~ubuntu-branches/ubuntu/raring/findutils/raring

ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO AMTAR install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM AWK SET_MAKE am__leading_dot CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE RANLIB ac_ct_RANLIB CPP EGREP ALLOCA ALLOCA_H LIBOBJS MKINSTALLDIRS MSGFMT GMSGFMT XGETTEXT MSGMERGE build build_cpu build_vendor build_os host host_cpu host_vendor host_os USE_NLS LIBICONV LTLIBICONV INTLLIBS LIBINTL LTLIBINTL POSUB LTLIBOBJS'

313

ac_subst_files=''

314

315

# Initialize some variables set by options.

316

ac_init_help=

317

ac_init_version=false

318

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

319

# dashes changed to underlines.

320

cache_file=/dev/null

321

exec_prefix=NONE

322

no_create=

323

no_recursion=

324

prefix=NONE

325

program_prefix=NONE

326

program_suffix=NONE

327

program_transform_name=s,x,x,

328

silent=

329

site=

330

srcdir=

331

verbose=

332

x_includes=NONE

333

x_libraries=NONE

334

335

# Installation directory options.

336

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

337

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

338

# by default will actually change.

339

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

340

bindir='${exec_prefix}/bin'

341

sbindir='${exec_prefix}/sbin'

342

libexecdir='${exec_prefix}/libexec'

343

datadir='${prefix}/share'

344

sysconfdir='${prefix}/etc'

345

sharedstatedir='${prefix}/com'

346

localstatedir='${prefix}/var'

347

libdir='${exec_prefix}/lib'

348

includedir='${prefix}/include'

349

oldincludedir='/usr/include'

350

infodir='${prefix}/info'

351

mandir='${prefix}/man'

352

353

ac_prev=

354

for ac_option

355

356

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

357

if test -n "$ac_prev"; then

358

eval "$ac_prev=\$ac_option"

359

ac_prev=

360

continue

361

362

363

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

364

365

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

366

367

case $ac_option in

368

369

370

ac_prev=bindir ;;

371

372

bindir=$ac_optarg ;;

373

374

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

375

ac_prev=build_alias ;;

376

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

377

build_alias=$ac_optarg ;;

378

379

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

380

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

381

ac_prev=cache_file ;;

382

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

383

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

384

cache_file=$ac_optarg ;;

385

386

--config-cache | -C)

387

cache_file=config.cache ;;

388

389

390

ac_prev=datadir ;;

391

392

| --da=*)

393

datadir=$ac_optarg ;;

394

395

-disable-* | --disable-*)

396

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

397

# Reject names that are not valid shell variable names.

398

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

399

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

400

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

401

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

402

eval "enable_$ac_feature=no" ;;

403

404

-enable-* | --enable-*)

405

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

406

# Reject names that are not valid shell variable names.

407

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

408

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

409

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

410

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

411

case $ac_option in

412

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

413

*) ac_optarg=yes ;;

414

esac

415

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

416

417

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

418

419

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

420

ac_prev=exec_prefix ;;

421

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

422

423

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

424

exec_prefix=$ac_optarg ;;

425

426

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

427

# Obsolete; use --with-gas.

428

with_gas=yes ;;

429

430

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

431

ac_init_help=long ;;

432

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

433

ac_init_help=recursive ;;

434

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

435

ac_init_help=short ;;

436

437

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

438

ac_prev=host_alias ;;

439

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

440

host_alias=$ac_optarg ;;

441

442

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

443

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

444

ac_prev=includedir ;;

445

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

446

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

447

includedir=$ac_optarg ;;

448

449

450

ac_prev=infodir ;;

451

452

infodir=$ac_optarg ;;

453

454

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

455

ac_prev=libdir ;;

456

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

457

libdir=$ac_optarg ;;

458

459

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

460

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

461

ac_prev=libexecdir ;;

462

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

463

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

464

libexecdir=$ac_optarg ;;

465

466

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

467

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

468

469

ac_prev=localstatedir ;;

470

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

471

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

472

473

localstatedir=$ac_optarg ;;

474

475

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

476

ac_prev=mandir ;;

477

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

478

mandir=$ac_optarg ;;

479

480

-nfp | --nfp | --nf)

481

# Obsolete; use --without-fp.

482

with_fp=no ;;

483

484

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

485

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

486

no_create=yes ;;

487

488

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

489

490

no_recursion=yes ;;

491

492

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

493

494

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

495

ac_prev=oldincludedir ;;

496

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

497

498

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

499

oldincludedir=$ac_optarg ;;

500

501

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

502

ac_prev=prefix ;;

503

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

504

prefix=$ac_optarg ;;

505

506

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

507

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

508

ac_prev=program_prefix ;;

509

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

510

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

511

program_prefix=$ac_optarg ;;

512

513

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

514

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

515

ac_prev=program_suffix ;;

516

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

517

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

518

program_suffix=$ac_optarg ;;

519

520

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

521

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

522

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

523

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

524

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

525

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

526

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

527

ac_prev=program_transform_name ;;

528

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

529

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

530

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

531

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

532

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

533

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

534

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

535

program_transform_name=$ac_optarg ;;

536

537

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

538

539

silent=yes ;;

540

541

542

ac_prev=sbindir ;;

543

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

544

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

545

sbindir=$ac_optarg ;;

546

547

-sharedstatedir | --sharedstatedir | --sharedstatedi \

548

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

549

550

| --sha | --sh)

551

ac_prev=sharedstatedir ;;

552

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

553

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

554

555

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

556

sharedstatedir=$ac_optarg ;;

557

558

-site | --site | --sit)

559

ac_prev=site ;;

560

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

561

site=$ac_optarg ;;

562

563

564

ac_prev=srcdir ;;

565

566

srcdir=$ac_optarg ;;

567

568

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

569

570

ac_prev=sysconfdir ;;

571

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

572

573

sysconfdir=$ac_optarg ;;

574

575

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

576

ac_prev=target_alias ;;

577

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

578

target_alias=$ac_optarg ;;

579

580

581

verbose=yes ;;

582

583

584

ac_init_version=: ;;

585

586

-with-* | --with-*)

587

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

588

# Reject names that are not valid shell variable names.

589

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

590

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

591

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

592

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

593

case $ac_option in

594

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

595

*) ac_optarg=yes ;;

596

esac

597

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

598

599

-without-* | --without-*)

600

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

601

# Reject names that are not valid shell variable names.

602

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

603

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

604

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

605

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

606

eval "with_$ac_package=no" ;;

607

608

--x)

609

# Obsolete; use --with-x.

610

with_x=yes ;;

611

612

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

613

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

614

ac_prev=x_includes ;;

615

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

616

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

617

x_includes=$ac_optarg ;;

618

619

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

620

621

ac_prev=x_libraries ;;

622

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

623

624

x_libraries=$ac_optarg ;;

625

626

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

627

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

628

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

629

;;

630

631

*=*)

632

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

633

# Reject names that are not valid shell variable names.

634

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

635

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

636

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

637

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

638

eval "$ac_envvar='$ac_optarg'"

639

export $ac_envvar ;;

640

641

642

# FIXME: should be removed in autoconf 3.0.

643

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

644

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

645

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

646

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

647

;;

648

649

esac

650

done

651

652

if test -n "$ac_prev"; then

653

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

654

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

655

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

656

657

658

# Be sure to have absolute paths.

659

for ac_var in exec_prefix prefix

660

661

eval ac_val=$`echo $ac_var`

662

case $ac_val in

663

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

664

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

665

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

666

esac

667

done

668

669

# Be sure to have absolute paths.

670

for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \

671

localstatedir libdir includedir oldincludedir infodir mandir

672

673

eval ac_val=$`echo $ac_var`

674

case $ac_val in

675

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

676

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

677

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

678

esac

679

done

680

681

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

682

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

683

# FIXME: To remove some day.

684

build=$build_alias

685

host=$host_alias

686

target=$target_alias

687

688

# FIXME: To remove some day.

689

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

690

if test "x$build_alias" = x; then

691

cross_compiling=maybe

692

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

693

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

694

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

695

cross_compiling=yes

696

697

698

699

ac_tool_prefix=

700

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

701

702

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

703

704

705

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

706

if test -z "$srcdir"; then

707

ac_srcdir_defaulted=yes

708

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

709

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

710

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

711

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

712

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

713

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

714

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

715

echo X"$0" |

716

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

717

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

718

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

719

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

720

s/.*/./; q'`

721

srcdir=$ac_confdir

722

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

723

srcdir=..

724

725

else

726

ac_srcdir_defaulted=no

727

728

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

729

if test "$ac_srcdir_defaulted" = yes; then

730

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

731

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

732

else

733

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

734

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

735

736

737

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

738

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

739

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

740

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

741

ac_env_build_alias_set=${build_alias+set}

742

ac_env_build_alias_value=$build_alias

743

ac_cv_env_build_alias_set=${build_alias+set}

744

ac_cv_env_build_alias_value=$build_alias

745

ac_env_host_alias_set=${host_alias+set}

746

ac_env_host_alias_value=$host_alias

747

ac_cv_env_host_alias_set=${host_alias+set}

748

ac_cv_env_host_alias_value=$host_alias

749

ac_env_target_alias_set=${target_alias+set}

750

ac_env_target_alias_value=$target_alias

751

ac_cv_env_target_alias_set=${target_alias+set}

752

ac_cv_env_target_alias_value=$target_alias

753

ac_env_CC_set=${CC+set}

754

ac_env_CC_value=$CC

755

ac_cv_env_CC_set=${CC+set}

756

ac_cv_env_CC_value=$CC

757

ac_env_CFLAGS_set=${CFLAGS+set}

758

ac_env_CFLAGS_value=$CFLAGS

759

ac_cv_env_CFLAGS_set=${CFLAGS+set}

760

ac_cv_env_CFLAGS_value=$CFLAGS

761

ac_env_LDFLAGS_set=${LDFLAGS+set}

762

ac_env_LDFLAGS_value=$LDFLAGS

763

ac_cv_env_LDFLAGS_set=${LDFLAGS+set}

764

ac_cv_env_LDFLAGS_value=$LDFLAGS

765

ac_env_CPPFLAGS_set=${CPPFLAGS+set}

766

ac_env_CPPFLAGS_value=$CPPFLAGS

767

ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}

768

ac_cv_env_CPPFLAGS_value=$CPPFLAGS

769

ac_env_CPP_set=${CPP+set}

770

ac_env_CPP_value=$CPP

771

ac_cv_env_CPP_set=${CPP+set}

772

ac_cv_env_CPP_value=$CPP

773

774

775

# Report the --help message.

776

777

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

778

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

779

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

780

cat <<_ACEOF

781

\`configure' configures dummy 0 to adapt to many kinds of systems.

782

783

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

784

785

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

786

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

787

788

Defaults for the options are specified in brackets.

789

790

Configuration:

791

-h, --help display this help and exit

792

--help=short display options specific to this package

793

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

794

-V, --version display version information and exit

795

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

796

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

797

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

798

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

799

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

800

801

_ACEOF

802

803

cat <<_ACEOF

804

Installation directories:

805

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

806

[$ac_default_prefix]

807

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

808

[PREFIX]

809

810

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

811

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

812

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

813

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

814

815

For better control, use the options below.

816

817

Fine tuning of the installation directories:

818

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

819

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

820

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

821

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

822

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

823

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

824

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

825

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

826

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

827

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

828

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

829

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

830

_ACEOF

831

832

cat <<\_ACEOF

833

834

Program names:

835

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

836

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

837

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

838

839

System types:

840

--build=BUILD configure for building on BUILD [guessed]

841

--host=HOST cross-compile to build programs to run on HOST [BUILD]

842

_ACEOF

843

844

845

if test -n "$ac_init_help"; then

846

case $ac_init_help in

847

short | recursive ) echo "Configuration of dummy 0:";;

848

esac

849

cat <<\_ACEOF

850

851

Optional Features:

852

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

853

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

854

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

855

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

856

--disable-rpath do not hardcode runtime library paths

857

--disable-nls do not use Native Language Support

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-gnu-ld assume the C compiler uses GNU ld default=no

863

--with-libiconv-prefix=DIR search for libiconv in DIR/include and DIR/lib

864

--without-libiconv-prefix don't search for libiconv in includedir and libdir

865

--with-libintl-prefix=DIR search for libintl in DIR/include and DIR/lib

866

--without-libintl-prefix don't search for libintl in includedir and libdir

867

--without-included-regex don't compile regex; this is the default on

868

systems with version 2 of the GNU C library

869

(use with caution on other system)

870

871

Some influential environment variables:

872

CC C compiler command

873

CFLAGS C compiler flags

874

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

875

nonstandard directory <lib dir>

876

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

877

headers in a nonstandard directory <include dir>

878

CPP C preprocessor

879

880

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

881

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

882

883

_ACEOF

884

885

886

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

887

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

888

ac_popdir=`pwd`

889

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

890

test -d $ac_dir || continue

891

ac_builddir=.

892

893

if test "$ac_dir" != .; then

894

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

895

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

896

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

897

else

898

ac_dir_suffix= ac_top_builddir=

899

900

901

case $srcdir in

902

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

903

ac_srcdir=.

904

if test -z "$ac_top_builddir"; then

905

ac_top_srcdir=.

906

else

907

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

908

fi ;;

909

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

910

ac_srcdir=$srcdir$ac_dir_suffix;

911

ac_top_srcdir=$srcdir ;;

912

*) # Relative path.

913

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

914

ac_top_srcdir=$ac_top_builddir$srcdir ;;

915

esac

916

# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be

917

# absolute.

918

ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`

919

ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`

920

ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`

921

ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`

922

923

cd $ac_dir

924

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

925

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

926

echo

927

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

928

elif test -f $ac_srcdir/configure; then

929

echo

930

$SHELL $ac_srcdir/configure --help=recursive

931

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

932

test -f $ac_srcdir/configure.in; then

933

echo

934

$ac_configure --help

935

else

936

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

937

938

cd $ac_popdir

939

done

940

941

942

test -n "$ac_init_help" && exit 0

943

if $ac_init_version; then

944

cat <<\_ACEOF

945

dummy configure 0

946

generated by GNU Autoconf 2.57

947

948

949

Free Software Foundation, Inc.

950

This configure script is free software; the Free Software Foundation

951

gives unlimited permission to copy, distribute and modify it.

952

_ACEOF

953

exit 0

954

955

exec 5>config.log

956

cat >&5 <<_ACEOF

957

This file contains any messages produced by compilers while

958

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

959

960

It was created by dummy $as_me 0, which was

961

generated by GNU Autoconf 2.57. Invocation command line was

962

963

$ $0 $@

964

965

_ACEOF

966

{

967

cat <<_ASUNAME

968

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

969

## Platform. ##

970

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

971

972

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

973

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

974

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

975

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

976

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

977

978

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

979

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

980

981

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

982

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

983

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

984

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

985

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

986

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

987

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

988

989

_ASUNAME

990

991

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

992

for as_dir in $PATH

993

994

IFS=$as_save_IFS

995

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

996

echo "PATH: $as_dir"

997

done

998

999

} >&5

1000

1001

cat >&5 <<_ACEOF

1002

1003

1004

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

1005

## Core tests. ##

1006

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

1007

1008

_ACEOF

1009

1010

1011

# Keep a trace of the command line.

1012

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

1013

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

1014

# Also quote any args containing shell meta-characters.

1015

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

1016

ac_configure_args=

1017

ac_configure_args0=

1018

ac_configure_args1=

1019

ac_sep=

1020

ac_must_keep_next=false

1021

for ac_pass in 1 2

1022

1023

for ac_arg

1024

1025

case $ac_arg in

1026

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

1027

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

1028

1029

continue ;;

1030

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

1031

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

1032

esac

1033

case $ac_pass in

1034

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

1035

1036

ac_configure_args1="$ac_configure_args1 '$ac_arg'"

1037

if test $ac_must_keep_next = true; then

1038

ac_must_keep_next=false # Got value, back to normal.

1039

else

1040

case $ac_arg in

1041

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

1042

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

1043

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

1044

1045

case "$ac_configure_args0 " in

1046

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

1047

esac

1048

;;

1049

-* ) ac_must_keep_next=true ;;

1050

esac

1051

1052

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

1053

# Get rid of the leading space.

1054

ac_sep=" "

1055

;;

1056

esac

1057

done

1058

done

1059

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

1060

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

1061

1062

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

1063

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

1064

# would cause problems or look ugly.

1065

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

1066

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

1067

trap 'exit_status=$?

1068

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

1069

{

1070

echo

1071

1072

cat <<\_ASBOX

1073

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

1074

## Cache variables. ##

1075

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

1076

_ASBOX

1077

echo

1078

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

1079

{

1080

(set) 2>&1 |

1081

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

1082

*ac_space=\ *)

1083

sed -n \

1084

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

1085

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

1086

;;

1087

1088

sed -n \

1089

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

1090

;;

1091

esac;

1092

}

1093

echo

1094

1095

cat <<\_ASBOX

1096

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

1097

## Output variables. ##

1098

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

1099

_ASBOX

1100

echo

1101

for ac_var in $ac_subst_vars

1102

1103

eval ac_val=$`echo $ac_var`

1104

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

1105

done | sort

1106

echo

1107

1108

if test -n "$ac_subst_files"; then

1109

cat <<\_ASBOX

1110

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

1111

## Output files. ##

1112

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

1113

_ASBOX

1114

echo

1115

for ac_var in $ac_subst_files

1116

1117

eval ac_val=$`echo $ac_var`

1118

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

1119

done | sort

1120

echo

1121

1122

1123

if test -s confdefs.h; then

1124

cat <<\_ASBOX

1125

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

1126

## confdefs.h. ##

1127

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

1128

_ASBOX

1129

echo

1130

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

1131

echo

1132

1133

test "$ac_signal" != 0 &&

1134

echo "$as_me: caught signal $ac_signal"

1135

echo "$as_me: exit $exit_status"

1136

} >&5

1137

rm -f core core.* *.core &&

1138

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

1139

exit $exit_status

1140

' 0

1141

for ac_signal in 1 2 13 15; do

1142

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

1143

done

1144

ac_signal=0

1145

1146

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

1147

rm -rf conftest* confdefs.h

1148

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

1149

echo >confdefs.h

1150

1151

# Predefined preprocessor variables.

1152

1153

cat >>confdefs.h <<_ACEOF

1154

#define PACKAGE_NAME "$PACKAGE_NAME"

1155

_ACEOF

1156

1157

1158

cat >>confdefs.h <<_ACEOF

1159

#define PACKAGE_TARNAME "$PACKAGE_TARNAME"

1160

_ACEOF

1161

1162

1163

cat >>confdefs.h <<_ACEOF

1164

#define PACKAGE_VERSION "$PACKAGE_VERSION"

1165

_ACEOF

1166

1167

1168

cat >>confdefs.h <<_ACEOF

1169

#define PACKAGE_STRING "$PACKAGE_STRING"

1170

_ACEOF

1171

1172

1173

cat >>confdefs.h <<_ACEOF

1174

#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"

1175

_ACEOF

1176

1177

1178

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

1179

# Prefer explicitly selected file to automatically selected ones.

1180

if test -z "$CONFIG_SITE"; then

1181

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

1182

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

1183

else

1184

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

1185

1186

1187

for ac_site_file in $CONFIG_SITE; do

1188

if test -r "$ac_site_file"; then

1189

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

1190

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

1191

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

1192

. "$ac_site_file"

1193

1194

done

1195

1196

if test -r "$cache_file"; then

1197

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

1198

# files actually), so we avoid doing that.

1199

if test -f "$cache_file"; then

1200

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

1201

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

1202

case $cache_file in

1203

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

1204

*) . ./$cache_file;;

1205

esac

1206

1207

else

1208

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

1209

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

1210

>$cache_file

1211

1212

1213

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

1214

# value.

1215

ac_cache_corrupted=false

1216

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

1217

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

1218

eval ac_old_set=\$ac_cv_env_${ac_var}_set

1219

eval ac_new_set=\$ac_env_${ac_var}_set

1220

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

1221

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

1222

case $ac_old_set,$ac_new_set in

1223

set,)

1224

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

1225

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

1226

ac_cache_corrupted=: ;;

1227

,set)

1228

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

1229

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

1230

ac_cache_corrupted=: ;;

1231

,);;

1232

1233

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

1234

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

1235

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

1236

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

1237

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

1238

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

1239

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

1240

ac_cache_corrupted=:

1241

fi;;

1242

esac

1243

# Pass precious variables to config.status.

1244

if test "$ac_new_set" = set; then

1245

case $ac_new_val in

1246

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

1247

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

1248

*) ac_arg=$ac_var=$ac_new_val ;;

1249

esac

1250

case " $ac_configure_args " in

1251

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

1252

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

1253

esac

1254

1255

done

1256

if $ac_cache_corrupted; then

1257

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

1258

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

1259

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

1260

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

1261

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

1262

1263

1264

ac_ext=c

1265

ac_cpp='$CPP $CPPFLAGS'

1266

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

1267

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

1268

ac_compiler_gnu=$ac_cv_c_compiler_gnu

1269

1270

1271

gl_header_list="$gl_header_list stdlib.h"

1272

gl_header_list="$gl_header_list string.h"

1273

gl_header_list="$gl_header_list sys/param.h"

1274

gl_header_list="$gl_header_list unistd.h"

1275

gl_header_list="$gl_header_list limits.h"

1276

gl_header_list="$gl_header_list stddef.h"

1277

gl_header_list="$gl_header_list wchar.h"

1278

gl_header_list="$gl_header_list wctype.h"

1279

gl_func_list="$gl_func_list iswprint"

1280

gl_func_list="$gl_func_list mbsinit"

1281

gl_func_list="$gl_func_list isascii"

1282

gl_func_list="$gl_func_list mempcpy"

1283

gl_func_list="$gl_func_list memcpy"

1284

gl_header_list="$gl_header_list sys/time.h"

1285

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1308

1309

1310

am__api_version="1.7"

1311

ac_aux_dir=

1312

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

1313

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

1314

ac_aux_dir=$ac_dir

1315

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

1316

break

1317

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

1318

ac_aux_dir=$ac_dir

1319

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

1320

break

1321

elif test -f $ac_dir/shtool; then

1322

ac_aux_dir=$ac_dir

1323

ac_install_sh="$ac_aux_dir/shtool install -c"

1324

break

1325

1326

done

1327

if test -z "$ac_aux_dir"; then

1328

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

1329

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

1330

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

1331

1332

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

1333

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

1334

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

1335

1336

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

1337

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

1338

# incompatible versions:

1339

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

1340

# SunOS /usr/etc/install

1341

# IRIX /sbin/install

1342

# AIX /bin/install

1343

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

1344

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

1345

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

1346

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

1347

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

1348

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

1349

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

1350

if test -z "$INSTALL"; then

1351

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

1352

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

1353

else

1354

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1355

for as_dir in $PATH

1356

1357

IFS=$as_save_IFS

1358

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

1359

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

1360

case $as_dir/ in

1361

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

1362

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

1363

/usr/ucb/* ) ;;

1364

1365

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

1366

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

1367

# by default.

1368

for ac_prog in ginstall scoinst install; do

1369

for ac_exec_ext in '' $ac_executable_extensions; do

1370

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

1371

if test $ac_prog = install &&

1372

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

1373

# AIX install. It has an incompatible calling convention.

1374

1375

elif test $ac_prog = install &&

1376

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

1377

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

1378

1379

else

1380

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

1381

break 3

1382

1383

1384

done

1385

done

1386

;;

1387

esac

1388

done

1389

1390

1391

1392

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

1393

INSTALL=$ac_cv_path_install

1394

else

1395

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

1396

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

1397

# break other packages using the cache if that directory is

1398

# removed, or if the path is relative.

1399

INSTALL=$ac_install_sh

1400

1401

1402

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

1403

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

1404

1405

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

1406

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

1407

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

1408

1409

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

1410

1411

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

1412

1413

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

1414

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

1415

# Just in case

1416

sleep 1

1417

echo timestamp > conftest.file

1418

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

1419

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

1420

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

1421

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

1422

# directory).

1423

if (

1424

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

1425

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

1426

# -L didn't work.

1427

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

1428

1429

rm -f conftest.file

1430

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

1431

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

1432

1433

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

1434

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

1435

# broken ls alias from the environment. This has actually

1436

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

1437

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

1438

alias in your environment" >&5

1439

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

1440

alias in your environment" >&2;}

1441

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

1442

1443

1444

test "$2" = conftest.file

1445

)

1446

then

1447

# Ok.

1448

1449

else

1450

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

1451

Check your system clock" >&5

1452

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

1453

Check your system clock" >&2;}

1454

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

1455

1456

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

1457

echo "${ECHO_T}yes" >&6

1458

test "$program_prefix" != NONE &&

1459

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

1460

# Use a double $ so make ignores it.

1461

test "$program_suffix" != NONE &&

1462

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

1463

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

1464

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

1465

cat <<\_ACEOF >conftest.sed

1466

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

1467

_ACEOF

1468

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

1469

rm conftest.sed

1470

1471

1472

# expand $ac_aux_dir to an absolute path

1473

am_aux_dir=`cd $ac_aux_dir && pwd`

1474

1475

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

1476

# Use eval to expand $SHELL

1477

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

1478

am_missing_run="$MISSING --run "

1479

else

1480

am_missing_run=

1481

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

1482

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

1483

1484

1485

for ac_prog in gawk mawk nawk awk

1486

1487

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

1488

set dummy $ac_prog; ac_word=$2

1489

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

1490

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

1491

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

1492

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

1493

else

1494

if test -n "$AWK"; then

1495

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

1496

else

1497

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1498

for as_dir in $PATH

1499

1500

IFS=$as_save_IFS

1501

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

1502

for ac_exec_ext in '' $ac_executable_extensions; do

1503

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

1504

ac_cv_prog_AWK="$ac_prog"

1505

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

1506

break 2

1507

1508

done

1509

done

1510

1511

1512

1513

AWK=$ac_cv_prog_AWK

1514

if test -n "$AWK"; then

1515

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

1516

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

1517

else

1518

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

1519

echo "${ECHO_T}no" >&6

1520

1521

1522

test -n "$AWK" && break

1523

done

1524

1525

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

1526

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

1527

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

1528

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

1529

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

1530

else

1531

cat >conftest.make <<\_ACEOF

1532

all:

1533

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

1534

_ACEOF

1535

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

1536

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

1537

if test -n "$ac_maketemp"; then

1538

eval ac_cv_prog_make_${ac_make}_set=yes

1539

else

1540

eval ac_cv_prog_make_${ac_make}_set=no

1541

1542

rm -f conftest.make

1543

1544

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

1545

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

1546

echo "${ECHO_T}yes" >&6

1547

SET_MAKE=

1548

else

1549

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

1550

echo "${ECHO_T}no" >&6

1551

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

1552

1553

1554

rm -rf .tst 2>/dev/null

1555

mkdir .tst 2>/dev/null

1556

if test -d .tst; then

1557

am__leading_dot=.

1558

else

1559

am__leading_dot=_

1560

1561

rmdir .tst 2>/dev/null

1562

1563

# test to see if srcdir already configured

1564

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

1565

test -f $srcdir/config.status; then

1566

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

1567

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

1568

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

1569

1570

1571

# test whether we have cygpath

1572

if test -z "$CYGPATH_W"; then

1573

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

1574

CYGPATH_W='cygpath -w'

1575

else

1576

CYGPATH_W=echo

1577

1578

1579

1580

1581

# Define the identity of the package.

1582

PACKAGE='dummy'

1583

VERSION='0'

1584

1585

1586

cat >>confdefs.h <<_ACEOF

1587

#define PACKAGE "$PACKAGE"

1588

_ACEOF

1589

1590

1591

cat >>confdefs.h <<_ACEOF

1592

#define VERSION "$VERSION"

1593

_ACEOF

1594

1595

# Some tools Automake needs.

1596

1597

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

1598

1599

1600

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

1601

1602

1603

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

1604

1605

1606

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

1607

1608

1609

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

1610

1611

1612

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

1613

1614

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

1615

1616

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

1617

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

1618

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

1619

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

1620

if test "$cross_compiling" != no; then

1621

if test -n "$ac_tool_prefix"; then

1622

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

1623

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

1624

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

1625

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

1626

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

1627

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

1628

else

1629

if test -n "$STRIP"; then

1630

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

1631

else

1632

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1633

for as_dir in $PATH

1634

1635

IFS=$as_save_IFS

1636

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

1637

for ac_exec_ext in '' $ac_executable_extensions; do

1638

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

1639

ac_cv_prog_STRIP="${ac_tool_prefix}strip"

1640

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

1641

break 2

1642

1643

done

1644

done

1645

1646

1647

1648

STRIP=$ac_cv_prog_STRIP

1649

if test -n "$STRIP"; then

1650

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

1651

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

1652

else

1653

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

1654

echo "${ECHO_T}no" >&6

1655

1656

1657

1658

if test -z "$ac_cv_prog_STRIP"; then

1659

ac_ct_STRIP=$STRIP

1660

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

1661

set dummy strip; ac_word=$2

1662

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

1663

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

1664

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

1665

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

1666

else

1667

if test -n "$ac_ct_STRIP"; then

1668

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

1669

else

1670

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1671

for as_dir in $PATH

1672

1673

IFS=$as_save_IFS

1674

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

1675

for ac_exec_ext in '' $ac_executable_extensions; do

1676

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

1677

ac_cv_prog_ac_ct_STRIP="strip"

1678

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

1679

break 2

1680

1681

done

1682

done

1683

1684

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

1685

1686

1687

ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP

1688

if test -n "$ac_ct_STRIP"; then

1689

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

1690

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

1691

else

1692

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

1693

echo "${ECHO_T}no" >&6

1694

1695

1696

STRIP=$ac_ct_STRIP

1697

else

1698

STRIP="$ac_cv_prog_STRIP"

1699

1700

1701

1702

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

1703

1704

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

1705

# some platforms.

1706

1707

1708

1709

1710

ac_config_headers="$ac_config_headers config.h"

1711

1712

1713

ac_ext=c

1714

ac_cpp='$CPP $CPPFLAGS'

1715

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

1716

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

1717

ac_compiler_gnu=$ac_cv_c_compiler_gnu

1718

if test -n "$ac_tool_prefix"; then

1719

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

1720

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

1721

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

1722

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

1723

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

1724

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

1725

else

1726

if test -n "$CC"; then

1727

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

1728

else

1729

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1730

for as_dir in $PATH

1731

1732

IFS=$as_save_IFS

1733

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

1734

for ac_exec_ext in '' $ac_executable_extensions; do

1735

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

1736

ac_cv_prog_CC="${ac_tool_prefix}gcc"

1737

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

1738

break 2

1739

1740

done

1741

done

1742

1743

1744

1745

CC=$ac_cv_prog_CC

1746

if test -n "$CC"; then

1747

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

1748

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

1749

else

1750

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

1751

echo "${ECHO_T}no" >&6

1752

1753

1754

1755

if test -z "$ac_cv_prog_CC"; then

1756

ac_ct_CC=$CC

1757

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

1758

set dummy gcc; ac_word=$2

1759

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

1760

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

1761

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

1762

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

1763

else

1764

if test -n "$ac_ct_CC"; then

1765

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

1766

else

1767

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1768

for as_dir in $PATH

1769

1770

IFS=$as_save_IFS

1771

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

1772

for ac_exec_ext in '' $ac_executable_extensions; do

1773

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

1774

ac_cv_prog_ac_ct_CC="gcc"

1775

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

1776

break 2

1777

1778

done

1779

done

1780

1781

1782

1783

ac_ct_CC=$ac_cv_prog_ac_ct_CC

1784

if test -n "$ac_ct_CC"; then

1785

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

1786

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

1787

else

1788

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

1789

echo "${ECHO_T}no" >&6

1790

1791

1792

CC=$ac_ct_CC

1793

else

1794

CC="$ac_cv_prog_CC"

1795

1796

1797

if test -z "$CC"; then

1798

if test -n "$ac_tool_prefix"; then

1799

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

1800

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

1801

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

1802

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

1803

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

1804

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

1805

else

1806

if test -n "$CC"; then

1807

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

1808

else

1809

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1810

for as_dir in $PATH

1811

1812

IFS=$as_save_IFS

1813

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

1814

for ac_exec_ext in '' $ac_executable_extensions; do

1815

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

1816

ac_cv_prog_CC="${ac_tool_prefix}cc"

1817

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

1818

break 2

1819

1820

done

1821

done

1822

1823

1824

1825

CC=$ac_cv_prog_CC

1826

if test -n "$CC"; then

1827

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

1828

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

1829

else

1830

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

1831

echo "${ECHO_T}no" >&6

1832

1833

1834

1835

if test -z "$ac_cv_prog_CC"; then

1836

ac_ct_CC=$CC

1837

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

1838

set dummy cc; ac_word=$2

1839

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

1840

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

1841

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

1842

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

1843

else

1844

if test -n "$ac_ct_CC"; then

1845

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

1846

else

1847

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1848

for as_dir in $PATH

1849

1850

IFS=$as_save_IFS

1851

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

1852

for ac_exec_ext in '' $ac_executable_extensions; do

1853

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

1854

ac_cv_prog_ac_ct_CC="cc"

1855

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

1856

break 2

1857

1858

done

1859

done

1860

1861

1862

1863

ac_ct_CC=$ac_cv_prog_ac_ct_CC

1864

if test -n "$ac_ct_CC"; then

1865

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

1866

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

1867

else

1868

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

1869

echo "${ECHO_T}no" >&6

1870

1871

1872

CC=$ac_ct_CC

1873

else

1874

CC="$ac_cv_prog_CC"

1875

1876

1877

1878

if test -z "$CC"; then

1879

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

1880

set dummy cc; ac_word=$2

1881

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

1882

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

1883

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

1884

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

1885

else

1886

if test -n "$CC"; then

1887

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

1888

else

1889

ac_prog_rejected=no

1890

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1891

for as_dir in $PATH

1892

1893

IFS=$as_save_IFS

1894

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

1895

for ac_exec_ext in '' $ac_executable_extensions; do

1896

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

1897

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

1898

ac_prog_rejected=yes

1899

continue

1900

1901

ac_cv_prog_CC="cc"

1902

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

1903

break 2

1904

1905

done

1906

done

1907

1908

if test $ac_prog_rejected = yes; then

1909

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

1910

set dummy $ac_cv_prog_CC

1911

shift

1912

if test $# != 0; then

1913

# We chose a different compiler from the bogus one.

1914

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

1915

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

1916

shift

1917

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

1918

1919

1920

1921

1922

CC=$ac_cv_prog_CC

1923

if test -n "$CC"; then

1924

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

1925

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

1926

else

1927

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

1928

echo "${ECHO_T}no" >&6

1929

1930

1931

1932

if test -z "$CC"; then

1933

if test -n "$ac_tool_prefix"; then

1934

for ac_prog in cl

1935

1936

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

1937

set dummy $ac_tool_prefix$ac_prog; ac_word=$2

1938

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

1939

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

1940

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

1941

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

1942

else

1943

if test -n "$CC"; then

1944

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

1945

else

1946

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1947

for as_dir in $PATH

1948

1949

IFS=$as_save_IFS

1950

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

1951

for ac_exec_ext in '' $ac_executable_extensions; do

1952

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

1953

ac_cv_prog_CC="$ac_tool_prefix$ac_prog"

1954

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

1955

break 2

1956

1957

done

1958

done

1959

1960

1961

1962

CC=$ac_cv_prog_CC

1963

if test -n "$CC"; then

1964

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

1965

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

1966

else

1967

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

1968

echo "${ECHO_T}no" >&6

1969

1970

1971

test -n "$CC" && break

1972

done

1973

1974

if test -z "$CC"; then

1975

ac_ct_CC=$CC

1976

for ac_prog in cl

1977

1978

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

1979

set dummy $ac_prog; ac_word=$2

1980

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

1981

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

1982

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

1983

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

1984

else

1985

if test -n "$ac_ct_CC"; then

1986

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

1987

else

1988

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1989

for as_dir in $PATH

1990

1991

IFS=$as_save_IFS

1992

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

1993

for ac_exec_ext in '' $ac_executable_extensions; do

1994

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

1995

ac_cv_prog_ac_ct_CC="$ac_prog"

1996

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

1997

break 2

1998

1999

done

2000

done

2001

2002

2003

2004

ac_ct_CC=$ac_cv_prog_ac_ct_CC

2005

if test -n "$ac_ct_CC"; then

2006

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

2007

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

2008

else

2009

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

2010

echo "${ECHO_T}no" >&6

2011

2012

2013

test -n "$ac_ct_CC" && break

2014

done

2015

2016

CC=$ac_ct_CC

2017

2018

2019

2020

2021

2022

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

2023

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

2024

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

2025

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

2026

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

2027

2028

# Provide some information about the compiler.

2029

echo "$as_me:$LINENO:" \

2030

"checking for C compiler version" >&5

2031

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

2032

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

2033

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

2034

ac_status=$?

2035

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

2036

(exit $ac_status); }

2037

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

2038

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

2039

ac_status=$?

2040

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

2041

(exit $ac_status); }

2042

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

2043

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

2044

ac_status=$?

2045

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

2046

(exit $ac_status); }

2047

2048

cat >conftest.$ac_ext <<_ACEOF

2049

#line $LINENO "configure"

2050

/* confdefs.h. */

2051

_ACEOF

2052

cat confdefs.h >>conftest.$ac_ext

2053

cat >>conftest.$ac_ext <<_ACEOF

2054

/* end confdefs.h. */

2055

2056

int

2057

main ()

2058

{

2059

2060

;

2061

return 0;

2062

}

2063

_ACEOF

2064

ac_clean_files_save=$ac_clean_files

2065

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

2066

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

2067

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

2068

# of exeext.

2069

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

2070

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

2071

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

2072

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

2073

(eval $ac_link_default) 2>&5

2074

ac_status=$?

2075

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

2076

(exit $ac_status); }; then

2077

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

2078

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

2079

# resort.

2080

2081

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

2082

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

2083

ac_cv_exeext=

2084

# b.out is created by i960 compilers.

2085

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

2086

2087

test -f "$ac_file" || continue

2088

case $ac_file in

2089

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

2090

;;

2091

conftest.$ac_ext )

2092

# This is the source file.

2093

;;

2094

[ab].out )

2095

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

2096

# certainly right.

2097

break;;

2098

*.* )

2099

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

2100

# FIXME: I believe we export ac_cv_exeext for Libtool,

2101

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

2102

# maintain Libtool? --akim.

2103

export ac_cv_exeext

2104

break;;

2105

* )

2106

break;;

2107

esac

2108

done

2109

else

2110

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

2111

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

2112

2113

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

2114

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

2115

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

2116

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

2117

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

2118

2119

2120

ac_exeext=$ac_cv_exeext

2121

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

2122

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

2123

2124

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

2125

# the compiler is broken, or we cross compile.

2126

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

2127

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

2128

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

2129

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

2130

if test "$cross_compiling" != yes; then

2131

if { ac_try='./$ac_file'

2132

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

2133

(eval $ac_try) 2>&5

2134

ac_status=$?

2135

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

2136

(exit $ac_status); }; }; then

2137

cross_compiling=no

2138

else

2139

if test "$cross_compiling" = maybe; then

2140

cross_compiling=yes

2141

else

2142

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

2143

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

2144

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

2145

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

2146

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

2147

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

2148

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

2149

2150

2151

2152

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

2153

echo "${ECHO_T}yes" >&6

2154

2155

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

2156

ac_clean_files=$ac_clean_files_save

2157

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

2158

# the compiler is broken, or we cross compile.

2159

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

2160

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

2161

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

2162

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

2163

2164

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

2165

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

2166

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

2167

(eval $ac_link) 2>&5

2168

ac_status=$?

2169

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

2170

(exit $ac_status); }; then

2171

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

2172

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

2173

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

2174

# `rm'.

2175

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

2176

test -f "$ac_file" || continue

2177

case $ac_file in

2178

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

2179

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

2180

export ac_cv_exeext

2181

break;;

2182

* ) break;;

2183

esac

2184

done

2185

else

2186

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

2187

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

2188

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

2189

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

2190

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

2191

2192

2193

rm -f conftest$ac_cv_exeext

2194

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

2195

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

2196

2197

rm -f conftest.$ac_ext

2198

EXEEXT=$ac_cv_exeext

2199

ac_exeext=$EXEEXT

2200

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

2201

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

2202

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

2203

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

2204

else

2205

cat >conftest.$ac_ext <<_ACEOF

2206

#line $LINENO "configure"

2207

/* confdefs.h. */

2208

_ACEOF

2209

cat confdefs.h >>conftest.$ac_ext

2210

cat >>conftest.$ac_ext <<_ACEOF

2211

/* end confdefs.h. */

2212

2213

int

2214

main ()

2215

{

2216

2217

;

2218

return 0;

2219

}

2220

_ACEOF

2221

rm -f conftest.o conftest.obj

2222

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

2223

(eval $ac_compile) 2>&5

2224

ac_status=$?

2225

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

2226

(exit $ac_status); }; then

2227

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

2228

case $ac_file in

2229

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

2230

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

2231

break;;

2232

esac

2233

done

2234

else

2235

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

2236

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

2237

2238

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

2239

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

2240

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

2241

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

2242

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

2243

2244

2245

rm -f conftest.$ac_cv_objext conftest.$ac_ext

2246

2247

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

2248

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

2249

OBJEXT=$ac_cv_objext

2250

ac_objext=$OBJEXT

2251

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

2252

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

2253

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

2254

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

2255

else

2256

cat >conftest.$ac_ext <<_ACEOF

2257

#line $LINENO "configure"

2258

/* confdefs.h. */

2259

_ACEOF

2260

cat confdefs.h >>conftest.$ac_ext

2261

cat >>conftest.$ac_ext <<_ACEOF

2262

/* end confdefs.h. */

2263

2264

int

2265

main ()

2266

{

2267

#ifndef __GNUC__

2268

choke me

2269

#endif

2270

2271

;

2272

return 0;

2273

}

2274

_ACEOF

2275

rm -f conftest.$ac_objext

2276

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

2277

(eval $ac_compile) 2>&5

2278

ac_status=$?

2279

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

2280

(exit $ac_status); } &&

2281

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

2282

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

2283

(eval $ac_try) 2>&5

2284

ac_status=$?

2285

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

2286

(exit $ac_status); }; }; then

2287

ac_compiler_gnu=yes

2288

else

2289

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

2290

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

2291

2292

ac_compiler_gnu=no

2293

2294

rm -f conftest.$ac_objext conftest.$ac_ext

2295

ac_cv_c_compiler_gnu=$ac_compiler_gnu

2296

2297

2298

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

2299

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

2300

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

2301

ac_test_CFLAGS=${CFLAGS+set}

2302

ac_save_CFLAGS=$CFLAGS

2303

CFLAGS="-g"

2304

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

2305

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

2306

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

2307

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

2308

else

2309

cat >conftest.$ac_ext <<_ACEOF

2310

#line $LINENO "configure"

2311

/* confdefs.h. */

2312

_ACEOF

2313

cat confdefs.h >>conftest.$ac_ext

2314

cat >>conftest.$ac_ext <<_ACEOF

2315

/* end confdefs.h. */

2316

2317

int

2318

main ()

2319

{

2320

2321

;

2322

return 0;

2323

}

2324

_ACEOF

2325

rm -f conftest.$ac_objext

2326

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

2327

(eval $ac_compile) 2>&5

2328

ac_status=$?

2329

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

2330

(exit $ac_status); } &&

2331

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

2332

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

2333

(eval $ac_try) 2>&5

2334

ac_status=$?

2335

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

2336

(exit $ac_status); }; }; then

2337

ac_cv_prog_cc_g=yes

2338

else

2339

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

2340

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

2341

2342

ac_cv_prog_cc_g=no

2343

2344

rm -f conftest.$ac_objext conftest.$ac_ext

2345

2346

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

2347

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

2348

if test "$ac_test_CFLAGS" = set; then

2349

CFLAGS=$ac_save_CFLAGS

2350

elif test $ac_cv_prog_cc_g = yes; then

2351

if test "$GCC" = yes; then

2352

CFLAGS="-g -O2"

2353

else

2354

CFLAGS="-g"

2355

2356

else

2357

if test "$GCC" = yes; then

2358

CFLAGS="-O2"

2359

else

2360

CFLAGS=

2361

2362

2363

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

2364

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

2365

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

2366

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

2367

else

2368

ac_cv_prog_cc_stdc=no

2369

ac_save_CC=$CC

2370

cat >conftest.$ac_ext <<_ACEOF

2371

#line $LINENO "configure"

2372

/* confdefs.h. */

2373

_ACEOF

2374

cat confdefs.h >>conftest.$ac_ext

2375

cat >>conftest.$ac_ext <<_ACEOF

2376

/* end confdefs.h. */

2377

#include <stdarg.h>

2378

#include <stdio.h>

2379

#include <sys/types.h>

2380

#include <sys/stat.h>

2381

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

2382

struct buf { int x; };

2383

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

2384

static char *e (p, i)

2385

char **p;

2386

int i;

2387

{

2388

return p[i];

2389

}

2390

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

2391

{

2392

char *s;

2393

va_list v;

2394

va_start (v,p);

2395

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

2396

va_end (v);

2397

return s;

2398

}

2399

int test (int i, double x);

2400

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

2401

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

2402

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

2403

int argc;

2404

char **argv;

2405

int

2406

main ()

2407

{

2408

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

2409

;

2410

return 0;

2411

}

2412

_ACEOF

2413

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

2414

# breaks some systems' header files.

2415

# AIX -qlanglvl=ansi

2416

# Ultrix and OSF/1 -std1

2417

# HP-UX 10.20 and later -Ae

2418

# HP-UX older versions -Aa -D_HPUX_SOURCE

2419

# SVR4 -Xc -D__EXTENSIONS__

2420

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

2421

2422

CC="$ac_save_CC $ac_arg"

2423

rm -f conftest.$ac_objext

2424

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

2425

(eval $ac_compile) 2>&5

2426

ac_status=$?

2427

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

2428

(exit $ac_status); } &&

2429

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

2430

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

2431

(eval $ac_try) 2>&5

2432

ac_status=$?

2433

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

2434

(exit $ac_status); }; }; then

2435

ac_cv_prog_cc_stdc=$ac_arg

2436

break

2437

else

2438

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

2439

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

2440

2441

2442

rm -f conftest.$ac_objext

2443

done

2444

rm -f conftest.$ac_ext conftest.$ac_objext

2445

CC=$ac_save_CC

2446

2447

2448

2449

case "x$ac_cv_prog_cc_stdc" in

2450

x|xno)

2451

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

2452

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

2453

2454

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

2455

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

2456

CC="$CC $ac_cv_prog_cc_stdc" ;;

2457

esac

2458

2459

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

2460

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

2461

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

2462

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

2463

cat >conftest.$ac_ext <<_ACEOF

2464

#ifndef __cplusplus

2465

choke me

2466

#endif

2467

_ACEOF

2468

rm -f conftest.$ac_objext

2469

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

2470

(eval $ac_compile) 2>&5

2471

ac_status=$?

2472

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

2473

(exit $ac_status); } &&

2474

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

2475

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

2476

(eval $ac_try) 2>&5

2477

ac_status=$?

2478

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

2479

(exit $ac_status); }; }; then

2480

for ac_declaration in \

2481

''\

2482

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

2483

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

2484

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

2485

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

2486

'void exit (int);' \

2487

'#include <stdlib.h>'

2488

2489

cat >conftest.$ac_ext <<_ACEOF

2490

#line $LINENO "configure"

2491

/* confdefs.h. */

2492

_ACEOF

2493

cat confdefs.h >>conftest.$ac_ext

2494

cat >>conftest.$ac_ext <<_ACEOF

2495

/* end confdefs.h. */

2496

#include <stdlib.h>

2497

$ac_declaration

2498

int

2499

main ()

2500

{

2501

exit (42);

2502

;

2503

return 0;

2504

}

2505

_ACEOF

2506

rm -f conftest.$ac_objext

2507

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

2508

(eval $ac_compile) 2>&5

2509

ac_status=$?

2510

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

2511

(exit $ac_status); } &&

2512

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

2513

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

2514

(eval $ac_try) 2>&5

2515

ac_status=$?

2516

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

2517

(exit $ac_status); }; }; then

2518

2519

else

2520

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

2521

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

2522

2523

continue

2524

2525

rm -f conftest.$ac_objext conftest.$ac_ext

2526

cat >conftest.$ac_ext <<_ACEOF

2527

#line $LINENO "configure"

2528

/* confdefs.h. */

2529

_ACEOF

2530

cat confdefs.h >>conftest.$ac_ext

2531

cat >>conftest.$ac_ext <<_ACEOF

2532

/* end confdefs.h. */

2533

$ac_declaration

2534

int

2535

main ()

2536

{

2537

exit (42);

2538

;

2539

return 0;

2540

}

2541

_ACEOF

2542

rm -f conftest.$ac_objext

2543

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

2544

(eval $ac_compile) 2>&5

2545

ac_status=$?

2546

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

2547

(exit $ac_status); } &&

2548

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

2549

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

2550

(eval $ac_try) 2>&5

2551

ac_status=$?

2552

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

2553

(exit $ac_status); }; }; then

2554

break

2555

else

2556

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

2557

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

2558

2559

2560

rm -f conftest.$ac_objext conftest.$ac_ext

2561

done

2562

rm -f conftest*

2563

if test -n "$ac_declaration"; then

2564

echo '#ifdef __cplusplus' >>confdefs.h

2565

echo $ac_declaration >>confdefs.h

2566

echo '#endif' >>confdefs.h

2567

2568

2569

else

2570

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

2571

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

2572

2573

2574

rm -f conftest.$ac_objext conftest.$ac_ext

2575

ac_ext=c

2576

ac_cpp='$CPP $CPPFLAGS'

2577

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

2578

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

2579

ac_compiler_gnu=$ac_cv_c_compiler_gnu

2580

DEPDIR="${am__leading_dot}deps"

2581

2582

ac_config_commands="$ac_config_commands depfiles"

2583

2584

2585

am_make=${MAKE-make}

2586

cat > confinc << 'END'

2587

am__doit:

2588

@echo done

2589

.PHONY: am__doit

2590

END

2591

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

2592

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

2593

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

2594

am__include="#"

2595

am__quote=

2596

_am_result=none

2597

# First try GNU make style include.

2598

echo "include confinc" > confmf

2599

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

2600

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

2601

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

2602

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

2603

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

2604

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

2605

am__include=include

2606

am__quote=

2607

_am_result=GNU

2608

2609

# Now try BSD make style include.

2610

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

2611

echo '.include "confinc"' > confmf

2612

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

2613

am__include=.include

2614

am__quote="\""

2615

_am_result=BSD

2616

2617

2618

2619

2620

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

2621

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

2622

rm -f confinc confmf

2623

2624

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

2625

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

2626

enableval="$enable_dependency_tracking"

2627

2628

fi;

2629

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

2630

am_depcomp="$ac_aux_dir/depcomp"

2631

AMDEPBACKSLASH='\'

2632

2633

2634

2635

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

2636

AMDEP_TRUE=

2637

AMDEP_FALSE='#'

2638

else

2639

AMDEP_TRUE='#'

2640

AMDEP_FALSE=

2641

2642

2643

2644

2645

2646

depcc="$CC" am_compiler_list=

2647

2648

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

2649

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

2650

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

2651

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

2652

else

2653

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

2654

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

2655

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

2656

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

2657

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

2658

# in D'.

2659

mkdir conftest.dir

2660

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

2661

# using a relative directory.

2662

cp "$am_depcomp" conftest.dir

2663

cd conftest.dir

2664

2665

am_cv_CC_dependencies_compiler_type=none

2666

if test "$am_compiler_list" = ""; then

2667

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

2668

2669

for depmode in $am_compiler_list; do

2670

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

2671

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

2672

# This happens at least with the AIX C compiler.

2673

echo '#include "conftest.h"' > conftest.c

2674

echo 'int i;' > conftest.h

2675

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

2676

2677

case $depmode in

2678

nosideeffect)

2679

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

2680

# only be used when explicitly requested

2681

if test "x$enable_dependency_tracking" = xyes; then

2682

continue

2683

else

2684

break

2685

2686

;;

2687

none) break ;;

2688

esac

2689

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

2690

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

2691

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

2692

if depmode=$depmode \

2693

source=conftest.c object=conftest.o \

2694

depfile=conftest.Po tmpdepfile=conftest.TPo \

2695

$SHELL ./depcomp $depcc -c -o conftest.o conftest.c \

2696

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

2697

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

2698

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

2699

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

2700

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

2701

# that says an option was ignored.

2702

if grep 'ignoring option' conftest.err >/dev/null 2>&1; then :; else

2703

am_cv_CC_dependencies_compiler_type=$depmode

2704

break

2705

2706

2707

done

2708

2709

cd ..

2710

rm -rf conftest.dir

2711

else

2712

am_cv_CC_dependencies_compiler_type=none

2713

2714

2715

2716

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

2717

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

2718

CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

2719

2720

2721

2722

2723

test "x$enable_dependency_tracking" != xno \

2724

&& test "$am_cv_CC_dependencies_compiler_type" = gcc3; then

2725

am__fastdepCC_TRUE=

2726

am__fastdepCC_FALSE='#'

2727

else

2728

am__fastdepCC_TRUE='#'

2729

am__fastdepCC_FALSE=

2730

2731

2732

2733

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

2734

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

2735

# incompatible versions:

2736

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

2737

# SunOS /usr/etc/install

2738

# IRIX /sbin/install

2739

# AIX /bin/install

2740

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

2741

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

2742

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

2743

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

2744

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

2745

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

2746

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

2747

if test -z "$INSTALL"; then

2748

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

2749

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

2750

else

2751

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2752

for as_dir in $PATH

2753

2754

IFS=$as_save_IFS

2755

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

2756

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

2757

case $as_dir/ in

2758

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

2759

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

2760

/usr/ucb/* ) ;;

2761

2762

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

2763

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

2764

# by default.

2765

for ac_prog in ginstall scoinst install; do

2766

for ac_exec_ext in '' $ac_executable_extensions; do

2767

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

2768

if test $ac_prog = install &&

2769

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

2770

# AIX install. It has an incompatible calling convention.

2771

2772

elif test $ac_prog = install &&

2773

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

2774

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

2775

2776

else

2777

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

2778

break 3

2779

2780

2781

done

2782

done

2783

;;

2784

esac

2785

done

2786

2787

2788

2789

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

2790

INSTALL=$ac_cv_path_install

2791

else

2792

# As a last resort, use the slow shell script. We don't cache a

2793

# path for INSTALL within a source directory, because that will

2794

# break other packages using the cache if that directory is

2795

# removed, or if the path is relative.

2796

INSTALL=$ac_install_sh

2797

2798

2799

echo "$as_me:$LINENO: result: $INSTALL" >&5

2800

echo "${ECHO_T}$INSTALL" >&6

2801

2802

# Use test -z because SunOS4 sh mishandles braces in ${var-val}.

2803

# It thinks the first close brace ends the variable substitution.

2804

test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

2805

2806

test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

2807

2808

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

2809

2810

echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5

2811

echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6

2812

set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'`

2813

if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then

2814

echo $ECHO_N "(cached) $ECHO_C" >&6

2815

else

2816

cat >conftest.make <<\_ACEOF

2817

all:

2818

@echo 'ac_maketemp="$(MAKE)"'

2819

_ACEOF

2820

# GNU make sometimes prints "make[1]: Entering...", which would confuse us.

2821

eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`

2822

if test -n "$ac_maketemp"; then

2823

eval ac_cv_prog_make_${ac_make}_set=yes

2824

else

2825

eval ac_cv_prog_make_${ac_make}_set=no

2826

2827

rm -f conftest.make

2828

2829

if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then

2830

echo "$as_me:$LINENO: result: yes" >&5

2831

echo "${ECHO_T}yes" >&6

2832

SET_MAKE=

2833

else

2834

echo "$as_me:$LINENO: result: no" >&5

2835

echo "${ECHO_T}no" >&6

2836

SET_MAKE="MAKE=${MAKE-make}"

2837

2838

2839

if test -n "$ac_tool_prefix"; then

2840

# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.

2841

set dummy ${ac_tool_prefix}ranlib; ac_word=$2

2842

echo "$as_me:$LINENO: checking for $ac_word" >&5

2843

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

2844

if test "${ac_cv_prog_RANLIB+set}" = set; then

2845

echo $ECHO_N "(cached) $ECHO_C" >&6

2846

else

2847

if test -n "$RANLIB"; then

2848

ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.

2849

else

2850

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2851

for as_dir in $PATH

2852

2853

IFS=$as_save_IFS

2854

test -z "$as_dir" && as_dir=.

2855

for ac_exec_ext in '' $ac_executable_extensions; do

2856

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

2857

ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"

2858

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

2859

break 2

2860

2861

done

2862

done

2863

2864

2865

2866

RANLIB=$ac_cv_prog_RANLIB

2867

if test -n "$RANLIB"; then

2868

echo "$as_me:$LINENO: result: $RANLIB" >&5

2869

echo "${ECHO_T}$RANLIB" >&6

2870

else

2871

echo "$as_me:$LINENO: result: no" >&5

2872

echo "${ECHO_T}no" >&6

2873

2874

2875

2876

if test -z "$ac_cv_prog_RANLIB"; then

2877

ac_ct_RANLIB=$RANLIB

2878

# Extract the first word of "ranlib", so it can be a program name with args.

2879

set dummy ranlib; ac_word=$2

2880

echo "$as_me:$LINENO: checking for $ac_word" >&5

2881

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

2882

if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then

2883

echo $ECHO_N "(cached) $ECHO_C" >&6

2884

else

2885

if test -n "$ac_ct_RANLIB"; then

2886

ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.

2887

else

2888

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2889

for as_dir in $PATH

2890

2891

IFS=$as_save_IFS

2892

test -z "$as_dir" && as_dir=.

2893

for ac_exec_ext in '' $ac_executable_extensions; do

2894

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

2895

ac_cv_prog_ac_ct_RANLIB="ranlib"

2896

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

2897

break 2

2898

2899

done

2900

done

2901

2902

test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"

2903

2904

2905

ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB

2906

if test -n "$ac_ct_RANLIB"; then

2907

echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5

2908

echo "${ECHO_T}$ac_ct_RANLIB" >&6

2909

else

2910

echo "$as_me:$LINENO: result: no" >&5

2911

echo "${ECHO_T}no" >&6

2912

2913

2914

RANLIB=$ac_ct_RANLIB

2915

else

2916

RANLIB="$ac_cv_prog_RANLIB"

2917

2918

2919

2920

2921

cat >>confdefs.h <<\_ACEOF

2922

#define _GNU_SOURCE 1

2923

_ACEOF

2924

2925

2926

2927

ac_ext=c

2928

ac_cpp='$CPP $CPPFLAGS'

2929

ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

2930

ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

2931

ac_compiler_gnu=$ac_cv_c_compiler_gnu

2932

echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5

2933

echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6

2934

# On Suns, sometimes $CPP names a directory.

2935

if test -n "$CPP" && test -d "$CPP"; then

2936

CPP=

2937

2938

if test -z "$CPP"; then

2939

if test "${ac_cv_prog_CPP+set}" = set; then

2940

echo $ECHO_N "(cached) $ECHO_C" >&6

2941

else

2942

# Double quotes because CPP needs to be expanded

2943

for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

2944

2945

ac_preproc_ok=false

2946

for ac_c_preproc_warn_flag in '' yes

2947

2948

# Use a header file that comes with gcc, so configuring glibc

2949

# with a fresh cross-compiler works.

2950

# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

2951

# <limits.h> exists even on freestanding compilers.

2952

# On the NeXT, cc -E runs the code through the compiler's parser,

2953

# not just through cpp. "Syntax error" is here to catch this case.

2954

cat >conftest.$ac_ext <<_ACEOF

2955

#line $LINENO "configure"

2956

/* confdefs.h. */

2957

_ACEOF

2958

cat confdefs.h >>conftest.$ac_ext

2959

cat >>conftest.$ac_ext <<_ACEOF

2960

/* end confdefs.h. */

2961

#ifdef __STDC__

2962

# include <limits.h>

2963

#else

2964

# include <assert.h>

2965

#endif

2966

Syntax error

2967

_ACEOF

2968

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

2969

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

2970

ac_status=$?

2971

grep -v '^ *+' conftest.er1 >conftest.err

2972

rm -f conftest.er1

2973

cat conftest.err >&5

2974

echo "$as_me:$LINENO: \$? = $ac_status" >&5

2975

(exit $ac_status); } >/dev/null; then

2976

if test -s conftest.err; then

2977

ac_cpp_err=$ac_c_preproc_warn_flag

2978

else

2979

ac_cpp_err=

2980

2981

else

2982

ac_cpp_err=yes

2983

2984

if test -z "$ac_cpp_err"; then

2985

2986

else

2987

echo "$as_me: failed program was:" >&5

2988

sed 's/^/| /' conftest.$ac_ext >&5

2989

2990

# Broken: fails on valid input.

2991

continue

2992

2993

rm -f conftest.err conftest.$ac_ext

2994

2995

# OK, works on sane cases. Now check whether non-existent headers

2996

# can be detected and how.

2997

cat >conftest.$ac_ext <<_ACEOF

2998

#line $LINENO "configure"

2999

/* confdefs.h. */

3000

_ACEOF

3001

cat confdefs.h >>conftest.$ac_ext

3002

cat >>conftest.$ac_ext <<_ACEOF

3003

/* end confdefs.h. */

3004

#include <ac_nonexistent.h>

3005

_ACEOF

3006

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3007

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3008

ac_status=$?

3009

grep -v '^ *+' conftest.er1 >conftest.err

3010

rm -f conftest.er1

3011

cat conftest.err >&5

3012

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3013

(exit $ac_status); } >/dev/null; then

3014

if test -s conftest.err; then

3015

ac_cpp_err=$ac_c_preproc_warn_flag

3016

else

3017

ac_cpp_err=

3018

3019

else

3020

ac_cpp_err=yes

3021

3022

if test -z "$ac_cpp_err"; then

3023

# Broken: success on invalid input.

3024

continue

3025

else

3026

echo "$as_me: failed program was:" >&5

3027

sed 's/^/| /' conftest.$ac_ext >&5

3028

3029

# Passes both tests.

3030

ac_preproc_ok=:

3031

break

3032

3033

rm -f conftest.err conftest.$ac_ext

3034

3035

done

3036

# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3037

rm -f conftest.err conftest.$ac_ext

3038

if $ac_preproc_ok; then

3039

break

3040

3041

3042

done

3043

ac_cv_prog_CPP=$CPP

3044

3045

3046

CPP=$ac_cv_prog_CPP

3047

else

3048

ac_cv_prog_CPP=$CPP

3049

3050

echo "$as_me:$LINENO: result: $CPP" >&5

3051

echo "${ECHO_T}$CPP" >&6

3052

ac_preproc_ok=false

3053

for ac_c_preproc_warn_flag in '' yes

3054

3055

# Use a header file that comes with gcc, so configuring glibc

3056

# with a fresh cross-compiler works.

3057

# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3058

# <limits.h> exists even on freestanding compilers.

3059

# On the NeXT, cc -E runs the code through the compiler's parser,

3060

# not just through cpp. "Syntax error" is here to catch this case.

3061

cat >conftest.$ac_ext <<_ACEOF

3062

#line $LINENO "configure"

3063

/* confdefs.h. */

3064

_ACEOF

3065

cat confdefs.h >>conftest.$ac_ext

3066

cat >>conftest.$ac_ext <<_ACEOF

3067

/* end confdefs.h. */

3068

#ifdef __STDC__

3069

# include <limits.h>

3070

#else

3071

# include <assert.h>

3072

#endif

3073

Syntax error

3074

_ACEOF

3075

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3076

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3077

ac_status=$?

3078

grep -v '^ *+' conftest.er1 >conftest.err

3079

rm -f conftest.er1

3080

cat conftest.err >&5

3081

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3082

(exit $ac_status); } >/dev/null; then

3083

if test -s conftest.err; then

3084

ac_cpp_err=$ac_c_preproc_warn_flag

3085

else

3086

ac_cpp_err=

3087

3088

else

3089

ac_cpp_err=yes

3090

3091

if test -z "$ac_cpp_err"; then

3092

3093

else

3094

echo "$as_me: failed program was:" >&5

3095

sed 's/^/| /' conftest.$ac_ext >&5

3096

3097

# Broken: fails on valid input.

3098

continue

3099

3100

rm -f conftest.err conftest.$ac_ext

3101

3102

# OK, works on sane cases. Now check whether non-existent headers

3103

# can be detected and how.

3104

cat >conftest.$ac_ext <<_ACEOF

3105

#line $LINENO "configure"

3106

/* confdefs.h. */

3107

_ACEOF

3108

cat confdefs.h >>conftest.$ac_ext

3109

cat >>conftest.$ac_ext <<_ACEOF

3110

/* end confdefs.h. */

3111

#include <ac_nonexistent.h>

3112

_ACEOF

3113

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3114

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3115

ac_status=$?

3116

grep -v '^ *+' conftest.er1 >conftest.err

3117

rm -f conftest.er1

3118

cat conftest.err >&5

3119

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3120

(exit $ac_status); } >/dev/null; then

3121

if test -s conftest.err; then

3122

ac_cpp_err=$ac_c_preproc_warn_flag

3123

else

3124

ac_cpp_err=

3125

3126

else

3127

ac_cpp_err=yes

3128

3129

if test -z "$ac_cpp_err"; then

3130

# Broken: success on invalid input.

3131

continue

3132

else

3133

echo "$as_me: failed program was:" >&5

3134

sed 's/^/| /' conftest.$ac_ext >&5

3135

3136

# Passes both tests.

3137

ac_preproc_ok=:

3138

break

3139

3140

rm -f conftest.err conftest.$ac_ext

3141

3142

done

3143

# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3144

rm -f conftest.err conftest.$ac_ext

3145

if $ac_preproc_ok; then

3146

3147

else

3148

{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check

3149

See \`config.log' for more details." >&5

3150

echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check

3151

See \`config.log' for more details." >&2;}

3152

{ (exit 1); exit 1; }; }

3153

3154

3155

ac_ext=c

3156

ac_cpp='$CPP $CPPFLAGS'

3157

ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

3158

ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

3159

ac_compiler_gnu=$ac_cv_c_compiler_gnu

3160

3161

echo "$as_me:$LINENO: checking for egrep" >&5

3162

echo $ECHO_N "checking for egrep... $ECHO_C" >&6

3163

if test "${ac_cv_prog_egrep+set}" = set; then

3164

echo $ECHO_N "(cached) $ECHO_C" >&6

3165

else

3166

if echo a | (grep -E '(a|b)') >/dev/null 2>&1

3167

then ac_cv_prog_egrep='grep -E'

3168

else ac_cv_prog_egrep='egrep'

3169

3170

3171

echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5

3172

echo "${ECHO_T}$ac_cv_prog_egrep" >&6

3173

EGREP=$ac_cv_prog_egrep

3174

3175

3176

3177

3178

# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works

3179

# for constant arguments. Useless!

3180

echo "$as_me:$LINENO: checking for working alloca.h" >&5

3181

echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6

3182

if test "${ac_cv_working_alloca_h+set}" = set; then

3183

echo $ECHO_N "(cached) $ECHO_C" >&6

3184

else

3185

cat >conftest.$ac_ext <<_ACEOF

3186

#line $LINENO "configure"

3187

/* confdefs.h. */

3188

_ACEOF

3189

cat confdefs.h >>conftest.$ac_ext

3190

cat >>conftest.$ac_ext <<_ACEOF

3191

/* end confdefs.h. */

3192

#include <alloca.h>

3193

int

3194

main ()

3195

{

3196

char *p = (char *) alloca (2 * sizeof (int));

3197

;

3198

return 0;

3199

}

3200

_ACEOF

3201

rm -f conftest.$ac_objext conftest$ac_exeext

3202

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3203

(eval $ac_link) 2>&5

3204

ac_status=$?

3205

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3206

(exit $ac_status); } &&

3207

{ ac_try='test -s conftest$ac_exeext'

3208

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3209

(eval $ac_try) 2>&5

3210

ac_status=$?

3211

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3212

(exit $ac_status); }; }; then

3213

ac_cv_working_alloca_h=yes

3214

else

3215

echo "$as_me: failed program was:" >&5

3216

sed 's/^/| /' conftest.$ac_ext >&5

3217

3218

ac_cv_working_alloca_h=no

3219

3220

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

3221

3222

echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5

3223

echo "${ECHO_T}$ac_cv_working_alloca_h" >&6

3224

if test $ac_cv_working_alloca_h = yes; then

3225

3226

cat >>confdefs.h <<\_ACEOF

3227

#define HAVE_ALLOCA_H 1

3228

_ACEOF

3229

3230

3231

3232

echo "$as_me:$LINENO: checking for alloca" >&5

3233

echo $ECHO_N "checking for alloca... $ECHO_C" >&6

3234

if test "${ac_cv_func_alloca_works+set}" = set; then

3235

echo $ECHO_N "(cached) $ECHO_C" >&6

3236

else

3237

cat >conftest.$ac_ext <<_ACEOF

3238

#line $LINENO "configure"

3239

/* confdefs.h. */

3240

_ACEOF

3241

cat confdefs.h >>conftest.$ac_ext

3242

cat >>conftest.$ac_ext <<_ACEOF

3243

/* end confdefs.h. */

3244

#ifdef __GNUC__

3245

# define alloca __builtin_alloca

3246

#else

3247

# ifdef _MSC_VER

3248

# include <malloc.h>

3249

# define alloca _alloca

3250

# else

3251

# if HAVE_ALLOCA_H

3252

# include <alloca.h>

3253

# else

3254

# ifdef _AIX

3255

#pragma alloca

3256

# else

3257

# ifndef alloca /* predefined by HP cc +Olibcalls */

3258

char *alloca ();

3259

# endif

3260

# endif

3261

# endif

3262

# endif

3263

#endif

3264

3265

int

3266

main ()

3267

{

3268

char *p = (char *) alloca (1);

3269

;

3270

return 0;

3271

}

3272

_ACEOF

3273

rm -f conftest.$ac_objext conftest$ac_exeext

3274

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3275

(eval $ac_link) 2>&5

3276

ac_status=$?

3277

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3278

(exit $ac_status); } &&

3279

{ ac_try='test -s conftest$ac_exeext'

3280

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3281

(eval $ac_try) 2>&5

3282

ac_status=$?

3283

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3284

(exit $ac_status); }; }; then

3285

ac_cv_func_alloca_works=yes

3286

else

3287

echo "$as_me: failed program was:" >&5

3288

sed 's/^/| /' conftest.$ac_ext >&5

3289

3290

ac_cv_func_alloca_works=no

3291

3292

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

3293

3294

echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5

3295

echo "${ECHO_T}$ac_cv_func_alloca_works" >&6

3296

3297

if test $ac_cv_func_alloca_works = yes; then

3298

3299

cat >>confdefs.h <<\_ACEOF

3300

#define HAVE_ALLOCA 1

3301

_ACEOF

3302

3303

else

3304

# The SVR3 libPW and SVR4 libucb both contain incompatible functions

3305

# that cause trouble. Some versions do not even contain alloca or

3306

# contain a buggy version. If you still want to use their alloca,

3307

# use ar to extract alloca.o from them instead of compiling alloca.c.

3308

3309

ALLOCA=alloca.$ac_objext

3310

3311

cat >>confdefs.h <<\_ACEOF

3312

#define C_ALLOCA 1

3313

_ACEOF

3314

3315

3316

echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5

3317

echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6

3318

if test "${ac_cv_os_cray+set}" = set; then

3319

echo $ECHO_N "(cached) $ECHO_C" >&6

3320

else

3321

cat >conftest.$ac_ext <<_ACEOF

3322

#line $LINENO "configure"

3323

/* confdefs.h. */

3324

_ACEOF

3325

cat confdefs.h >>conftest.$ac_ext

3326

cat >>conftest.$ac_ext <<_ACEOF

3327

/* end confdefs.h. */

3328

#if defined(CRAY) && ! defined(CRAY2)

3329

webecray

3330

#else

3331

wenotbecray

3332

#endif

3333

3334

_ACEOF

3335

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3336

$EGREP "webecray" >/dev/null 2>&1; then

3337

ac_cv_os_cray=yes

3338

else

3339

ac_cv_os_cray=no

3340

3341

rm -f conftest*

3342

3343

3344

echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5

3345

echo "${ECHO_T}$ac_cv_os_cray" >&6

3346

if test $ac_cv_os_cray = yes; then

3347

for ac_func in _getb67 GETB67 getb67; do

3348

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

3349

echo "$as_me:$LINENO: checking for $ac_func" >&5

3350

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

3351

if eval "test \"\${$as_ac_var+set}\" = set"; then

3352

echo $ECHO_N "(cached) $ECHO_C" >&6

3353

else

3354

cat >conftest.$ac_ext <<_ACEOF

3355

#line $LINENO "configure"

3356

/* confdefs.h. */

3357

_ACEOF

3358

cat confdefs.h >>conftest.$ac_ext

3359

cat >>conftest.$ac_ext <<_ACEOF

3360

/* end confdefs.h. */

3361

/* System header to define __stub macros and hopefully few prototypes,

3362

which can conflict with char $ac_func (); below.

3363

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3364

<limits.h> exists even on freestanding compilers. */

3365

#ifdef __STDC__

3366

# include <limits.h>

3367

#else

3368

# include <assert.h>

3369

#endif

3370

/* Override any gcc2 internal prototype to avoid an error. */

3371

#ifdef __cplusplus

3372

extern "C"

3373

{

3374

#endif

3375

/* We use char because int might match the return type of a gcc2

3376

builtin and then its argument prototype would still apply. */

3377

char $ac_func ();

3378

/* The GNU C library defines this for functions which it implements

3379

to always fail with ENOSYS. Some functions are actually named

3380

something starting with __ and the normal name is an alias. */

3381

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

3382

choke me

3383

#else

3384

char (*f) () = $ac_func;

3385

#endif

3386

#ifdef __cplusplus

3387

}

3388

#endif

3389

3390

int

3391

main ()

3392

{

3393

return f != $ac_func;

3394

;

3395

return 0;

3396

}

3397

_ACEOF

3398

rm -f conftest.$ac_objext conftest$ac_exeext

3399

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3400

(eval $ac_link) 2>&5

3401

ac_status=$?

3402

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3403

(exit $ac_status); } &&

3404

{ ac_try='test -s conftest$ac_exeext'

3405

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3406

(eval $ac_try) 2>&5

3407

ac_status=$?

3408

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3409

(exit $ac_status); }; }; then

3410

eval "$as_ac_var=yes"

3411

else

3412

echo "$as_me: failed program was:" >&5

3413

sed 's/^/| /' conftest.$ac_ext >&5

3414

3415

eval "$as_ac_var=no"

3416

3417

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

3418

3419

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

3420

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

3421

if test `eval echo '${'$as_ac_var'}'` = yes; then

3422

3423

cat >>confdefs.h <<_ACEOF

3424

#define CRAY_STACKSEG_END $ac_func

3425

_ACEOF

3426

3427

break

3428

3429

3430

done

3431

3432

3433

echo "$as_me:$LINENO: checking stack direction for C alloca" >&5

3434

echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6

3435

if test "${ac_cv_c_stack_direction+set}" = set; then

3436

echo $ECHO_N "(cached) $ECHO_C" >&6

3437

else

3438

if test "$cross_compiling" = yes; then

3439

ac_cv_c_stack_direction=0

3440

else

3441

cat >conftest.$ac_ext <<_ACEOF

3442

#line $LINENO "configure"

3443

/* confdefs.h. */

3444

_ACEOF

3445

cat confdefs.h >>conftest.$ac_ext

3446

cat >>conftest.$ac_ext <<_ACEOF

3447

/* end confdefs.h. */

3448

int

3449

find_stack_direction ()

3450

{

3451

static char *addr = 0;

3452

auto char dummy;

3453

if (addr == 0)

3454

{

3455

addr = &dummy;

3456

return find_stack_direction ();

3457

}

3458

else

3459

return (&dummy > addr) ? 1 : -1;

3460

}

3461

3462

int

3463

main ()

3464

{

3465

exit (find_stack_direction () < 0);

3466

}

3467

_ACEOF

3468

rm -f conftest$ac_exeext

3469

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3470

(eval $ac_link) 2>&5

3471

ac_status=$?

3472

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3473

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

3474

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3475

(eval $ac_try) 2>&5

3476

ac_status=$?

3477

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3478

(exit $ac_status); }; }; then

3479

ac_cv_c_stack_direction=1

3480

else

3481

echo "$as_me: program exited with status $ac_status" >&5

3482

echo "$as_me: failed program was:" >&5

3483

sed 's/^/| /' conftest.$ac_ext >&5

3484

3485

( exit $ac_status )

3486

ac_cv_c_stack_direction=-1

3487

3488

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

3489

3490

3491

echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5

3492

echo "${ECHO_T}$ac_cv_c_stack_direction" >&6

3493

3494

cat >>confdefs.h <<_ACEOF

3495

#define STACK_DIRECTION $ac_cv_c_stack_direction

3496

_ACEOF

3497

3498

3499

3500

3501

echo "$as_me:$LINENO: checking for ANSI C header files" >&5

3502

echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

3503

if test "${ac_cv_header_stdc+set}" = set; then

3504

echo $ECHO_N "(cached) $ECHO_C" >&6

3505

else

3506

cat >conftest.$ac_ext <<_ACEOF

3507

#line $LINENO "configure"

3508

/* confdefs.h. */

3509

_ACEOF

3510

cat confdefs.h >>conftest.$ac_ext

3511

cat >>conftest.$ac_ext <<_ACEOF

3512

/* end confdefs.h. */

3513

#include <stdlib.h>

3514

#include <stdarg.h>

3515

#include <string.h>

3516

#include <float.h>

3517

3518

int

3519

main ()

3520

{

3521

3522

;

3523

return 0;

3524

}

3525

_ACEOF

3526

rm -f conftest.$ac_objext

3527

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

3528

(eval $ac_compile) 2>&5

3529

ac_status=$?

3530

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3531

(exit $ac_status); } &&

3532

{ ac_try='test -s conftest.$ac_objext'

3533

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3534

(eval $ac_try) 2>&5

3535

ac_status=$?

3536

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3537

(exit $ac_status); }; }; then

3538

ac_cv_header_stdc=yes

3539

else

3540

echo "$as_me: failed program was:" >&5

3541

sed 's/^/| /' conftest.$ac_ext >&5

3542

3543

ac_cv_header_stdc=no

3544

3545

rm -f conftest.$ac_objext conftest.$ac_ext

3546

3547

if test $ac_cv_header_stdc = yes; then

3548

# SunOS 4.x string.h does not declare mem*, contrary to ANSI.

3549

cat >conftest.$ac_ext <<_ACEOF

3550

#line $LINENO "configure"

3551

/* confdefs.h. */

3552

_ACEOF

3553

cat confdefs.h >>conftest.$ac_ext

3554

cat >>conftest.$ac_ext <<_ACEOF

3555

/* end confdefs.h. */

3556

#include <string.h>

3557

3558

_ACEOF

3559

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3560

$EGREP "memchr" >/dev/null 2>&1; then

3561

3562

else

3563

ac_cv_header_stdc=no

3564

3565

rm -f conftest*

3566

3567

3568

3569

if test $ac_cv_header_stdc = yes; then

3570

# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

3571

cat >conftest.$ac_ext <<_ACEOF

3572

#line $LINENO "configure"

3573

/* confdefs.h. */

3574

_ACEOF

3575

cat confdefs.h >>conftest.$ac_ext

3576

cat >>conftest.$ac_ext <<_ACEOF

3577

/* end confdefs.h. */

3578

#include <stdlib.h>

3579

3580

_ACEOF

3581

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3582

$EGREP "free" >/dev/null 2>&1; then

3583

3584

else

3585

ac_cv_header_stdc=no

3586

3587

rm -f conftest*

3588

3589

3590

3591

if test $ac_cv_header_stdc = yes; then

3592

# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

3593

if test "$cross_compiling" = yes; then

3594

3595

else

3596

cat >conftest.$ac_ext <<_ACEOF

3597

#line $LINENO "configure"

3598

/* confdefs.h. */

3599

_ACEOF

3600

cat confdefs.h >>conftest.$ac_ext

3601

cat >>conftest.$ac_ext <<_ACEOF

3602

/* end confdefs.h. */

3603

#include <ctype.h>

3604

#if ((' ' & 0x0FF) == 0x020)

3605

# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

3606

# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

3607

#else

3608

# define ISLOWER(c) \

3609

(('a' <= (c) && (c) <= 'i') \

3610

|| ('j' <= (c) && (c) <= 'r') \

3611

|| ('s' <= (c) && (c) <= 'z'))

3612

# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

3613

#endif

3614

3615

#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

3616

int

3617

main ()

3618

{

3619

int i;

3620

for (i = 0; i < 256; i++)

3621

if (XOR (islower (i), ISLOWER (i))

3622

|| toupper (i) != TOUPPER (i))

3623

exit(2);

3624

exit (0);

3625

}

3626

_ACEOF

3627

rm -f conftest$ac_exeext

3628

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3629

(eval $ac_link) 2>&5

3630

ac_status=$?

3631

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3632

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

3633

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3634

(eval $ac_try) 2>&5

3635

ac_status=$?

3636

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3637

(exit $ac_status); }; }; then

3638

3639

else

3640

echo "$as_me: program exited with status $ac_status" >&5

3641

echo "$as_me: failed program was:" >&5

3642

sed 's/^/| /' conftest.$ac_ext >&5

3643

3644

( exit $ac_status )

3645

ac_cv_header_stdc=no

3646

3647

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

3648

3649

3650

3651

echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

3652

echo "${ECHO_T}$ac_cv_header_stdc" >&6

3653

if test $ac_cv_header_stdc = yes; then

3654

3655

cat >>confdefs.h <<\_ACEOF

3656

#define STDC_HEADERS 1

3657

_ACEOF

3658

3659

3660

3661

# On IRIX 5.3, sys/types and inttypes.h are conflicting.

3662

3663

3664

3665

3666

3667

3668

3669

3670

3671

for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \

3672

inttypes.h stdint.h unistd.h

3673

3674

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

3675

echo "$as_me:$LINENO: checking for $ac_header" >&5

3676

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

3677

if eval "test \"\${$as_ac_Header+set}\" = set"; then

3678

echo $ECHO_N "(cached) $ECHO_C" >&6

3679

else

3680

cat >conftest.$ac_ext <<_ACEOF

3681

#line $LINENO "configure"

3682

/* confdefs.h. */

3683

_ACEOF

3684

cat confdefs.h >>conftest.$ac_ext

3685

cat >>conftest.$ac_ext <<_ACEOF

3686

/* end confdefs.h. */

3687

$ac_includes_default

3688

3689

#include <$ac_header>

3690

_ACEOF

3691

rm -f conftest.$ac_objext

3692

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

3693

(eval $ac_compile) 2>&5

3694

ac_status=$?

3695

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3696

(exit $ac_status); } &&

3697

{ ac_try='test -s conftest.$ac_objext'

3698

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3699

(eval $ac_try) 2>&5

3700

ac_status=$?

3701

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3702

(exit $ac_status); }; }; then

3703

eval "$as_ac_Header=yes"

3704

else

3705

echo "$as_me: failed program was:" >&5

3706

sed 's/^/| /' conftest.$ac_ext >&5

3707

3708

eval "$as_ac_Header=no"

3709

3710

rm -f conftest.$ac_objext conftest.$ac_ext

3711

3712

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

3713

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

3714

if test `eval echo '${'$as_ac_Header'}'` = yes; then

3715

cat >>confdefs.h <<_ACEOF

3716

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

3717

_ACEOF

3718

3719

3720

3721

done

3722

3723

3724

3725

3726

3727

3728

3729

for ac_header in $gl_header_list

3730

3731

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

3732

if eval "test \"\${$as_ac_Header+set}\" = set"; then

3733

echo "$as_me:$LINENO: checking for $ac_header" >&5

3734

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

3735

if eval "test \"\${$as_ac_Header+set}\" = set"; then

3736

echo $ECHO_N "(cached) $ECHO_C" >&6

3737

3738

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

3739

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

3740

else

3741

# Is the header compilable?

3742

echo "$as_me:$LINENO: checking $ac_header usability" >&5

3743

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

3744

cat >conftest.$ac_ext <<_ACEOF

3745

#line $LINENO "configure"

3746

/* confdefs.h. */

3747

_ACEOF

3748

cat confdefs.h >>conftest.$ac_ext

3749

cat >>conftest.$ac_ext <<_ACEOF

3750

/* end confdefs.h. */

3751

$ac_includes_default

3752

#include <$ac_header>

3753

_ACEOF

3754

rm -f conftest.$ac_objext

3755

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

3756

(eval $ac_compile) 2>&5

3757

ac_status=$?

3758

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3759

(exit $ac_status); } &&

3760

{ ac_try='test -s conftest.$ac_objext'

3761

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3762

(eval $ac_try) 2>&5

3763

ac_status=$?

3764

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3765

(exit $ac_status); }; }; then

3766

ac_header_compiler=yes

3767

else

3768

echo "$as_me: failed program was:" >&5

3769

sed 's/^/| /' conftest.$ac_ext >&5

3770

3771

ac_header_compiler=no

3772

3773

rm -f conftest.$ac_objext conftest.$ac_ext

3774

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

3775

echo "${ECHO_T}$ac_header_compiler" >&6

3776

3777

# Is the header present?

3778

echo "$as_me:$LINENO: checking $ac_header presence" >&5

3779

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

3780

cat >conftest.$ac_ext <<_ACEOF

3781

#line $LINENO "configure"

3782

/* confdefs.h. */

3783

_ACEOF

3784

cat confdefs.h >>conftest.$ac_ext

3785

cat >>conftest.$ac_ext <<_ACEOF

3786

/* end confdefs.h. */

3787

#include <$ac_header>

3788

_ACEOF

3789

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3790

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3791

ac_status=$?

3792

grep -v '^ *+' conftest.er1 >conftest.err

3793

rm -f conftest.er1

3794

cat conftest.err >&5

3795

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3796

(exit $ac_status); } >/dev/null; then

3797

if test -s conftest.err; then

3798

ac_cpp_err=$ac_c_preproc_warn_flag

3799

else

3800

ac_cpp_err=

3801

3802

else

3803

ac_cpp_err=yes

3804

3805

if test -z "$ac_cpp_err"; then

3806

ac_header_preproc=yes

3807

else

3808

echo "$as_me: failed program was:" >&5

3809

sed 's/^/| /' conftest.$ac_ext >&5

3810

3811

ac_header_preproc=no

3812

3813

rm -f conftest.err conftest.$ac_ext

3814

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

3815

echo "${ECHO_T}$ac_header_preproc" >&6

3816

3817

# So? What about this header?

3818

case $ac_header_compiler:$ac_header_preproc in

3819

yes:no )

3820

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

3821

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

3822

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

3823

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

3824

(

3825

cat <<\_ASBOX

3826

## ------------------------------------ ##

3827

## Report this to bug-autoconf@gnu.org. ##

3828

## ------------------------------------ ##

3829

_ASBOX

3830

) |

3831

sed "s/^/$as_me: WARNING: /" >&2

3832

;;

3833

no:yes )

3834

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

3835

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

3836

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

3837

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

3838

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

3839

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

3840

(

3841

cat <<\_ASBOX

3842

## ------------------------------------ ##

3843

## Report this to bug-autoconf@gnu.org. ##

3844

## ------------------------------------ ##

3845

_ASBOX

3846

) |

3847

sed "s/^/$as_me: WARNING: /" >&2

3848

;;

3849

esac

3850

echo "$as_me:$LINENO: checking for $ac_header" >&5

3851

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

3852

if eval "test \"\${$as_ac_Header+set}\" = set"; then

3853

echo $ECHO_N "(cached) $ECHO_C" >&6

3854

else

3855

eval "$as_ac_Header=$ac_header_preproc"

3856

3857

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

3858

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

3859

3860

3861

if test `eval echo '${'$as_ac_Header'}'` = yes; then

3862

cat >>confdefs.h <<_ACEOF

3863

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

3864

_ACEOF

3865

3866

3867

3868

done

3869

3870

3871

3872

3873

3874

3875

3876

3877

3878

3879

3880

3881

3882

3883

3884

3885

3886

if test $ac_cv_func_alloca_works = no; then

3887

3888

3889

3890

3891

3892

3893

3894

3895

3896

3897

3898

3899

3900

3901

# Define an additional variable used in the Makefile substitution.

3902

3903

cat >conftest.$ac_ext <<_ACEOF

3904

#line $LINENO "configure"

3905

/* confdefs.h. */

3906

_ACEOF

3907

cat confdefs.h >>conftest.$ac_ext

3908

cat >>conftest.$ac_ext <<_ACEOF

3909

/* end confdefs.h. */

3910

3911

#if defined __GNUC__ || defined _MSC_VER || !HAVE_ALLOCA_H

3912

Need own alloca

3913

#endif

3914

3915

_ACEOF

3916

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3917

$EGREP "Need own alloca" >/dev/null 2>&1; then

3918

ALLOCA_H=alloca.h

3919

else

3920

ALLOCA_H=

3921

3922

rm -f conftest*

3923

3924

3925

3926

3927

3928

3929

echo "$as_me:$LINENO: checking whether system is Windows or MSDOS" >&5

3930

echo $ECHO_N "checking whether system is Windows or MSDOS... $ECHO_C" >&6

3931

if test "${ac_cv_win_or_dos+set}" = set; then

3932

echo $ECHO_N "(cached) $ECHO_C" >&6

3933

else

3934

3935

cat >conftest.$ac_ext <<_ACEOF

3936

#line $LINENO "configure"

3937

/* confdefs.h. */

3938

_ACEOF

3939

cat confdefs.h >>conftest.$ac_ext

3940

cat >>conftest.$ac_ext <<_ACEOF

3941

/* end confdefs.h. */

3942

3943

int

3944

main ()

3945

{

3946

#if !defined _WIN32 && !defined __WIN32__ && !defined __MSDOS__

3947

neither MSDOS nor Windows

3948

#endif

3949

;

3950

return 0;

3951

}

3952

_ACEOF

3953

rm -f conftest.$ac_objext

3954

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

3955

(eval $ac_compile) 2>&5

3956

ac_status=$?

3957

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3958

(exit $ac_status); } &&

3959

{ ac_try='test -s conftest.$ac_objext'

3960

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3961

(eval $ac_try) 2>&5

3962

ac_status=$?

3963

echo "$as_me:$LINENO: \$? = $ac_status" >&5

3964

(exit $ac_status); }; }; then

3965

ac_cv_win_or_dos=yes

3966

else

3967

echo "$as_me: failed program was:" >&5

3968

sed 's/^/| /' conftest.$ac_ext >&5

3969

3970

ac_cv_win_or_dos=no

3971

3972

rm -f conftest.$ac_objext conftest.$ac_ext

3973

3974

3975

echo "$as_me:$LINENO: result: $ac_cv_win_or_dos" >&5

3976

echo "${ECHO_T}$ac_cv_win_or_dos" >&6

3977

3978

if test x"$ac_cv_win_or_dos" = xyes; then

3979

ac_fs_accepts_drive_letter_prefix=1

3980

ac_fs_backslash_is_file_name_separator=1

3981

else

3982

ac_fs_accepts_drive_letter_prefix=0

3983

ac_fs_backslash_is_file_name_separator=0

3984

3985

3986

3987

3988

3989

3990

cat >>confdefs.h <<_ACEOF

3991

#define FILESYSTEM_ACCEPTS_DRIVE_LETTER_PREFIX $ac_fs_accepts_drive_letter_prefix

3992

_ACEOF

3993

3994

3995

3996

3997

3998

3999

cat >>confdefs.h <<_ACEOF

4000

#define FILESYSTEM_BACKSLASH_IS_FILE_NAME_SEPARATOR $ac_fs_backslash_is_file_name_separator

4001

_ACEOF

4002

4003

4004

4005

4006

4007

4008

4009

4010

4011

4012

4013

4014

4015

4016

4017

4018

4019

4020

4021

4022

4023

4024

4025

4026

4027

4028

4029

4030

4031

4032

4033

4034

4035

4036

for ac_func in vprintf

4037

4038

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

4039

echo "$as_me:$LINENO: checking for $ac_func" >&5

4040

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

4041

if eval "test \"\${$as_ac_var+set}\" = set"; then

4042

echo $ECHO_N "(cached) $ECHO_C" >&6

4043

else

4044

cat >conftest.$ac_ext <<_ACEOF

4045

#line $LINENO "configure"

4046

/* confdefs.h. */

4047

_ACEOF

4048

cat confdefs.h >>conftest.$ac_ext

4049

cat >>conftest.$ac_ext <<_ACEOF

4050

/* end confdefs.h. */

4051

/* System header to define __stub macros and hopefully few prototypes,

4052

which can conflict with char $ac_func (); below.

4053

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4054

<limits.h> exists even on freestanding compilers. */

4055

#ifdef __STDC__

4056

# include <limits.h>

4057

#else

4058

# include <assert.h>

4059

#endif

4060

/* Override any gcc2 internal prototype to avoid an error. */

4061

#ifdef __cplusplus

4062

extern "C"

4063

{

4064

#endif

4065

/* We use char because int might match the return type of a gcc2

4066

builtin and then its argument prototype would still apply. */

4067

char $ac_func ();

4068

/* The GNU C library defines this for functions which it implements

4069

to always fail with ENOSYS. Some functions are actually named

4070

something starting with __ and the normal name is an alias. */

4071

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

4072

choke me

4073

#else

4074

char (*f) () = $ac_func;

4075

#endif

4076

#ifdef __cplusplus

4077

}

4078

#endif

4079

4080

int

4081

main ()

4082

{

4083

return f != $ac_func;

4084

;

4085

return 0;

4086

}

4087

_ACEOF

4088

rm -f conftest.$ac_objext conftest$ac_exeext

4089

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4090

(eval $ac_link) 2>&5

4091

ac_status=$?

4092

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4093

(exit $ac_status); } &&

4094

{ ac_try='test -s conftest$ac_exeext'

4095

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4096

(eval $ac_try) 2>&5

4097

ac_status=$?

4098

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4099

(exit $ac_status); }; }; then

4100

eval "$as_ac_var=yes"

4101

else

4102

echo "$as_me: failed program was:" >&5

4103

sed 's/^/| /' conftest.$ac_ext >&5

4104

4105

eval "$as_ac_var=no"

4106

4107

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4108

4109

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

4110

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

4111

if test `eval echo '${'$as_ac_var'}'` = yes; then

4112

cat >>confdefs.h <<_ACEOF

4113

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

4114

_ACEOF

4115

4116

echo "$as_me:$LINENO: checking for _doprnt" >&5

4117

echo $ECHO_N "checking for _doprnt... $ECHO_C" >&6

4118

if test "${ac_cv_func__doprnt+set}" = set; then

4119

echo $ECHO_N "(cached) $ECHO_C" >&6

4120

else

4121

cat >conftest.$ac_ext <<_ACEOF

4122

#line $LINENO "configure"

4123

/* confdefs.h. */

4124

_ACEOF

4125

cat confdefs.h >>conftest.$ac_ext

4126

cat >>conftest.$ac_ext <<_ACEOF

4127

/* end confdefs.h. */

4128

/* System header to define __stub macros and hopefully few prototypes,

4129

which can conflict with char _doprnt (); below.

4130

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4131

<limits.h> exists even on freestanding compilers. */

4132

#ifdef __STDC__

4133

# include <limits.h>

4134

#else

4135

# include <assert.h>

4136

#endif

4137

/* Override any gcc2 internal prototype to avoid an error. */

4138

#ifdef __cplusplus

4139

extern "C"

4140

{

4141

#endif

4142

/* We use char because int might match the return type of a gcc2

4143

builtin and then its argument prototype would still apply. */

4144

char _doprnt ();

4145

/* The GNU C library defines this for functions which it implements

4146

to always fail with ENOSYS. Some functions are actually named

4147

something starting with __ and the normal name is an alias. */

4148

#if defined (__stub__doprnt) || defined (__stub____doprnt)

4149

choke me

4150

#else

4151

char (*f) () = _doprnt;

4152

#endif

4153

#ifdef __cplusplus

4154

}

4155

#endif

4156

4157

int

4158

main ()

4159

{

4160

return f != _doprnt;

4161

;

4162

return 0;

4163

}

4164

_ACEOF

4165

rm -f conftest.$ac_objext conftest$ac_exeext

4166

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4167

(eval $ac_link) 2>&5

4168

ac_status=$?

4169

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4170

(exit $ac_status); } &&

4171

{ ac_try='test -s conftest$ac_exeext'

4172

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4173

(eval $ac_try) 2>&5

4174

ac_status=$?

4175

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4176

(exit $ac_status); }; }; then

4177

ac_cv_func__doprnt=yes

4178

else

4179

echo "$as_me: failed program was:" >&5

4180

sed 's/^/| /' conftest.$ac_ext >&5

4181

4182

ac_cv_func__doprnt=no

4183

4184

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4185

4186

echo "$as_me:$LINENO: result: $ac_cv_func__doprnt" >&5

4187

echo "${ECHO_T}$ac_cv_func__doprnt" >&6

4188

if test $ac_cv_func__doprnt = yes; then

4189

4190

cat >>confdefs.h <<\_ACEOF

4191

#define HAVE_DOPRNT 1

4192

_ACEOF

4193

4194

4195

4196

4197

done

4198

4199

4200

4201

echo "$as_me:$LINENO: checking for error_at_line" >&5

4202

echo $ECHO_N "checking for error_at_line... $ECHO_C" >&6

4203

if test "${ac_cv_lib_error_at_line+set}" = set; then

4204

echo $ECHO_N "(cached) $ECHO_C" >&6

4205

else

4206

cat >conftest.$ac_ext <<_ACEOF

4207

#line $LINENO "configure"

4208

/* confdefs.h. */

4209

_ACEOF

4210

cat confdefs.h >>conftest.$ac_ext

4211

cat >>conftest.$ac_ext <<_ACEOF

4212

/* end confdefs.h. */

4213

4214

int

4215

main ()

4216

{

4217

error_at_line (0, 0, "", 0, "");

4218

;

4219

return 0;

4220

}

4221

_ACEOF

4222

rm -f conftest.$ac_objext conftest$ac_exeext

4223

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4224

(eval $ac_link) 2>&5

4225

ac_status=$?

4226

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4227

(exit $ac_status); } &&

4228

{ ac_try='test -s conftest$ac_exeext'

4229

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4230

(eval $ac_try) 2>&5

4231

ac_status=$?

4232

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4233

(exit $ac_status); }; }; then

4234

ac_cv_lib_error_at_line=yes

4235

else

4236

echo "$as_me: failed program was:" >&5

4237

sed 's/^/| /' conftest.$ac_ext >&5

4238

4239

ac_cv_lib_error_at_line=no

4240

4241

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4242

4243

echo "$as_me:$LINENO: result: $ac_cv_lib_error_at_line" >&5

4244

echo "${ECHO_T}$ac_cv_lib_error_at_line" >&6

4245

if test $ac_cv_lib_error_at_line = no; then

4246

LIBOBJS="$LIBOBJS error.$ac_objext"

4247

4248

4249

4250

4251

4252

4253

for ac_func in strerror

4254

4255

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

4256

echo "$as_me:$LINENO: checking for $ac_func" >&5

4257

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

4258

if eval "test \"\${$as_ac_var+set}\" = set"; then

4259

echo $ECHO_N "(cached) $ECHO_C" >&6

4260

else

4261

cat >conftest.$ac_ext <<_ACEOF

4262

#line $LINENO "configure"

4263

/* confdefs.h. */

4264

_ACEOF

4265

cat confdefs.h >>conftest.$ac_ext

4266

cat >>conftest.$ac_ext <<_ACEOF

4267

/* end confdefs.h. */

4268

/* System header to define __stub macros and hopefully few prototypes,

4269

which can conflict with char $ac_func (); below.

4270

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4271

<limits.h> exists even on freestanding compilers. */

4272

#ifdef __STDC__

4273

# include <limits.h>

4274

#else

4275

# include <assert.h>

4276

#endif

4277

/* Override any gcc2 internal prototype to avoid an error. */

4278

#ifdef __cplusplus

4279

extern "C"

4280

{

4281

#endif

4282

/* We use char because int might match the return type of a gcc2

4283

builtin and then its argument prototype would still apply. */

4284

char $ac_func ();

4285

/* The GNU C library defines this for functions which it implements

4286

to always fail with ENOSYS. Some functions are actually named

4287

something starting with __ and the normal name is an alias. */

4288

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

4289

choke me

4290

#else

4291

char (*f) () = $ac_func;

4292

#endif

4293

#ifdef __cplusplus

4294

}

4295

#endif

4296

4297

int

4298

main ()

4299

{

4300

return f != $ac_func;

4301

;

4302

return 0;

4303

}

4304

_ACEOF

4305

rm -f conftest.$ac_objext conftest$ac_exeext

4306

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4307

(eval $ac_link) 2>&5

4308

ac_status=$?

4309

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4310

(exit $ac_status); } &&

4311

{ ac_try='test -s conftest$ac_exeext'

4312

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4313

(eval $ac_try) 2>&5

4314

ac_status=$?

4315

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4316

(exit $ac_status); }; }; then

4317

eval "$as_ac_var=yes"

4318

else

4319

echo "$as_me: failed program was:" >&5

4320

sed 's/^/| /' conftest.$ac_ext >&5

4321

4322

eval "$as_ac_var=no"

4323

4324

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4325

4326

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

4327

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

4328

if test `eval echo '${'$as_ac_var'}'` = yes; then

4329

cat >>confdefs.h <<_ACEOF

4330

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

4331

_ACEOF

4332

4333

4334

done

4335

4336

echo "$as_me:$LINENO: checking whether strerror is declared" >&5

4337

echo $ECHO_N "checking whether strerror is declared... $ECHO_C" >&6

4338

if test "${ac_cv_have_decl_strerror+set}" = set; then

4339

echo $ECHO_N "(cached) $ECHO_C" >&6

4340

else

4341

cat >conftest.$ac_ext <<_ACEOF

4342

#line $LINENO "configure"

4343

/* confdefs.h. */

4344

_ACEOF

4345

cat confdefs.h >>conftest.$ac_ext

4346

cat >>conftest.$ac_ext <<_ACEOF

4347

/* end confdefs.h. */

4348

$ac_includes_default

4349

int

4350

main ()

4351

{

4352

#ifndef strerror

4353

char *p = (char *) strerror;

4354

#endif

4355

4356

;

4357

return 0;

4358

}

4359

_ACEOF

4360

rm -f conftest.$ac_objext

4361

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4362

(eval $ac_compile) 2>&5

4363

ac_status=$?

4364

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4365

(exit $ac_status); } &&

4366

{ ac_try='test -s conftest.$ac_objext'

4367

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4368

(eval $ac_try) 2>&5

4369

ac_status=$?

4370

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4371

(exit $ac_status); }; }; then

4372

ac_cv_have_decl_strerror=yes

4373

else

4374

echo "$as_me: failed program was:" >&5

4375

sed 's/^/| /' conftest.$ac_ext >&5

4376

4377

ac_cv_have_decl_strerror=no

4378

4379

rm -f conftest.$ac_objext conftest.$ac_ext

4380

4381

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strerror" >&5

4382

echo "${ECHO_T}$ac_cv_have_decl_strerror" >&6

4383

if test $ac_cv_have_decl_strerror = yes; then

4384

4385

cat >>confdefs.h <<_ACEOF

4386

#define HAVE_DECL_STRERROR 1

4387

_ACEOF

4388

4389

4390

else

4391

cat >>confdefs.h <<_ACEOF

4392

#define HAVE_DECL_STRERROR 0

4393

_ACEOF

4394

4395

4396

4397

4398

4399

echo "$as_me:$LINENO: checking whether strerror_r is declared" >&5

4400

echo $ECHO_N "checking whether strerror_r is declared... $ECHO_C" >&6

4401

if test "${ac_cv_have_decl_strerror_r+set}" = set; then

4402

echo $ECHO_N "(cached) $ECHO_C" >&6

4403

else

4404

cat >conftest.$ac_ext <<_ACEOF

4405

#line $LINENO "configure"

4406

/* confdefs.h. */

4407

_ACEOF

4408

cat confdefs.h >>conftest.$ac_ext

4409

cat >>conftest.$ac_ext <<_ACEOF

4410

/* end confdefs.h. */

4411

$ac_includes_default

4412

int

4413

main ()

4414

{

4415

#ifndef strerror_r

4416

char *p = (char *) strerror_r;

4417

#endif

4418

4419

;

4420

return 0;

4421

}

4422

_ACEOF

4423

rm -f conftest.$ac_objext

4424

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4425

(eval $ac_compile) 2>&5

4426

ac_status=$?

4427

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4428

(exit $ac_status); } &&

4429

{ ac_try='test -s conftest.$ac_objext'

4430

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4431

(eval $ac_try) 2>&5

4432

ac_status=$?

4433

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4434

(exit $ac_status); }; }; then

4435

ac_cv_have_decl_strerror_r=yes

4436

else

4437

echo "$as_me: failed program was:" >&5

4438

sed 's/^/| /' conftest.$ac_ext >&5

4439

4440

ac_cv_have_decl_strerror_r=no

4441

4442

rm -f conftest.$ac_objext conftest.$ac_ext

4443

4444

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strerror_r" >&5

4445

echo "${ECHO_T}$ac_cv_have_decl_strerror_r" >&6

4446

if test $ac_cv_have_decl_strerror_r = yes; then

4447

4448

cat >>confdefs.h <<_ACEOF

4449

#define HAVE_DECL_STRERROR_R 1

4450

_ACEOF

4451

4452

4453

else

4454

cat >>confdefs.h <<_ACEOF

4455

#define HAVE_DECL_STRERROR_R 0

4456

_ACEOF

4457

4458

4459

4460

4461

4462

4463

for ac_func in strerror_r

4464

4465

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

4466

echo "$as_me:$LINENO: checking for $ac_func" >&5

4467

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

4468

if eval "test \"\${$as_ac_var+set}\" = set"; then

4469

echo $ECHO_N "(cached) $ECHO_C" >&6

4470

else

4471

cat >conftest.$ac_ext <<_ACEOF

4472

#line $LINENO "configure"

4473

/* confdefs.h. */

4474

_ACEOF

4475

cat confdefs.h >>conftest.$ac_ext

4476

cat >>conftest.$ac_ext <<_ACEOF

4477

/* end confdefs.h. */

4478

/* System header to define __stub macros and hopefully few prototypes,

4479

which can conflict with char $ac_func (); below.

4480

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4481

<limits.h> exists even on freestanding compilers. */

4482

#ifdef __STDC__

4483

# include <limits.h>

4484

#else

4485

# include <assert.h>

4486

#endif

4487

/* Override any gcc2 internal prototype to avoid an error. */

4488

#ifdef __cplusplus

4489

extern "C"

4490

{

4491

#endif

4492

/* We use char because int might match the return type of a gcc2

4493

builtin and then its argument prototype would still apply. */

4494

char $ac_func ();

4495

/* The GNU C library defines this for functions which it implements

4496

to always fail with ENOSYS. Some functions are actually named

4497

something starting with __ and the normal name is an alias. */

4498

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

4499

choke me

4500

#else

4501

char (*f) () = $ac_func;

4502

#endif

4503

#ifdef __cplusplus

4504

}

4505

#endif

4506

4507

int

4508

main ()

4509

{

4510

return f != $ac_func;

4511

;

4512

return 0;

4513

}

4514

_ACEOF

4515

rm -f conftest.$ac_objext conftest$ac_exeext

4516

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4517

(eval $ac_link) 2>&5

4518

ac_status=$?

4519

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4520

(exit $ac_status); } &&

4521

{ ac_try='test -s conftest$ac_exeext'

4522

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4523

(eval $ac_try) 2>&5

4524

ac_status=$?

4525

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4526

(exit $ac_status); }; }; then

4527

eval "$as_ac_var=yes"

4528

else

4529

echo "$as_me: failed program was:" >&5

4530

sed 's/^/| /' conftest.$ac_ext >&5

4531

4532

eval "$as_ac_var=no"

4533

4534

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4535

4536

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

4537

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

4538

if test `eval echo '${'$as_ac_var'}'` = yes; then

4539

cat >>confdefs.h <<_ACEOF

4540

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

4541

_ACEOF

4542

4543

4544

done

4545

4546

echo "$as_me:$LINENO: checking whether strerror_r returns char *" >&5

4547

echo $ECHO_N "checking whether strerror_r returns char *... $ECHO_C" >&6

4548

if test "${ac_cv_func_strerror_r_char_p+set}" = set; then

4549

echo $ECHO_N "(cached) $ECHO_C" >&6

4550

else

4551

4552

ac_cv_func_strerror_r_char_p=no

4553

if test $ac_cv_have_decl_strerror_r = yes; then

4554

cat >conftest.$ac_ext <<_ACEOF

4555

#line $LINENO "configure"

4556

/* confdefs.h. */

4557

_ACEOF

4558

cat confdefs.h >>conftest.$ac_ext

4559

cat >>conftest.$ac_ext <<_ACEOF

4560

/* end confdefs.h. */

4561

$ac_includes_default

4562

int

4563

main ()

4564

{

4565

4566

char buf[100];

4567

char x = *strerror_r (0, buf, sizeof buf);

4568

char *p = strerror_r (0, buf, sizeof buf);

4569

4570

;

4571

return 0;

4572

}

4573

_ACEOF

4574

rm -f conftest.$ac_objext

4575

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4576

(eval $ac_compile) 2>&5

4577

ac_status=$?

4578

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4579

(exit $ac_status); } &&

4580

{ ac_try='test -s conftest.$ac_objext'

4581

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4582

(eval $ac_try) 2>&5

4583

ac_status=$?

4584

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4585

(exit $ac_status); }; }; then

4586

ac_cv_func_strerror_r_char_p=yes

4587

else

4588

echo "$as_me: failed program was:" >&5

4589

sed 's/^/| /' conftest.$ac_ext >&5

4590

4591

4592

rm -f conftest.$ac_objext conftest.$ac_ext

4593

else

4594

# strerror_r is not declared. Choose between

4595

# systems that have relatively inaccessible declarations for the

4596

# function. BeOS and DEC UNIX 4.0 fall in this category, but the

4597

# former has a strerror_r that returns char*, while the latter

4598

# has a strerror_r that returns `int'.

4599

# This test should segfault on the DEC system.

4600

if test "$cross_compiling" = yes; then

4601

4602

else

4603

cat >conftest.$ac_ext <<_ACEOF

4604

#line $LINENO "configure"

4605

/* confdefs.h. */

4606

_ACEOF

4607

cat confdefs.h >>conftest.$ac_ext

4608

cat >>conftest.$ac_ext <<_ACEOF

4609

/* end confdefs.h. */

4610

$ac_includes_default

4611

extern char *strerror_r ();

4612

int

4613

main ()

4614

{

4615

char buf[100];

4616

char x = *strerror_r (0, buf, sizeof buf);

4617

exit (!isalpha (x));

4618

;

4619

return 0;

4620

}

4621

_ACEOF

4622

rm -f conftest$ac_exeext

4623

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4624

(eval $ac_link) 2>&5

4625

ac_status=$?

4626

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4627

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

4628

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4629

(eval $ac_try) 2>&5

4630

ac_status=$?

4631

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4632

(exit $ac_status); }; }; then

4633

ac_cv_func_strerror_r_char_p=yes

4634

else

4635

echo "$as_me: program exited with status $ac_status" >&5

4636

echo "$as_me: failed program was:" >&5

4637

sed 's/^/| /' conftest.$ac_ext >&5

4638

4639

4640

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

4641

4642

4643

4644

4645

echo "$as_me:$LINENO: result: $ac_cv_func_strerror_r_char_p" >&5

4646

echo "${ECHO_T}$ac_cv_func_strerror_r_char_p" >&6

4647

if test $ac_cv_func_strerror_r_char_p = yes; then

4648

4649

cat >>confdefs.h <<\_ACEOF

4650

#define STRERROR_R_CHAR_P 1

4651

_ACEOF

4652

4653

4654

4655

4656

4657

4658

4659

4660

4661

4662

4663

4664

4665

4666

4667

4668

4669

4670

4671

echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5

4672

echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6

4673

if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then

4674

echo $ECHO_N "(cached) $ECHO_C" >&6

4675

else

4676

cat >conftest.$ac_ext <<_ACEOF

4677

#line $LINENO "configure"

4678

/* confdefs.h. */

4679

_ACEOF

4680

cat confdefs.h >>conftest.$ac_ext

4681

cat >>conftest.$ac_ext <<_ACEOF

4682

/* end confdefs.h. */

4683

$ac_includes_default

4684

int

4685

main ()

4686

{

4687

static struct stat ac_aggr;

4688

if (ac_aggr.st_blocks)

4689

return 0;

4690

;

4691

return 0;

4692

}

4693

_ACEOF

4694

rm -f conftest.$ac_objext

4695

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4696

(eval $ac_compile) 2>&5

4697

ac_status=$?

4698

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4699

(exit $ac_status); } &&

4700

{ ac_try='test -s conftest.$ac_objext'

4701

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4702

(eval $ac_try) 2>&5

4703

ac_status=$?

4704

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4705

(exit $ac_status); }; }; then

4706

ac_cv_member_struct_stat_st_blocks=yes

4707

else

4708

echo "$as_me: failed program was:" >&5

4709

sed 's/^/| /' conftest.$ac_ext >&5

4710

4711

cat >conftest.$ac_ext <<_ACEOF

4712

#line $LINENO "configure"

4713

/* confdefs.h. */

4714

_ACEOF

4715

cat confdefs.h >>conftest.$ac_ext

4716

cat >>conftest.$ac_ext <<_ACEOF

4717

/* end confdefs.h. */

4718

$ac_includes_default

4719

int

4720

main ()

4721

{

4722

static struct stat ac_aggr;

4723

if (sizeof ac_aggr.st_blocks)

4724

return 0;

4725

;

4726

return 0;

4727

}

4728

_ACEOF

4729

rm -f conftest.$ac_objext

4730

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4731

(eval $ac_compile) 2>&5

4732

ac_status=$?

4733

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4734

(exit $ac_status); } &&

4735

{ ac_try='test -s conftest.$ac_objext'

4736

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4737

(eval $ac_try) 2>&5

4738

ac_status=$?

4739

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4740

(exit $ac_status); }; }; then

4741

ac_cv_member_struct_stat_st_blocks=yes

4742

else

4743

echo "$as_me: failed program was:" >&5

4744

sed 's/^/| /' conftest.$ac_ext >&5

4745

4746

ac_cv_member_struct_stat_st_blocks=no

4747

4748

rm -f conftest.$ac_objext conftest.$ac_ext

4749

4750

rm -f conftest.$ac_objext conftest.$ac_ext

4751

4752

echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5

4753

echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6

4754

if test $ac_cv_member_struct_stat_st_blocks = yes; then

4755

4756

cat >>confdefs.h <<_ACEOF

4757

#define HAVE_STRUCT_STAT_ST_BLOCKS 1

4758

_ACEOF

4759

4760

4761

cat >>confdefs.h <<\_ACEOF

4762

#define HAVE_ST_BLOCKS 1

4763

_ACEOF

4764

4765

else

4766

LIBOBJS="$LIBOBJS fileblocks.$ac_objext"

4767

4768

4769

4770

if test $ac_cv_member_struct_stat_st_blocks = no; then

4771

4772

4773

4774

4775

4776

4777

4778

4779

4780

4781

4782

4783

4784

4785

4786

echo "$as_me:$LINENO: checking whether stat file-mode macros are broken" >&5

4787

echo $ECHO_N "checking whether stat file-mode macros are broken... $ECHO_C" >&6

4788

if test "${ac_cv_header_stat_broken+set}" = set; then

4789

echo $ECHO_N "(cached) $ECHO_C" >&6

4790

else

4791

cat >conftest.$ac_ext <<_ACEOF

4792

#line $LINENO "configure"

4793

/* confdefs.h. */

4794

_ACEOF

4795

cat confdefs.h >>conftest.$ac_ext

4796

cat >>conftest.$ac_ext <<_ACEOF

4797

/* end confdefs.h. */

4798

#include <sys/types.h>

4799

#include <sys/stat.h>

4800

4801

#if defined(S_ISBLK) && defined(S_IFDIR)

4802

# if S_ISBLK (S_IFDIR)

4803

You lose.

4804

# endif

4805

#endif

4806

4807

#if defined(S_ISBLK) && defined(S_IFCHR)

4808

# if S_ISBLK (S_IFCHR)

4809

You lose.

4810

# endif

4811

#endif

4812

4813

#if defined(S_ISLNK) && defined(S_IFREG)

4814

# if S_ISLNK (S_IFREG)

4815

You lose.

4816

# endif

4817

#endif

4818

4819

#if defined(S_ISSOCK) && defined(S_IFREG)

4820

# if S_ISSOCK (S_IFREG)

4821

You lose.

4822

# endif

4823

#endif

4824

4825

_ACEOF

4826

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

4827

$EGREP "You lose" >/dev/null 2>&1; then

4828

ac_cv_header_stat_broken=yes

4829

else

4830

ac_cv_header_stat_broken=no

4831

4832

rm -f conftest*

4833

4834

4835

echo "$as_me:$LINENO: result: $ac_cv_header_stat_broken" >&5

4836

echo "${ECHO_T}$ac_cv_header_stat_broken" >&6

4837

if test $ac_cv_header_stat_broken = yes; then

4838

4839

cat >>confdefs.h <<\_ACEOF

4840

#define STAT_MACROS_BROKEN 1

4841

_ACEOF

4842

4843

4844

4845

4846

4847

4848

4849

# No macro. You should also use one of fnmatch-posix or fnmatch-gnu.

4850

4851

4852

4853

4854

am_getline_needs_run_time_check=no

4855

echo "$as_me:$LINENO: checking for getline" >&5

4856

echo $ECHO_N "checking for getline... $ECHO_C" >&6

4857

if test "${ac_cv_func_getline+set}" = set; then

4858

echo $ECHO_N "(cached) $ECHO_C" >&6

4859

else

4860

cat >conftest.$ac_ext <<_ACEOF

4861

#line $LINENO "configure"

4862

/* confdefs.h. */

4863

_ACEOF

4864

cat confdefs.h >>conftest.$ac_ext

4865

cat >>conftest.$ac_ext <<_ACEOF

4866

/* end confdefs.h. */

4867

/* System header to define __stub macros and hopefully few prototypes,

4868

which can conflict with char getline (); below.

4869

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4870

<limits.h> exists even on freestanding compilers. */

4871

#ifdef __STDC__

4872

# include <limits.h>

4873

#else

4874

# include <assert.h>

4875

#endif

4876

/* Override any gcc2 internal prototype to avoid an error. */

4877

#ifdef __cplusplus

4878

extern "C"

4879

{

4880

#endif

4881

/* We use char because int might match the return type of a gcc2

4882

builtin and then its argument prototype would still apply. */

4883

char getline ();

4884

/* The GNU C library defines this for functions which it implements

4885

to always fail with ENOSYS. Some functions are actually named

4886

something starting with __ and the normal name is an alias. */

4887

#if defined (__stub_getline) || defined (__stub___getline)

4888

choke me

4889

#else

4890

char (*f) () = getline;

4891

#endif

4892

#ifdef __cplusplus

4893

}

4894

#endif

4895

4896

int

4897

main ()

4898

{

4899

return f != getline;

4900

;

4901

return 0;

4902

}

4903

_ACEOF

4904

rm -f conftest.$ac_objext conftest$ac_exeext

4905

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4906

(eval $ac_link) 2>&5

4907

ac_status=$?

4908

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4909

(exit $ac_status); } &&

4910

{ ac_try='test -s conftest$ac_exeext'

4911

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4912

(eval $ac_try) 2>&5

4913

ac_status=$?

4914

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4915

(exit $ac_status); }; }; then

4916

ac_cv_func_getline=yes

4917

else

4918

echo "$as_me: failed program was:" >&5

4919

sed 's/^/| /' conftest.$ac_ext >&5

4920

4921

ac_cv_func_getline=no

4922

4923

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

4924

4925

echo "$as_me:$LINENO: result: $ac_cv_func_getline" >&5

4926

echo "${ECHO_T}$ac_cv_func_getline" >&6

4927

if test $ac_cv_func_getline = yes; then

4928

am_getline_needs_run_time_check=yes

4929

else

4930

am_cv_func_working_getline=no

4931

4932

4933

if test $am_getline_needs_run_time_check = yes; then

4934

echo "$as_me:$LINENO: checking for working getline function" >&5

4935

echo $ECHO_N "checking for working getline function... $ECHO_C" >&6

4936

if test "${am_cv_func_working_getline+set}" = set; then

4937

echo $ECHO_N "(cached) $ECHO_C" >&6

4938

else

4939

echo fooN |tr -d '\012'|tr N '\012' > conftest.data

4940

if test "$cross_compiling" = yes; then

4941

am_cv_func_working_getline=no

4942

else

4943

cat >conftest.$ac_ext <<_ACEOF

4944

#line $LINENO "configure"

4945

/* confdefs.h. */

4946

_ACEOF

4947

cat confdefs.h >>conftest.$ac_ext

4948

cat >>conftest.$ac_ext <<_ACEOF

4949

/* end confdefs.h. */

4950

4951

# include <stdio.h>

4952

# include <stdlib.h>

4953

# include <string.h>

4954

int main ()

4955

{ /* Based on a test program from Karl Heuer. */

4956

char *line = NULL;

4957

size_t siz = 0;

4958

int len;

4959

FILE *in = fopen ("./conftest.data", "r");

4960

if (!in)

4961

return 1;

4962

len = getline (&line, &siz, in);

4963

exit ((len == 4 && line && strcmp (line, "foo\n") == 0) ? 0 : 1);

4964

}

4965

4966

_ACEOF

4967

rm -f conftest$ac_exeext

4968

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4969

(eval $ac_link) 2>&5

4970

ac_status=$?

4971

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4972

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

4973

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4974

(eval $ac_try) 2>&5

4975

ac_status=$?

4976

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4977

(exit $ac_status); }; }; then

4978

am_cv_func_working_getline=yes

4979

else

4980

echo "$as_me: program exited with status $ac_status" >&5

4981

echo "$as_me: failed program was:" >&5

4982

sed 's/^/| /' conftest.$ac_ext >&5

4983

4984

( exit $ac_status )

4985

am_cv_func_working_getline=no

4986

4987

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

4988

4989

4990

echo "$as_me:$LINENO: result: $am_cv_func_working_getline" >&5

4991

echo "${ECHO_T}$am_cv_func_working_getline" >&6

4992

4993

4994

if test $am_cv_func_working_getline = no; then

4995

4996

cat >>confdefs.h <<\_ACEOF

4997

#define getline gnu_getline

4998

_ACEOF

4999

5000

LIBOBJS="$LIBOBJS getline.$ac_objext"

5001

5002

5003

5004

for ac_func in getdelim

5005

5006

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

5007

echo "$as_me:$LINENO: checking for $ac_func" >&5

5008

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

5009

if eval "test \"\${$as_ac_var+set}\" = set"; then

5010

echo $ECHO_N "(cached) $ECHO_C" >&6

5011

else

5012

cat >conftest.$ac_ext <<_ACEOF

5013

#line $LINENO "configure"

5014

/* confdefs.h. */

5015

_ACEOF

5016

cat confdefs.h >>conftest.$ac_ext

5017

cat >>conftest.$ac_ext <<_ACEOF

5018

/* end confdefs.h. */

5019

/* System header to define __stub macros and hopefully few prototypes,

5020

which can conflict with char $ac_func (); below.

5021

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

5022

<limits.h> exists even on freestanding compilers. */

5023

#ifdef __STDC__

5024

# include <limits.h>

5025

#else

5026

# include <assert.h>

5027

#endif

5028

/* Override any gcc2 internal prototype to avoid an error. */

5029

#ifdef __cplusplus

5030

extern "C"

5031

{

5032

#endif

5033

/* We use char because int might match the return type of a gcc2

5034

builtin and then its argument prototype would still apply. */

5035

char $ac_func ();

5036

/* The GNU C library defines this for functions which it implements

5037

to always fail with ENOSYS. Some functions are actually named

5038

something starting with __ and the normal name is an alias. */

5039

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

5040

choke me

5041

#else

5042

char (*f) () = $ac_func;

5043

#endif

5044

#ifdef __cplusplus

5045

}

5046

#endif

5047

5048

int

5049

main ()

5050

{

5051

return f != $ac_func;

5052

;

5053

return 0;

5054

}

5055

_ACEOF

5056

rm -f conftest.$ac_objext conftest$ac_exeext

5057

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5058

(eval $ac_link) 2>&5

5059

ac_status=$?

5060

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5061

(exit $ac_status); } &&

5062

{ ac_try='test -s conftest$ac_exeext'

5063

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5064

(eval $ac_try) 2>&5

5065

ac_status=$?

5066

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5067

(exit $ac_status); }; }; then

5068

eval "$as_ac_var=yes"

5069

else

5070

echo "$as_me: failed program was:" >&5

5071

sed 's/^/| /' conftest.$ac_ext >&5

5072

5073

eval "$as_ac_var=no"

5074

5075

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

5076

5077

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

5078

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

5079

if test `eval echo '${'$as_ac_var'}'` = yes; then

5080

cat >>confdefs.h <<_ACEOF

5081

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

5082

_ACEOF

5083

5084

5085

done

5086

5087

5088

5089

5090

5091

5092

5093

5094

5095

5096

5097

5098

5099

5100

5101

5102

MKINSTALLDIRS=

5103

if test -n "$ac_aux_dir"; then

5104

MKINSTALLDIRS="$ac_aux_dir/mkinstalldirs"

5105

5106

if test -z "$MKINSTALLDIRS"; then

5107

MKINSTALLDIRS="\$(top_srcdir)/mkinstalldirs"

5108

5109

5110

5111

5112

5113

5114

# Extract the first word of "msgfmt", so it can be a program name with args.

5115

set dummy msgfmt; ac_word=$2

5116

echo "$as_me:$LINENO: checking for $ac_word" >&5

5117

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

5118

if test "${ac_cv_path_MSGFMT+set}" = set; then

5119

echo $ECHO_N "(cached) $ECHO_C" >&6

5120

else

5121

case "$MSGFMT" in

5122

/*)

5123

ac_cv_path_MSGFMT="$MSGFMT" # Let the user override the test with a path.

5124

;;

5125

5126

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"

5127

for ac_dir in $PATH; do

5128

test -z "$ac_dir" && ac_dir=.

5129

if test -f $ac_dir/$ac_word; then

5130

if $ac_dir/$ac_word --statistics /dev/null >/dev/null 2>&1 &&

5131

(if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then

5132

ac_cv_path_MSGFMT="$ac_dir/$ac_word"

5133

break

5134

5135

5136

done

5137

IFS="$ac_save_ifs"

5138

test -z "$ac_cv_path_MSGFMT" && ac_cv_path_MSGFMT=":"

5139

;;

5140

esac

5141

5142

MSGFMT="$ac_cv_path_MSGFMT"

5143

if test "$MSGFMT" != ":"; then

5144

echo "$as_me:$LINENO: result: $MSGFMT" >&5

5145

echo "${ECHO_T}$MSGFMT" >&6

5146

else

5147

echo "$as_me:$LINENO: result: no" >&5

5148

echo "${ECHO_T}no" >&6

5149

5150

5151

# Extract the first word of "gmsgfmt", so it can be a program name with args.

5152

set dummy gmsgfmt; ac_word=$2

5153

echo "$as_me:$LINENO: checking for $ac_word" >&5

5154

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

5155

if test "${ac_cv_path_GMSGFMT+set}" = set; then

5156

echo $ECHO_N "(cached) $ECHO_C" >&6

5157

else

5158

case $GMSGFMT in

5159

[\\/]* | ?:[\\/]*)

5160

ac_cv_path_GMSGFMT="$GMSGFMT" # Let the user override the test with a path.

5161

;;

5162

5163

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

5164

for as_dir in $PATH

5165

5166

IFS=$as_save_IFS

5167

test -z "$as_dir" && as_dir=.

5168

for ac_exec_ext in '' $ac_executable_extensions; do

5169

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

5170

ac_cv_path_GMSGFMT="$as_dir/$ac_word$ac_exec_ext"

5171

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

5172

break 2

5173

5174

done

5175

done

5176

5177

test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT"

5178

;;

5179

esac

5180

5181

GMSGFMT=$ac_cv_path_GMSGFMT

5182

5183

if test -n "$GMSGFMT"; then

5184

echo "$as_me:$LINENO: result: $GMSGFMT" >&5

5185

echo "${ECHO_T}$GMSGFMT" >&6

5186

else

5187

echo "$as_me:$LINENO: result: no" >&5

5188

echo "${ECHO_T}no" >&6

5189

5190

5191

5192

# Extract the first word of "xgettext", so it can be a program name with args.

5193

set dummy xgettext; ac_word=$2

5194

echo "$as_me:$LINENO: checking for $ac_word" >&5

5195

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

5196

if test "${ac_cv_path_XGETTEXT+set}" = set; then

5197

echo $ECHO_N "(cached) $ECHO_C" >&6

5198

else

5199

case "$XGETTEXT" in

5200

/*)

5201

ac_cv_path_XGETTEXT="$XGETTEXT" # Let the user override the test with a path.

5202

;;

5203

5204

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"

5205

for ac_dir in $PATH; do

5206

test -z "$ac_dir" && ac_dir=.

5207

if test -f $ac_dir/$ac_word; then

5208

if $ac_dir/$ac_word --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 &&

5209

(if $ac_dir/$ac_word --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then

5210

ac_cv_path_XGETTEXT="$ac_dir/$ac_word"

5211

break

5212

5213

5214

done

5215

IFS="$ac_save_ifs"

5216

test -z "$ac_cv_path_XGETTEXT" && ac_cv_path_XGETTEXT=":"

5217

;;

5218

esac

5219

5220

XGETTEXT="$ac_cv_path_XGETTEXT"

5221

if test "$XGETTEXT" != ":"; then

5222

echo "$as_me:$LINENO: result: $XGETTEXT" >&5

5223

echo "${ECHO_T}$XGETTEXT" >&6

5224

else

5225

echo "$as_me:$LINENO: result: no" >&5

5226

echo "${ECHO_T}no" >&6

5227

5228

5229

rm -f messages.po

5230

5231

# Extract the first word of "msgmerge", so it can be a program name with args.

5232

set dummy msgmerge; ac_word=$2

5233

echo "$as_me:$LINENO: checking for $ac_word" >&5

5234

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

5235

if test "${ac_cv_path_MSGMERGE+set}" = set; then

5236

echo $ECHO_N "(cached) $ECHO_C" >&6

5237

else

5238

case "$MSGMERGE" in

5239

/*)

5240

ac_cv_path_MSGMERGE="$MSGMERGE" # Let the user override the test with a path.

5241

;;

5242

5243

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"

5244

for ac_dir in $PATH; do

5245

test -z "$ac_dir" && ac_dir=.

5246

if test -f $ac_dir/$ac_word; then

5247

if $ac_dir/$ac_word --update -q /dev/null /dev/null >/dev/null 2>&1; then

5248

ac_cv_path_MSGMERGE="$ac_dir/$ac_word"

5249

break

5250

5251

5252

done

5253

IFS="$ac_save_ifs"

5254

test -z "$ac_cv_path_MSGMERGE" && ac_cv_path_MSGMERGE=":"

5255

;;

5256

esac

5257

5258

MSGMERGE="$ac_cv_path_MSGMERGE"

5259

if test "$MSGMERGE" != ":"; then

5260

echo "$as_me:$LINENO: result: $MSGMERGE" >&5

5261

echo "${ECHO_T}$MSGMERGE" >&6

5262

else

5263

echo "$as_me:$LINENO: result: no" >&5

5264

echo "${ECHO_T}no" >&6

5265

5266

5267

5268

if test "$GMSGFMT" != ":"; then

5269

if $GMSGFMT --statistics /dev/null >/dev/null 2>&1 &&

5270

(if $GMSGFMT --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then

5271

: ;

5272

else

5273

GMSGFMT=`echo "$GMSGFMT" | sed -e 's,^.*/,,'`

5274

echo "$as_me:$LINENO: result: found $GMSGFMT program is not GNU msgfmt; ignore it" >&5

5275

echo "${ECHO_T}found $GMSGFMT program is not GNU msgfmt; ignore it" >&6

5276

GMSGFMT=":"

5277

5278

5279

5280

if test "$XGETTEXT" != ":"; then

5281

if $XGETTEXT --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 &&

5282

(if $XGETTEXT --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then

5283

: ;

5284

else

5285

echo "$as_me:$LINENO: result: found xgettext program is not GNU xgettext; ignore it" >&5

5286

echo "${ECHO_T}found xgettext program is not GNU xgettext; ignore it" >&6

5287

XGETTEXT=":"

5288

5289

rm -f messages.po

5290

5291

5292

ac_config_commands="$ac_config_commands default-1"

5293

5294

5295

5296

if test "X$prefix" = "XNONE"; then

5297

acl_final_prefix="$ac_default_prefix"

5298

else

5299

acl_final_prefix="$prefix"

5300

5301

if test "X$exec_prefix" = "XNONE"; then

5302

acl_final_exec_prefix='${prefix}'

5303

else

5304

acl_final_exec_prefix="$exec_prefix"

5305

5306

acl_save_prefix="$prefix"

5307

prefix="$acl_final_prefix"

5308

eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"

5309

prefix="$acl_save_prefix"

5310

5311

# Make sure we can run config.sub.

5312

$ac_config_sub sun4 >/dev/null 2>&1 ||

5313

{ { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5

5314

echo "$as_me: error: cannot run $ac_config_sub" >&2;}

5315

{ (exit 1); exit 1; }; }

5316

5317

echo "$as_me:$LINENO: checking build system type" >&5

5318

echo $ECHO_N "checking build system type... $ECHO_C" >&6

5319

if test "${ac_cv_build+set}" = set; then

5320

echo $ECHO_N "(cached) $ECHO_C" >&6

5321

else

5322

ac_cv_build_alias=$build_alias

5323

test -z "$ac_cv_build_alias" &&

5324

ac_cv_build_alias=`$ac_config_guess`

5325

test -z "$ac_cv_build_alias" &&

5326

{ { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5

5327

echo "$as_me: error: cannot guess build type; you must specify one" >&2;}

5328

{ (exit 1); exit 1; }; }

5329

ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||

5330

{ { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5

5331

echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}

5332

{ (exit 1); exit 1; }; }

5333

5334

5335

echo "$as_me:$LINENO: result: $ac_cv_build" >&5

5336

echo "${ECHO_T}$ac_cv_build" >&6

5337

build=$ac_cv_build

5338

build_cpu=`echo $ac_cv_build | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\1/'`

5339

build_vendor=`echo $ac_cv_build | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\2/'`

5340

build_os=`echo $ac_cv_build | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\3/'`

5341

5342

5343

echo "$as_me:$LINENO: checking host system type" >&5

5344

echo $ECHO_N "checking host system type... $ECHO_C" >&6

5345

if test "${ac_cv_host+set}" = set; then

5346

echo $ECHO_N "(cached) $ECHO_C" >&6

5347

else

5348

ac_cv_host_alias=$host_alias

5349

test -z "$ac_cv_host_alias" &&

5350

ac_cv_host_alias=$ac_cv_build_alias

5351

ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||

5352

{ { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5

5353

echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}

5354

{ (exit 1); exit 1; }; }

5355

5356

5357

echo "$as_me:$LINENO: result: $ac_cv_host" >&5

5358

echo "${ECHO_T}$ac_cv_host" >&6

5359

host=$ac_cv_host

5360

host_cpu=`echo $ac_cv_host | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\1/'`

5361

host_vendor=`echo $ac_cv_host | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\2/'`

5362

host_os=`echo $ac_cv_host | sed 's/^$[^-]*$-$[^-]*$-$.*$$/\3/'`

5363

5364

5365

5366

# Check whether --with-gnu-ld or --without-gnu-ld was given.

5367

if test "${with_gnu_ld+set}" = set; then

5368

withval="$with_gnu_ld"

5369

test "$withval" = no || with_gnu_ld=yes

5370

else

5371

with_gnu_ld=no

5372

fi;

5373

ac_prog=ld

5374

if test "$GCC" = yes; then

5375

# Check if gcc -print-prog-name=ld gives a path.

5376

echo "$as_me:$LINENO: checking for ld used by GCC" >&5

5377

echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6

5378

case $host in

5379

*-*-mingw*)

5380

# gcc leaves a trailing carriage return which upsets mingw

5381

ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

5382

5383

ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

5384

esac

5385

case $ac_prog in

5386

# Accept absolute paths.

5387

[\\/]* | [A-Za-z]:[\\/]*)

5388

re_direlt='/[^/][^/]*/\.\./'

5389

# Canonicalize the path of ld

5390

ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`

5391

while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

5392

ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`

5393

done

5394

test -z "$LD" && LD="$ac_prog"

5395

;;

5396

"")

5397

# If it fails, then pretend we aren't using GCC.

5398

ac_prog=ld

5399

;;

5400

5401

# If it is relative, then search for the first ld in PATH.

5402

with_gnu_ld=unknown

5403

;;

5404

esac

5405

elif test "$with_gnu_ld" = yes; then

5406

echo "$as_me:$LINENO: checking for GNU ld" >&5

5407

echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6

5408

else

5409

echo "$as_me:$LINENO: checking for non-GNU ld" >&5

5410

echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6

5411

5412

if test "${acl_cv_path_LD+set}" = set; then

5413

echo $ECHO_N "(cached) $ECHO_C" >&6

5414

else

5415

if test -z "$LD"; then

5416

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"

5417

for ac_dir in $PATH; do

5418

test -z "$ac_dir" && ac_dir=.

5419

if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

5420

acl_cv_path_LD="$ac_dir/$ac_prog"

5421

# Check to see if the program is GNU ld. I'd rather use --version,

5422

# but apparently some GNU ld's only accept -v.

5423

# Break only if it was the GNU/non-GNU ld that we prefer.

5424

if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then

5425

test "$with_gnu_ld" != no && break

5426

else

5427

test "$with_gnu_ld" != yes && break

5428

5429

5430

done

5431

IFS="$ac_save_ifs"

5432

else

5433

acl_cv_path_LD="$LD" # Let the user override the test with a path.

5434

5435

5436

5437

LD="$acl_cv_path_LD"

5438

if test -n "$LD"; then

5439

echo "$as_me:$LINENO: result: $LD" >&5

5440

echo "${ECHO_T}$LD" >&6

5441

else

5442

echo "$as_me:$LINENO: result: no" >&5

5443

echo "${ECHO_T}no" >&6

5444

5445

test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5

5446

echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}

5447

{ (exit 1); exit 1; }; }

5448

echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5

5449

echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6

5450

if test "${acl_cv_prog_gnu_ld+set}" = set; then

5451

echo $ECHO_N "(cached) $ECHO_C" >&6

5452

else

5453

# I'd rather use --version here, but apparently some GNU ld's only accept -v.

5454

if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then

5455

acl_cv_prog_gnu_ld=yes

5456

else

5457

acl_cv_prog_gnu_ld=no

5458

5459

5460

echo "$as_me:$LINENO: result: $acl_cv_prog_gnu_ld" >&5

5461

echo "${ECHO_T}$acl_cv_prog_gnu_ld" >&6

5462

with_gnu_ld=$acl_cv_prog_gnu_ld

5463

5464

5465

5466

echo "$as_me:$LINENO: checking for shared library run path origin" >&5

5467

echo $ECHO_N "checking for shared library run path origin... $ECHO_C" >&6

5468

if test "${acl_cv_rpath+set}" = set; then

5469

echo $ECHO_N "(cached) $ECHO_C" >&6

5470

else

5471

5472

CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \

5473

${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh

5474

. ./conftest.sh

5475

rm -f ./conftest.sh

5476

acl_cv_rpath=done

5477

5478

5479

echo "$as_me:$LINENO: result: $acl_cv_rpath" >&5

5480

echo "${ECHO_T}$acl_cv_rpath" >&6

5481

wl="$acl_cv_wl"

5482

libext="$acl_cv_libext"

5483

shlibext="$acl_cv_shlibext"

5484

hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"

5485

hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"

5486

hardcode_direct="$acl_cv_hardcode_direct"

5487

hardcode_minus_L="$acl_cv_hardcode_minus_L"

5488

sys_lib_search_path_spec="$acl_cv_sys_lib_search_path_spec"

5489

sys_lib_dlsearch_path_spec="$acl_cv_sys_lib_dlsearch_path_spec"

5490

# Check whether --enable-rpath or --disable-rpath was given.

5491

if test "${enable_rpath+set}" = set; then

5492

enableval="$enable_rpath"

5493

5494

else

5495

enable_rpath=yes

5496

fi;

5497

5498

5499

5500

5501

5502

5503

5504

use_additional=yes

5505

5506

acl_save_prefix="$prefix"

5507

prefix="$acl_final_prefix"

5508

acl_save_exec_prefix="$exec_prefix"

5509

exec_prefix="$acl_final_exec_prefix"

5510

5511

eval additional_includedir=\"$includedir\"

5512

eval additional_libdir=\"$libdir\"

5513

5514

exec_prefix="$acl_save_exec_prefix"

5515

prefix="$acl_save_prefix"

5516

5517

5518

# Check whether --with-libiconv-prefix or --without-libiconv-prefix was given.

5519

if test "${with_libiconv_prefix+set}" = set; then

5520

withval="$with_libiconv_prefix"

5521

5522

if test "X$withval" = "Xno"; then

5523

use_additional=no

5524

else

5525

if test "X$withval" = "X"; then

5526

5527

acl_save_prefix="$prefix"

5528

prefix="$acl_final_prefix"

5529

acl_save_exec_prefix="$exec_prefix"

5530

exec_prefix="$acl_final_exec_prefix"

5531

5532

eval additional_includedir=\"$includedir\"

5533

eval additional_libdir=\"$libdir\"

5534

5535

exec_prefix="$acl_save_exec_prefix"

5536

prefix="$acl_save_prefix"

5537

5538

else

5539

additional_includedir="$withval/include"

5540

additional_libdir="$withval/lib"

5541

5542

5543

5544

fi;

5545

LIBICONV=

5546

LTLIBICONV=

5547

INCICONV=

5548

rpathdirs=

5549

ltrpathdirs=

5550

names_already_handled=

5551

names_next_round='iconv '

5552

while test -n "$names_next_round"; do

5553

names_this_round="$names_next_round"

5554

names_next_round=

5555

for name in $names_this_round; do

5556

already_handled=

5557

for n in $names_already_handled; do

5558

if test "$n" = "$name"; then

5559

already_handled=yes

5560

break

5561

5562

done

5563

if test -z "$already_handled"; then

5564

names_already_handled="$names_already_handled $name"

5565

uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`

5566

eval value=\"\$HAVE_LIB$uppername\"

5567

if test -n "$value"; then

5568

if test "$value" = yes; then

5569

eval value=\"\$LIB$uppername\"

5570

test -z "$value" || LIBICONV="${LIBICONV}${LIBICONV:+ }$value"

5571

eval value=\"\$LTLIB$uppername\"

5572

test -z "$value" || LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }$value"

5573

else

5574

5575

5576

else

5577

found_dir=

5578

found_la=

5579

found_so=

5580

found_a=

5581

if test $use_additional = yes; then

5582

if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then

5583

found_dir="$additional_libdir"

5584

found_so="$additional_libdir/lib$name.$shlibext"

5585

if test -f "$additional_libdir/lib$name.la"; then

5586

found_la="$additional_libdir/lib$name.la"

5587

5588

else

5589

if test -f "$additional_libdir/lib$name.$libext"; then

5590

found_dir="$additional_libdir"

5591

found_a="$additional_libdir/lib$name.$libext"

5592

if test -f "$additional_libdir/lib$name.la"; then

5593

found_la="$additional_libdir/lib$name.la"

5594

5595

5596

5597

5598

if test "X$found_dir" = "X"; then

5599

for x in $LDFLAGS $LTLIBICONV; do

5600

5601

acl_save_prefix="$prefix"

5602

prefix="$acl_final_prefix"

5603

acl_save_exec_prefix="$exec_prefix"

5604

exec_prefix="$acl_final_exec_prefix"

5605

eval x=\"$x\"

5606

exec_prefix="$acl_save_exec_prefix"

5607

prefix="$acl_save_prefix"

5608

5609

case "$x" in

5610

-L*)

5611

dir=`echo "X$x" | sed -e 's/^X-L//'`

5612

if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then

5613

found_dir="$dir"

5614

found_so="$dir/lib$name.$shlibext"

5615

if test -f "$dir/lib$name.la"; then

5616

found_la="$dir/lib$name.la"

5617

5618

else

5619

if test -f "$dir/lib$name.$libext"; then

5620

found_dir="$dir"

5621

found_a="$dir/lib$name.$libext"

5622

if test -f "$dir/lib$name.la"; then

5623

found_la="$dir/lib$name.la"

5624

5625

5626

5627

;;

5628

esac

5629

if test "X$found_dir" != "X"; then

5630

break

5631

5632

done

5633

5634

if test "X$found_dir" != "X"; then

5635

LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-L$found_dir -l$name"

5636

if test "X$found_so" != "X"; then

5637

if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then

5638

LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"

5639

else

5640

haveit=

5641

for x in $ltrpathdirs; do

5642

if test "X$x" = "X$found_dir"; then

5643

haveit=yes

5644

break

5645

5646

done

5647

if test -z "$haveit"; then

5648

ltrpathdirs="$ltrpathdirs $found_dir"

5649

5650

if test "$hardcode_direct" = yes; then

5651

LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"

5652

else

5653

if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then

5654

LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"

5655

haveit=

5656

for x in $rpathdirs; do

5657

if test "X$x" = "X$found_dir"; then

5658

haveit=yes

5659

break

5660

5661

done

5662

if test -z "$haveit"; then

5663

rpathdirs="$rpathdirs $found_dir"

5664

5665

else

5666

haveit=

5667

for x in $LDFLAGS $LIBICONV; do

5668

5669

acl_save_prefix="$prefix"

5670

prefix="$acl_final_prefix"

5671

acl_save_exec_prefix="$exec_prefix"

5672

exec_prefix="$acl_final_exec_prefix"

5673

eval x=\"$x\"

5674

exec_prefix="$acl_save_exec_prefix"

5675

prefix="$acl_save_prefix"

5676

5677

if test "X$x" = "X-L$found_dir"; then

5678

haveit=yes

5679

break

5680

5681

done

5682

if test -z "$haveit"; then

5683

LIBICONV="${LIBICONV}${LIBICONV:+ }-L$found_dir"

5684

5685

if test "$hardcode_minus_L" != no; then

5686

LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"

5687

else

5688

LIBICONV="${LIBICONV}${LIBICONV:+ }-l$name"

5689

5690

5691

5692

5693

else

5694

if test "X$found_a" != "X"; then

5695

LIBICONV="${LIBICONV}${LIBICONV:+ }$found_a"

5696

else

5697

LIBICONV="${LIBICONV}${LIBICONV:+ }-L$found_dir -l$name"

5698

5699

5700

additional_includedir=

5701

case "$found_dir" in

5702

*/lib | */lib/)

5703

basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'`

5704

additional_includedir="$basedir/include"

5705

;;

5706

esac

5707

if test "X$additional_includedir" != "X"; then

5708

if test "X$additional_includedir" != "X/usr/include"; then

5709

haveit=

5710

if test "X$additional_includedir" = "X/usr/local/include"; then

5711

if test -n "$GCC"; then

5712

case $host_os in

5713

linux*) haveit=yes;;

5714

esac

5715

5716

5717

if test -z "$haveit"; then

5718

for x in $CPPFLAGS $INCICONV; do

5719

5720

acl_save_prefix="$prefix"

5721

prefix="$acl_final_prefix"

5722

acl_save_exec_prefix="$exec_prefix"

5723

exec_prefix="$acl_final_exec_prefix"

5724

eval x=\"$x\"

5725

exec_prefix="$acl_save_exec_prefix"

5726

prefix="$acl_save_prefix"

5727

5728

if test "X$x" = "X-I$additional_includedir"; then

5729

haveit=yes

5730

break

5731

5732

done

5733

if test -z "$haveit"; then

5734

if test -d "$additional_includedir"; then

5735

INCICONV="${INCICONV}${INCICONV:+ }-I$additional_includedir"

5736

5737

5738

5739

5740

5741

if test -n "$found_la"; then

5742

save_libdir="$libdir"

5743

case "$found_la" in

5744

*/* | *\\*) . "$found_la" ;;

5745

*) . "./$found_la" ;;

5746

esac

5747

libdir="$save_libdir"

5748

for dep in $dependency_libs; do

5749

case "$dep" in

5750

-L*)

5751

additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`

5752

if test "X$additional_libdir" != "X/usr/lib"; then

5753

haveit=

5754

if test "X$additional_libdir" = "X/usr/local/lib"; then

5755

if test -n "$GCC"; then

5756

case $host_os in

5757

linux*) haveit=yes;;

5758

esac

5759

5760

5761

if test -z "$haveit"; then

5762

haveit=

5763

for x in $LDFLAGS $LIBICONV; do

5764

5765

acl_save_prefix="$prefix"

5766

prefix="$acl_final_prefix"

5767

acl_save_exec_prefix="$exec_prefix"

5768

exec_prefix="$acl_final_exec_prefix"

5769

eval x=\"$x\"

5770

exec_prefix="$acl_save_exec_prefix"

5771

prefix="$acl_save_prefix"

5772

5773

if test "X$x" = "X-L$additional_libdir"; then

5774

haveit=yes

5775

break

5776

5777

done

5778

if test -z "$haveit"; then

5779

if test -d "$additional_libdir"; then

5780

LIBICONV="${LIBICONV}${LIBICONV:+ }-L$additional_libdir"

5781

5782

5783

haveit=

5784

for x in $LDFLAGS $LTLIBICONV; do

5785

5786

acl_save_prefix="$prefix"

5787

prefix="$acl_final_prefix"

5788

acl_save_exec_prefix="$exec_prefix"

5789

exec_prefix="$acl_final_exec_prefix"

5790

eval x=\"$x\"

5791

exec_prefix="$acl_save_exec_prefix"

5792

prefix="$acl_save_prefix"

5793

5794

if test "X$x" = "X-L$additional_libdir"; then

5795

haveit=yes

5796

break

5797

5798

done

5799

if test -z "$haveit"; then

5800

if test -d "$additional_libdir"; then

5801

LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-L$additional_libdir"

5802

5803

5804

5805

5806

;;

5807

-R*)

5808

dir=`echo "X$dep" | sed -e 's/^X-R//'`

5809

if test "$enable_rpath" != no; then

5810

haveit=

5811

for x in $rpathdirs; do

5812

if test "X$x" = "X$dir"; then

5813

haveit=yes

5814

break

5815

5816

done

5817

if test -z "$haveit"; then

5818

rpathdirs="$rpathdirs $dir"

5819

5820

haveit=

5821

for x in $ltrpathdirs; do

5822

if test "X$x" = "X$dir"; then

5823

haveit=yes

5824

break

5825

5826

done

5827

if test -z "$haveit"; then

5828

ltrpathdirs="$ltrpathdirs $dir"

5829

5830

5831

;;

5832

-l*)

5833

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`

5834

;;

5835

*.la)

5836

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`

5837

;;

5838

5839

LIBICONV="${LIBICONV}${LIBICONV:+ }$dep"

5840

LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }$dep"

5841

;;

5842

esac

5843

done

5844

5845

else

5846

LIBICONV="${LIBICONV}${LIBICONV:+ }-l$name"

5847

LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-l$name"

5848

5849

5850

5851

done

5852

done

5853

if test "X$rpathdirs" != "X"; then

5854

if test -n "$hardcode_libdir_separator"; then

5855

alldirs=

5856

for found_dir in $rpathdirs; do

5857

alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir"

5858

done

5859

acl_save_libdir="$libdir"

5860

libdir="$alldirs"

5861

eval flag=\"$hardcode_libdir_flag_spec\"

5862

libdir="$acl_save_libdir"

5863

LIBICONV="${LIBICONV}${LIBICONV:+ }$flag"

5864

else

5865

for found_dir in $rpathdirs; do

5866

acl_save_libdir="$libdir"

5867

libdir="$found_dir"

5868

eval flag=\"$hardcode_libdir_flag_spec\"

5869

libdir="$acl_save_libdir"

5870

LIBICONV="${LIBICONV}${LIBICONV:+ }$flag"

5871

done

5872

5873

5874

if test "X$ltrpathdirs" != "X"; then

5875

for found_dir in $ltrpathdirs; do

5876

LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-R$found_dir"

5877

done

5878

5879

5880

5881

5882

5883

5884

5885

5886

5887

5888

5889

5890

5891

5892

5893

5894

5895

5896

echo "$as_me:$LINENO: checking whether NLS is requested" >&5

5897

echo $ECHO_N "checking whether NLS is requested... $ECHO_C" >&6

5898

# Check whether --enable-nls or --disable-nls was given.

5899

if test "${enable_nls+set}" = set; then

5900

enableval="$enable_nls"

5901

USE_NLS=$enableval

5902

else

5903

USE_NLS=yes

5904

fi;

5905

echo "$as_me:$LINENO: result: $USE_NLS" >&5

5906

echo "${ECHO_T}$USE_NLS" >&6

5907

5908

5909

5910

LIBINTL=

5911

LTLIBINTL=

5912

POSUB=

5913

5914

if test "$USE_NLS" = "yes"; then

5915

gt_use_preinstalled_gnugettext=no

5916

5917

5918

5919

5920

5921

5922

echo "$as_me:$LINENO: checking for GNU gettext in libc" >&5

5923

echo $ECHO_N "checking for GNU gettext in libc... $ECHO_C" >&6

5924

if test "${gt_cv_func_gnugettext1_libc+set}" = set; then

5925

echo $ECHO_N "(cached) $ECHO_C" >&6

5926

else

5927

cat >conftest.$ac_ext <<_ACEOF

5928

#line $LINENO "configure"

5929

/* confdefs.h. */

5930

_ACEOF

5931

cat confdefs.h >>conftest.$ac_ext

5932

cat >>conftest.$ac_ext <<_ACEOF

5933

/* end confdefs.h. */

5934

#include <libintl.h>

5935

extern int _nl_msg_cat_cntr;

5936

extern int *_nl_domain_bindings;

5937

int

5938

main ()

5939

{

5940

bindtextdomain ("", "");

5941

return (int) gettext ("") + _nl_msg_cat_cntr + *_nl_domain_bindings

5942

;

5943

return 0;

5944

}

5945

_ACEOF

5946

rm -f conftest.$ac_objext conftest$ac_exeext

5947

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5948

(eval $ac_link) 2>&5

5949

ac_status=$?

5950

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5951

(exit $ac_status); } &&

5952

{ ac_try='test -s conftest$ac_exeext'

5953

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5954

(eval $ac_try) 2>&5

5955

ac_status=$?

5956

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5957

(exit $ac_status); }; }; then

5958

gt_cv_func_gnugettext1_libc=yes

5959

else

5960

echo "$as_me: failed program was:" >&5

5961

sed 's/^/| /' conftest.$ac_ext >&5

5962

5963

gt_cv_func_gnugettext1_libc=no

5964

5965

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

5966

5967

echo "$as_me:$LINENO: result: $gt_cv_func_gnugettext1_libc" >&5

5968

echo "${ECHO_T}$gt_cv_func_gnugettext1_libc" >&6

5969

5970

if test "$gt_cv_func_gnugettext1_libc" != "yes"; then

5971

5972

5973

5974

5975

5976

am_save_CPPFLAGS="$CPPFLAGS"

5977

5978

for element in $INCICONV; do

5979

haveit=

5980

for x in $CPPFLAGS; do

5981

5982

acl_save_prefix="$prefix"

5983

prefix="$acl_final_prefix"

5984

acl_save_exec_prefix="$exec_prefix"

5985

exec_prefix="$acl_final_exec_prefix"

5986

eval x=\"$x\"

5987

exec_prefix="$acl_save_exec_prefix"

5988

prefix="$acl_save_prefix"

5989

5990

if test "X$x" = "X$element"; then

5991

haveit=yes

5992

break

5993

5994

done

5995

if test -z "$haveit"; then

5996

CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"

5997

5998

done

5999

6000

6001

echo "$as_me:$LINENO: checking for iconv" >&5

6002

echo $ECHO_N "checking for iconv... $ECHO_C" >&6

6003

if test "${am_cv_func_iconv+set}" = set; then

6004

echo $ECHO_N "(cached) $ECHO_C" >&6

6005

else

6006

6007

am_cv_func_iconv="no, consider installing GNU libiconv"

6008

am_cv_lib_iconv=no

6009

cat >conftest.$ac_ext <<_ACEOF

6010

#line $LINENO "configure"

6011

/* confdefs.h. */

6012

_ACEOF

6013

cat confdefs.h >>conftest.$ac_ext

6014

cat >>conftest.$ac_ext <<_ACEOF

6015

/* end confdefs.h. */

6016

#include <stdlib.h>

6017

#include <iconv.h>

6018

int

6019

main ()

6020

{

6021

iconv_t cd = iconv_open("","");

6022

iconv(cd,NULL,NULL,NULL,NULL);

6023

iconv_close(cd);

6024

;

6025

return 0;

6026

}

6027

_ACEOF

6028

rm -f conftest.$ac_objext conftest$ac_exeext

6029

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6030

(eval $ac_link) 2>&5

6031

ac_status=$?

6032

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6033

(exit $ac_status); } &&

6034

{ ac_try='test -s conftest$ac_exeext'

6035

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6036

(eval $ac_try) 2>&5

6037

ac_status=$?

6038

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6039

(exit $ac_status); }; }; then

6040

am_cv_func_iconv=yes

6041

else

6042

echo "$as_me: failed program was:" >&5

6043

sed 's/^/| /' conftest.$ac_ext >&5

6044

6045

6046

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

6047

if test "$am_cv_func_iconv" != yes; then

6048

am_save_LIBS="$LIBS"

6049

LIBS="$LIBS $LIBICONV"

6050

cat >conftest.$ac_ext <<_ACEOF

6051

#line $LINENO "configure"

6052

/* confdefs.h. */

6053

_ACEOF

6054

cat confdefs.h >>conftest.$ac_ext

6055

cat >>conftest.$ac_ext <<_ACEOF

6056

/* end confdefs.h. */

6057

#include <stdlib.h>

6058

#include <iconv.h>

6059

int

6060

main ()

6061

{

6062

iconv_t cd = iconv_open("","");

6063

iconv(cd,NULL,NULL,NULL,NULL);

6064

iconv_close(cd);

6065

;

6066

return 0;

6067

}

6068

_ACEOF

6069

rm -f conftest.$ac_objext conftest$ac_exeext

6070

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6071

(eval $ac_link) 2>&5

6072

ac_status=$?

6073

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6074

(exit $ac_status); } &&

6075

{ ac_try='test -s conftest$ac_exeext'

6076

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6077

(eval $ac_try) 2>&5

6078

ac_status=$?

6079

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6080

(exit $ac_status); }; }; then

6081

am_cv_lib_iconv=yes

6082

am_cv_func_iconv=yes

6083

else

6084

echo "$as_me: failed program was:" >&5

6085

sed 's/^/| /' conftest.$ac_ext >&5

6086

6087

6088

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

6089

LIBS="$am_save_LIBS"

6090

6091

6092

6093

echo "$as_me:$LINENO: result: $am_cv_func_iconv" >&5

6094

echo "${ECHO_T}$am_cv_func_iconv" >&6

6095

if test "$am_cv_func_iconv" = yes; then

6096

6097

cat >>confdefs.h <<\_ACEOF

6098

#define HAVE_ICONV 1

6099

_ACEOF

6100

6101

6102

if test "$am_cv_lib_iconv" = yes; then

6103

echo "$as_me:$LINENO: checking how to link with libiconv" >&5

6104

echo $ECHO_N "checking how to link with libiconv... $ECHO_C" >&6

6105

echo "$as_me:$LINENO: result: $LIBICONV" >&5

6106

echo "${ECHO_T}$LIBICONV" >&6

6107

else

6108

CPPFLAGS="$am_save_CPPFLAGS"

6109

LIBICONV=

6110

LTLIBICONV=

6111

6112

6113

6114

6115

6116

6117

6118

use_additional=yes

6119

6120

acl_save_prefix="$prefix"

6121

prefix="$acl_final_prefix"

6122

acl_save_exec_prefix="$exec_prefix"

6123

exec_prefix="$acl_final_exec_prefix"

6124

6125

eval additional_includedir=\"$includedir\"

6126

eval additional_libdir=\"$libdir\"

6127

6128

exec_prefix="$acl_save_exec_prefix"

6129

prefix="$acl_save_prefix"

6130

6131

6132

# Check whether --with-libintl-prefix or --without-libintl-prefix was given.

6133

if test "${with_libintl_prefix+set}" = set; then

6134

withval="$with_libintl_prefix"

6135

6136

if test "X$withval" = "Xno"; then

6137

use_additional=no

6138

else

6139

if test "X$withval" = "X"; then

6140

6141

acl_save_prefix="$prefix"

6142

prefix="$acl_final_prefix"

6143

acl_save_exec_prefix="$exec_prefix"

6144

exec_prefix="$acl_final_exec_prefix"

6145

6146

eval additional_includedir=\"$includedir\"

6147

eval additional_libdir=\"$libdir\"

6148

6149

exec_prefix="$acl_save_exec_prefix"

6150

prefix="$acl_save_prefix"

6151

6152

else

6153

additional_includedir="$withval/include"

6154

additional_libdir="$withval/lib"

6155

6156

6157

6158

fi;

6159

LIBINTL=

6160

LTLIBINTL=

6161

INCINTL=

6162

rpathdirs=

6163

ltrpathdirs=

6164

names_already_handled=

6165

names_next_round='intl '

6166

while test -n "$names_next_round"; do

6167

names_this_round="$names_next_round"

6168

names_next_round=

6169

for name in $names_this_round; do

6170

already_handled=

6171

for n in $names_already_handled; do

6172

if test "$n" = "$name"; then

6173

already_handled=yes

6174

break

6175

6176

done

6177

if test -z "$already_handled"; then

6178

names_already_handled="$names_already_handled $name"

6179

uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`

6180

eval value=\"\$HAVE_LIB$uppername\"

6181

if test -n "$value"; then

6182

if test "$value" = yes; then

6183

eval value=\"\$LIB$uppername\"

6184

test -z "$value" || LIBINTL="${LIBINTL}${LIBINTL:+ }$value"

6185

eval value=\"\$LTLIB$uppername\"

6186

test -z "$value" || LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }$value"

6187

else

6188

6189

6190

else

6191

found_dir=

6192

found_la=

6193

found_so=

6194

found_a=

6195

if test $use_additional = yes; then

6196

if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then

6197

found_dir="$additional_libdir"

6198

found_so="$additional_libdir/lib$name.$shlibext"

6199

if test -f "$additional_libdir/lib$name.la"; then

6200

found_la="$additional_libdir/lib$name.la"

6201

6202

else

6203

if test -f "$additional_libdir/lib$name.$libext"; then

6204

found_dir="$additional_libdir"

6205

found_a="$additional_libdir/lib$name.$libext"

6206

if test -f "$additional_libdir/lib$name.la"; then

6207

found_la="$additional_libdir/lib$name.la"

6208

6209

6210

6211

6212

if test "X$found_dir" = "X"; then

6213

for x in $LDFLAGS $LTLIBINTL; do

6214

6215

acl_save_prefix="$prefix"

6216

prefix="$acl_final_prefix"

6217

acl_save_exec_prefix="$exec_prefix"

6218

exec_prefix="$acl_final_exec_prefix"

6219

eval x=\"$x\"

6220

exec_prefix="$acl_save_exec_prefix"

6221

prefix="$acl_save_prefix"

6222

6223

case "$x" in

6224

-L*)

6225

dir=`echo "X$x" | sed -e 's/^X-L//'`

6226

if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then

6227

found_dir="$dir"

6228

found_so="$dir/lib$name.$shlibext"

6229

if test -f "$dir/lib$name.la"; then

6230

found_la="$dir/lib$name.la"

6231

6232

else

6233

if test -f "$dir/lib$name.$libext"; then

6234

found_dir="$dir"

6235

found_a="$dir/lib$name.$libext"

6236

if test -f "$dir/lib$name.la"; then

6237

found_la="$dir/lib$name.la"

6238

6239

6240

6241

;;

6242

esac

6243

if test "X$found_dir" != "X"; then

6244

break

6245

6246

done

6247

6248

if test "X$found_dir" != "X"; then

6249

LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-L$found_dir -l$name"

6250

if test "X$found_so" != "X"; then

6251

if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then

6252

LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"

6253

else

6254

haveit=

6255

for x in $ltrpathdirs; do

6256

if test "X$x" = "X$found_dir"; then

6257

haveit=yes

6258

break

6259

6260

done

6261

if test -z "$haveit"; then

6262

ltrpathdirs="$ltrpathdirs $found_dir"

6263

6264

if test "$hardcode_direct" = yes; then

6265

LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"

6266

else

6267

if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then

6268

LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"

6269

haveit=

6270

for x in $rpathdirs; do

6271

if test "X$x" = "X$found_dir"; then

6272

haveit=yes

6273

break

6274

6275

done

6276

if test -z "$haveit"; then

6277

rpathdirs="$rpathdirs $found_dir"

6278

6279

else

6280

haveit=

6281

for x in $LDFLAGS $LIBINTL; do

6282

6283

acl_save_prefix="$prefix"

6284

prefix="$acl_final_prefix"

6285

acl_save_exec_prefix="$exec_prefix"

6286

exec_prefix="$acl_final_exec_prefix"

6287

eval x=\"$x\"

6288

exec_prefix="$acl_save_exec_prefix"

6289

prefix="$acl_save_prefix"

6290

6291

if test "X$x" = "X-L$found_dir"; then

6292

haveit=yes

6293

break

6294

6295

done

6296

if test -z "$haveit"; then

6297

LIBINTL="${LIBINTL}${LIBINTL:+ }-L$found_dir"

6298

6299

if test "$hardcode_minus_L" != no; then

6300

LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"

6301

else

6302

LIBINTL="${LIBINTL}${LIBINTL:+ }-l$name"

6303

6304

6305

6306

6307

else

6308

if test "X$found_a" != "X"; then

6309

LIBINTL="${LIBINTL}${LIBINTL:+ }$found_a"

6310

else

6311

LIBINTL="${LIBINTL}${LIBINTL:+ }-L$found_dir -l$name"

6312

6313

6314

additional_includedir=

6315

case "$found_dir" in

6316

*/lib | */lib/)

6317

basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'`

6318

additional_includedir="$basedir/include"

6319

;;

6320

esac

6321

if test "X$additional_includedir" != "X"; then

6322

if test "X$additional_includedir" != "X/usr/include"; then

6323

haveit=

6324

if test "X$additional_includedir" = "X/usr/local/include"; then

6325

if test -n "$GCC"; then

6326

case $host_os in

6327

linux*) haveit=yes;;

6328

esac

6329

6330

6331

if test -z "$haveit"; then

6332

for x in $CPPFLAGS $INCINTL; do

6333

6334

acl_save_prefix="$prefix"

6335

prefix="$acl_final_prefix"

6336

acl_save_exec_prefix="$exec_prefix"

6337

exec_prefix="$acl_final_exec_prefix"

6338

eval x=\"$x\"

6339

exec_prefix="$acl_save_exec_prefix"

6340

prefix="$acl_save_prefix"

6341

6342

if test "X$x" = "X-I$additional_includedir"; then

6343

haveit=yes

6344

break

6345

6346

done

6347

if test -z "$haveit"; then

6348

if test -d "$additional_includedir"; then

6349

INCINTL="${INCINTL}${INCINTL:+ }-I$additional_includedir"

6350

6351

6352

6353

6354

6355

if test -n "$found_la"; then

6356

save_libdir="$libdir"

6357

case "$found_la" in

6358

*/* | *\\*) . "$found_la" ;;

6359

*) . "./$found_la" ;;

6360

esac

6361

libdir="$save_libdir"

6362

for dep in $dependency_libs; do

6363

case "$dep" in

6364

-L*)

6365

additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`

6366

if test "X$additional_libdir" != "X/usr/lib"; then

6367

haveit=

6368

if test "X$additional_libdir" = "X/usr/local/lib"; then

6369

if test -n "$GCC"; then

6370

case $host_os in

6371

linux*) haveit=yes;;

6372

esac

6373

6374

6375

if test -z "$haveit"; then

6376

haveit=

6377

for x in $LDFLAGS $LIBINTL; do

6378

6379

acl_save_prefix="$prefix"

6380

prefix="$acl_final_prefix"

6381

acl_save_exec_prefix="$exec_prefix"

6382

exec_prefix="$acl_final_exec_prefix"

6383

eval x=\"$x\"

6384

exec_prefix="$acl_save_exec_prefix"

6385

prefix="$acl_save_prefix"

6386

6387

if test "X$x" = "X-L$additional_libdir"; then

6388

haveit=yes

6389

break

6390

6391

done

6392

if test -z "$haveit"; then

6393

if test -d "$additional_libdir"; then

6394

LIBINTL="${LIBINTL}${LIBINTL:+ }-L$additional_libdir"

6395

6396

6397

haveit=

6398

for x in $LDFLAGS $LTLIBINTL; do

6399

6400

acl_save_prefix="$prefix"

6401

prefix="$acl_final_prefix"

6402

acl_save_exec_prefix="$exec_prefix"

6403

exec_prefix="$acl_final_exec_prefix"

6404

eval x=\"$x\"

6405

exec_prefix="$acl_save_exec_prefix"

6406

prefix="$acl_save_prefix"

6407

6408

if test "X$x" = "X-L$additional_libdir"; then

6409

haveit=yes

6410

break

6411

6412

done

6413

if test -z "$haveit"; then

6414

if test -d "$additional_libdir"; then

6415

LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-L$additional_libdir"

6416

6417

6418

6419

6420

;;

6421

-R*)

6422

dir=`echo "X$dep" | sed -e 's/^X-R//'`

6423

if test "$enable_rpath" != no; then

6424

haveit=

6425

for x in $rpathdirs; do

6426

if test "X$x" = "X$dir"; then

6427

haveit=yes

6428

break

6429

6430

done

6431

if test -z "$haveit"; then

6432

rpathdirs="$rpathdirs $dir"

6433

6434

haveit=

6435

for x in $ltrpathdirs; do

6436

if test "X$x" = "X$dir"; then

6437

haveit=yes

6438

break

6439

6440

done

6441

if test -z "$haveit"; then

6442

ltrpathdirs="$ltrpathdirs $dir"

6443

6444

6445

;;

6446

-l*)

6447

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`

6448

;;

6449

*.la)

6450

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`

6451

;;

6452

6453

LIBINTL="${LIBINTL}${LIBINTL:+ }$dep"

6454

LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }$dep"

6455

;;

6456

esac

6457

done

6458

6459

else

6460

LIBINTL="${LIBINTL}${LIBINTL:+ }-l$name"

6461

LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-l$name"

6462

6463

6464

6465

done

6466

done

6467

if test "X$rpathdirs" != "X"; then

6468

if test -n "$hardcode_libdir_separator"; then

6469

alldirs=

6470

for found_dir in $rpathdirs; do

6471

alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir"

6472

done

6473

acl_save_libdir="$libdir"

6474

libdir="$alldirs"

6475

eval flag=\"$hardcode_libdir_flag_spec\"

6476

libdir="$acl_save_libdir"

6477

LIBINTL="${LIBINTL}${LIBINTL:+ }$flag"

6478

else

6479

for found_dir in $rpathdirs; do

6480

acl_save_libdir="$libdir"

6481

libdir="$found_dir"

6482

eval flag=\"$hardcode_libdir_flag_spec\"

6483

libdir="$acl_save_libdir"

6484

LIBINTL="${LIBINTL}${LIBINTL:+ }$flag"

6485

done

6486

6487

6488

if test "X$ltrpathdirs" != "X"; then

6489

for found_dir in $ltrpathdirs; do

6490

LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-R$found_dir"

6491

done

6492

6493

6494

echo "$as_me:$LINENO: checking for GNU gettext in libintl" >&5

6495

echo $ECHO_N "checking for GNU gettext in libintl... $ECHO_C" >&6

6496

if test "${gt_cv_func_gnugettext1_libintl+set}" = set; then

6497

echo $ECHO_N "(cached) $ECHO_C" >&6

6498

else

6499

gt_save_CPPFLAGS="$CPPFLAGS"

6500

CPPFLAGS="$CPPFLAGS $INCINTL"

6501

gt_save_LIBS="$LIBS"

6502

LIBS="$LIBS $LIBINTL"

6503

cat >conftest.$ac_ext <<_ACEOF

6504

#line $LINENO "configure"

6505

/* confdefs.h. */

6506

_ACEOF

6507

cat confdefs.h >>conftest.$ac_ext

6508

cat >>conftest.$ac_ext <<_ACEOF

6509

/* end confdefs.h. */

6510

#include <libintl.h>

6511

extern int _nl_msg_cat_cntr;

6512

extern

6513

#ifdef __cplusplus

6514

"C"

6515

#endif

6516

const char *_nl_expand_alias ();

6517

int

6518

main ()

6519

{

6520

bindtextdomain ("", "");

6521

return (int) gettext ("") + _nl_msg_cat_cntr + *_nl_expand_alias (0)

6522

;

6523

return 0;

6524

}

6525

_ACEOF

6526

rm -f conftest.$ac_objext conftest$ac_exeext

6527

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6528

(eval $ac_link) 2>&5

6529

ac_status=$?

6530

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6531

(exit $ac_status); } &&

6532

{ ac_try='test -s conftest$ac_exeext'

6533

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6534

(eval $ac_try) 2>&5

6535

ac_status=$?

6536

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6537

(exit $ac_status); }; }; then

6538

gt_cv_func_gnugettext1_libintl=yes

6539

else

6540

echo "$as_me: failed program was:" >&5

6541

sed 's/^/| /' conftest.$ac_ext >&5

6542

6543

gt_cv_func_gnugettext1_libintl=no

6544

6545

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

6546

if test "$gt_cv_func_gnugettext1_libintl" != yes && test -n "$LIBICONV"; then

6547

LIBS="$LIBS $LIBICONV"

6548

cat >conftest.$ac_ext <<_ACEOF

6549

#line $LINENO "configure"

6550

/* confdefs.h. */

6551

_ACEOF

6552

cat confdefs.h >>conftest.$ac_ext

6553

cat >>conftest.$ac_ext <<_ACEOF

6554

/* end confdefs.h. */

6555

#include <libintl.h>

6556

extern int _nl_msg_cat_cntr;

6557

extern

6558

#ifdef __cplusplus

6559

"C"

6560

#endif

6561

const char *_nl_expand_alias ();

6562

int

6563

main ()

6564

{

6565

bindtextdomain ("", "");

6566

return (int) gettext ("") + _nl_msg_cat_cntr + *_nl_expand_alias (0)

6567

;

6568

return 0;

6569

}

6570

_ACEOF

6571

rm -f conftest.$ac_objext conftest$ac_exeext

6572

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6573

(eval $ac_link) 2>&5

6574

ac_status=$?

6575

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6576

(exit $ac_status); } &&

6577

{ ac_try='test -s conftest$ac_exeext'

6578

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6579

(eval $ac_try) 2>&5

6580

ac_status=$?

6581

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6582

(exit $ac_status); }; }; then

6583

LIBINTL="$LIBINTL $LIBICONV"

6584

LTLIBINTL="$LTLIBINTL $LTLIBICONV"

6585

gt_cv_func_gnugettext1_libintl=yes

6586

6587

else

6588

echo "$as_me: failed program was:" >&5

6589

sed 's/^/| /' conftest.$ac_ext >&5

6590

6591

6592

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

6593

6594

CPPFLAGS="$gt_save_CPPFLAGS"

6595

LIBS="$gt_save_LIBS"

6596

6597

echo "$as_me:$LINENO: result: $gt_cv_func_gnugettext1_libintl" >&5

6598

echo "${ECHO_T}$gt_cv_func_gnugettext1_libintl" >&6

6599

6600

6601

if test "$gt_cv_func_gnugettext1_libc" = "yes" \

6602

|| { test "$gt_cv_func_gnugettext1_libintl" = "yes" \

6603

&& test "$PACKAGE" != gettext; }; then

6604

gt_use_preinstalled_gnugettext=yes

6605

else

6606

LIBINTL=

6607

LTLIBINTL=

6608

INCINTL=

6609

6610

6611

6612

6613

if test "$gt_use_preinstalled_gnugettext" = "yes" \

6614

|| test "$nls_cv_use_gnu_gettext" = "yes"; then

6615

6616

cat >>confdefs.h <<\_ACEOF

6617

#define ENABLE_NLS 1

6618

_ACEOF

6619

6620

else

6621

USE_NLS=no

6622

6623

6624

6625

if test "$USE_NLS" = "yes"; then

6626

6627

if test "$gt_use_preinstalled_gnugettext" = "yes"; then

6628

if test "$gt_cv_func_gnugettext1_libintl" = "yes"; then

6629

echo "$as_me:$LINENO: checking how to link with libintl" >&5

6630

echo $ECHO_N "checking how to link with libintl... $ECHO_C" >&6

6631

echo "$as_me:$LINENO: result: $LIBINTL" >&5

6632

echo "${ECHO_T}$LIBINTL" >&6

6633

6634

for element in $INCINTL; do

6635

haveit=

6636

for x in $CPPFLAGS; do

6637

6638

acl_save_prefix="$prefix"

6639

prefix="$acl_final_prefix"

6640

acl_save_exec_prefix="$exec_prefix"

6641

exec_prefix="$acl_final_exec_prefix"

6642

eval x=\"$x\"

6643

exec_prefix="$acl_save_exec_prefix"

6644

prefix="$acl_save_prefix"

6645

6646

if test "X$x" = "X$element"; then

6647

haveit=yes

6648

break

6649

6650

done

6651

if test -z "$haveit"; then

6652

CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"

6653

6654

done

6655

6656

6657

6658

6659

cat >>confdefs.h <<\_ACEOF

6660

#define HAVE_GETTEXT 1

6661

_ACEOF

6662

6663

6664

cat >>confdefs.h <<\_ACEOF

6665

#define HAVE_DCGETTEXT 1

6666

_ACEOF

6667

6668

6669

6670

POSUB=po

6671

6672

6673

6674

6675

INTLLIBS="$LIBINTL"

6676

6677

6678

6679

6680

6681

6682

6683

6684

echo "$as_me:$LINENO: checking for inttypes.h" >&5

6685

echo $ECHO_N "checking for inttypes.h... $ECHO_C" >&6

6686

if test "${jm_ac_cv_header_inttypes_h+set}" = set; then

6687

echo $ECHO_N "(cached) $ECHO_C" >&6

6688

else

6689

cat >conftest.$ac_ext <<_ACEOF

6690

#line $LINENO "configure"

6691

/* confdefs.h. */

6692

_ACEOF

6693

cat confdefs.h >>conftest.$ac_ext

6694

cat >>conftest.$ac_ext <<_ACEOF

6695

/* end confdefs.h. */

6696

#include <sys/types.h>

6697

#include <inttypes.h>

6698

int

6699

main ()

6700

{

6701

uintmax_t i = (uintmax_t) -1;

6702

;

6703

return 0;

6704

}

6705

_ACEOF

6706

rm -f conftest.$ac_objext

6707

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6708

(eval $ac_compile) 2>&5

6709

ac_status=$?

6710

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6711

(exit $ac_status); } &&

6712

{ ac_try='test -s conftest.$ac_objext'

6713

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6714

(eval $ac_try) 2>&5

6715

ac_status=$?

6716

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6717

(exit $ac_status); }; }; then

6718

jm_ac_cv_header_inttypes_h=yes

6719

else

6720

echo "$as_me: failed program was:" >&5

6721

sed 's/^/| /' conftest.$ac_ext >&5

6722

6723

jm_ac_cv_header_inttypes_h=no

6724

6725

rm -f conftest.$ac_objext conftest.$ac_ext

6726

6727

echo "$as_me:$LINENO: result: $jm_ac_cv_header_inttypes_h" >&5

6728

echo "${ECHO_T}$jm_ac_cv_header_inttypes_h" >&6

6729

if test $jm_ac_cv_header_inttypes_h = yes; then

6730

6731

cat >>confdefs.h <<_ACEOF

6732

#define HAVE_INTTYPES_H_WITH_UINTMAX 1

6733

_ACEOF

6734

6735

6736

6737

6738

echo "$as_me:$LINENO: checking for stdint.h" >&5

6739

echo $ECHO_N "checking for stdint.h... $ECHO_C" >&6

6740

if test "${jm_ac_cv_header_stdint_h+set}" = set; then

6741

echo $ECHO_N "(cached) $ECHO_C" >&6

6742

else

6743

cat >conftest.$ac_ext <<_ACEOF

6744

#line $LINENO "configure"

6745

/* confdefs.h. */

6746

_ACEOF

6747

cat confdefs.h >>conftest.$ac_ext

6748

cat >>conftest.$ac_ext <<_ACEOF

6749

/* end confdefs.h. */

6750

#include <sys/types.h>

6751

#include <stdint.h>

6752

int

6753

main ()

6754

{

6755

uintmax_t i = (uintmax_t) -1;

6756

;

6757

return 0;

6758

}

6759

_ACEOF

6760

rm -f conftest.$ac_objext

6761

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6762

(eval $ac_compile) 2>&5

6763

ac_status=$?

6764

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6765

(exit $ac_status); } &&

6766

{ ac_try='test -s conftest.$ac_objext'

6767

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6768

(eval $ac_try) 2>&5

6769

ac_status=$?

6770

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6771

(exit $ac_status); }; }; then

6772

jm_ac_cv_header_stdint_h=yes

6773

else

6774

echo "$as_me: failed program was:" >&5

6775

sed 's/^/| /' conftest.$ac_ext >&5

6776

6777

jm_ac_cv_header_stdint_h=no

6778

6779

rm -f conftest.$ac_objext conftest.$ac_ext

6780

6781

echo "$as_me:$LINENO: result: $jm_ac_cv_header_stdint_h" >&5

6782

echo "${ECHO_T}$jm_ac_cv_header_stdint_h" >&6

6783

if test $jm_ac_cv_header_stdint_h = yes; then

6784

6785

cat >>confdefs.h <<_ACEOF

6786

#define HAVE_STDINT_H_WITH_UINTMAX 1

6787

_ACEOF

6788

6789

6790

6791

6792

echo "$as_me:$LINENO: checking for unsigned long long" >&5

6793

echo $ECHO_N "checking for unsigned long long... $ECHO_C" >&6

6794

if test "${ac_cv_type_unsigned_long_long+set}" = set; then

6795

echo $ECHO_N "(cached) $ECHO_C" >&6

6796

else

6797

cat >conftest.$ac_ext <<_ACEOF

6798

#line $LINENO "configure"

6799

/* confdefs.h. */

6800

_ACEOF

6801

cat confdefs.h >>conftest.$ac_ext

6802

cat >>conftest.$ac_ext <<_ACEOF

6803

/* end confdefs.h. */

6804

unsigned long long ull = 1ULL; int i = 63;

6805

int

6806

main ()

6807

{

6808

unsigned long long ullmax = (unsigned long long) -1;

6809

return ull << i | ull >> i | ullmax / ull | ullmax % ull;

6810

;

6811

return 0;

6812

}

6813

_ACEOF

6814

rm -f conftest.$ac_objext conftest$ac_exeext

6815

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6816

(eval $ac_link) 2>&5

6817

ac_status=$?

6818

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6819

(exit $ac_status); } &&

6820

{ ac_try='test -s conftest$ac_exeext'

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_cv_type_unsigned_long_long=yes

6827

else

6828

echo "$as_me: failed program was:" >&5

6829

sed 's/^/| /' conftest.$ac_ext >&5

6830

6831

ac_cv_type_unsigned_long_long=no

6832

6833

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

6834

6835

echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long" >&5

6836

echo "${ECHO_T}$ac_cv_type_unsigned_long_long" >&6

6837

if test $ac_cv_type_unsigned_long_long = yes; then

6838

6839

cat >>confdefs.h <<\_ACEOF

6840

#define HAVE_UNSIGNED_LONG_LONG 1

6841

_ACEOF

6842

6843

6844

6845

6846

6847

6848

if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then

6849

6850

test $ac_cv_type_unsigned_long_long = yes \

6851

&& ac_type='unsigned long long' \

6852

|| ac_type='unsigned long'

6853

6854

cat >>confdefs.h <<_ACEOF

6855

#define uintmax_t $ac_type

6856

_ACEOF

6857

6858

else

6859

6860

cat >>confdefs.h <<\_ACEOF

6861

#define HAVE_UINTMAX_T 1

6862

_ACEOF

6863

6864

6865

6866

6867

6868

6869

6870

6871

6872

6873

echo "$as_me:$LINENO: checking whether getenv is declared" >&5

6874

echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6

6875

if test "${ac_cv_have_decl_getenv+set}" = set; then

6876

echo $ECHO_N "(cached) $ECHO_C" >&6

6877

else

6878

cat >conftest.$ac_ext <<_ACEOF

6879

#line $LINENO "configure"

6880

/* confdefs.h. */

6881

_ACEOF

6882

cat confdefs.h >>conftest.$ac_ext

6883

cat >>conftest.$ac_ext <<_ACEOF

6884

/* end confdefs.h. */

6885

$ac_includes_default

6886

int

6887

main ()

6888

{

6889

#ifndef getenv

6890

char *p = (char *) getenv;

6891

#endif

6892

6893

;

6894

return 0;

6895

}

6896

_ACEOF

6897

rm -f conftest.$ac_objext

6898

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6899

(eval $ac_compile) 2>&5

6900

ac_status=$?

6901

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6902

(exit $ac_status); } &&

6903

{ ac_try='test -s conftest.$ac_objext'

6904

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6905

(eval $ac_try) 2>&5

6906

ac_status=$?

6907

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6908

(exit $ac_status); }; }; then

6909

ac_cv_have_decl_getenv=yes

6910

else

6911

echo "$as_me: failed program was:" >&5

6912

sed 's/^/| /' conftest.$ac_ext >&5

6913

6914

ac_cv_have_decl_getenv=no

6915

6916

rm -f conftest.$ac_objext conftest.$ac_ext

6917

6918

echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5

6919

echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6

6920

if test $ac_cv_have_decl_getenv = yes; then

6921

6922

cat >>confdefs.h <<_ACEOF

6923

#define HAVE_DECL_GETENV 1

6924

_ACEOF

6925

6926

6927

else

6928

cat >>confdefs.h <<_ACEOF

6929

#define HAVE_DECL_GETENV 0

6930

_ACEOF

6931

6932

6933

6934

6935

6936

6937

6938

6939

6940

6941

6942

6943

6944

6945

6946

6947

6948

6949

6950

6951

6952

6953

6954

6955

6956

6957

6958

6959

6960

6961

6962

6963

6964

6965

6966

6967

6968

6969

6970

6971

6972

6973

6974

6975

6976

echo "$as_me:$LINENO: checking whether lstat dereferences a symlink specified with a trailing slash" >&5

6977

echo $ECHO_N "checking whether lstat dereferences a symlink specified with a trailing slash... $ECHO_C" >&6

6978

if test "${ac_cv_func_lstat_dereferences_slashed_symlink+set}" = set; then

6979

echo $ECHO_N "(cached) $ECHO_C" >&6

6980

else

6981

rm -f conftest.sym conftest.file

6982

echo >conftest.file

6983

if test "$as_ln_s" = "ln -s" && ln -s conftest.file conftest.sym; then

6984

if test "$cross_compiling" = yes; then

6985

ac_cv_func_lstat_dereferences_slashed_symlink=no

6986

else

6987

cat >conftest.$ac_ext <<_ACEOF

6988

#line $LINENO "configure"

6989

/* confdefs.h. */

6990

_ACEOF

6991

cat confdefs.h >>conftest.$ac_ext

6992

cat >>conftest.$ac_ext <<_ACEOF

6993

/* end confdefs.h. */

6994

$ac_includes_default

6995

int

6996

main ()

6997

{

6998

struct stat sbuf;

6999

/* Linux will dereference the symlink and fail.

7000

That is better in the sense that it means we will not

7001

have to compile and use the lstat wrapper. */

7002

exit (lstat ("conftest.sym/", &sbuf) ? 0 : 1);

7003

;

7004

return 0;

7005

}

7006

_ACEOF

7007

rm -f conftest$ac_exeext

7008

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7009

(eval $ac_link) 2>&5

7010

ac_status=$?

7011

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7012

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

7013

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7014

(eval $ac_try) 2>&5

7015

ac_status=$?

7016

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7017

(exit $ac_status); }; }; then

7018

ac_cv_func_lstat_dereferences_slashed_symlink=yes

7019

else

7020

echo "$as_me: program exited with status $ac_status" >&5

7021

echo "$as_me: failed program was:" >&5

7022

sed 's/^/| /' conftest.$ac_ext >&5

7023

7024

( exit $ac_status )

7025

ac_cv_func_lstat_dereferences_slashed_symlink=no

7026

7027

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

7028

7029

else

7030

# If the `ln -s' command failed, then we probably don't even

7031

# have an lstat function.

7032

ac_cv_func_lstat_dereferences_slashed_symlink=no

7033

7034

rm -f conftest.sym conftest.file

7035

7036

7037

echo "$as_me:$LINENO: result: $ac_cv_func_lstat_dereferences_slashed_symlink" >&5

7038

echo "${ECHO_T}$ac_cv_func_lstat_dereferences_slashed_symlink" >&6

7039

7040

test $ac_cv_func_lstat_dereferences_slashed_symlink = yes &&

7041

7042

cat >>confdefs.h <<_ACEOF

7043

#define LSTAT_FOLLOWS_SLASHED_SYMLINK 1

7044

_ACEOF

7045

7046

7047

if test $ac_cv_func_lstat_dereferences_slashed_symlink = no; then

7048

LIBOBJS="$LIBOBJS lstat.$ac_objext"

7049

7050

7051

7052

echo "$as_me:$LINENO: checking whether free is declared" >&5

7053

echo $ECHO_N "checking whether free is declared... $ECHO_C" >&6

7054

if test "${ac_cv_have_decl_free+set}" = set; then

7055

echo $ECHO_N "(cached) $ECHO_C" >&6

7056

else

7057

cat >conftest.$ac_ext <<_ACEOF

7058

#line $LINENO "configure"

7059

/* confdefs.h. */

7060

_ACEOF

7061

cat confdefs.h >>conftest.$ac_ext

7062

cat >>conftest.$ac_ext <<_ACEOF

7063

/* end confdefs.h. */

7064

$ac_includes_default

7065

int

7066

main ()

7067

{

7068

#ifndef free

7069

char *p = (char *) free;

7070

#endif

7071

7072

;

7073

return 0;

7074

}

7075

_ACEOF

7076

rm -f conftest.$ac_objext

7077

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7078

(eval $ac_compile) 2>&5

7079

ac_status=$?

7080

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7081

(exit $ac_status); } &&

7082

{ ac_try='test -s conftest.$ac_objext'

7083

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7084

(eval $ac_try) 2>&5

7085

ac_status=$?

7086

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7087

(exit $ac_status); }; }; then

7088

ac_cv_have_decl_free=yes

7089

else

7090

echo "$as_me: failed program was:" >&5

7091

sed 's/^/| /' conftest.$ac_ext >&5

7092

7093

ac_cv_have_decl_free=no

7094

7095

rm -f conftest.$ac_objext conftest.$ac_ext

7096

7097

echo "$as_me:$LINENO: result: $ac_cv_have_decl_free" >&5

7098

echo "${ECHO_T}$ac_cv_have_decl_free" >&6

7099

if test $ac_cv_have_decl_free = yes; then

7100

7101

cat >>confdefs.h <<_ACEOF

7102

#define HAVE_DECL_FREE 1

7103

_ACEOF

7104

7105

7106

else

7107

cat >>confdefs.h <<_ACEOF

7108

#define HAVE_DECL_FREE 0

7109

_ACEOF

7110

7111

7112

7113

7114

7115

7116

7117

echo "$as_me:$LINENO: checking whether lstat accepts an empty string" >&5

7118

echo $ECHO_N "checking whether lstat accepts an empty string... $ECHO_C" >&6

7119

if test "${ac_cv_func_lstat_empty_string_bug+set}" = set; then

7120

echo $ECHO_N "(cached) $ECHO_C" >&6

7121

else

7122

if test "$cross_compiling" = yes; then

7123

ac_cv_func_lstat_empty_string_bug=yes

7124

else

7125

cat >conftest.$ac_ext <<_ACEOF

7126

#line $LINENO "configure"

7127

/* confdefs.h. */

7128

_ACEOF

7129

cat confdefs.h >>conftest.$ac_ext

7130

cat >>conftest.$ac_ext <<_ACEOF

7131

/* end confdefs.h. */

7132

$ac_includes_default

7133

int

7134

main ()

7135

{

7136

struct stat sbuf;

7137

exit (lstat ("", &sbuf) ? 1 : 0);

7138

;

7139

return 0;

7140

}

7141

_ACEOF

7142

rm -f conftest$ac_exeext

7143

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7144

(eval $ac_link) 2>&5

7145

ac_status=$?

7146

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7147

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

7148

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7149

(eval $ac_try) 2>&5

7150

ac_status=$?

7151

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7152

(exit $ac_status); }; }; then

7153

ac_cv_func_lstat_empty_string_bug=yes

7154

else

7155

echo "$as_me: program exited with status $ac_status" >&5

7156

echo "$as_me: failed program was:" >&5

7157

sed 's/^/| /' conftest.$ac_ext >&5

7158

7159

( exit $ac_status )

7160

ac_cv_func_lstat_empty_string_bug=no

7161

7162

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

7163

7164

7165

echo "$as_me:$LINENO: result: $ac_cv_func_lstat_empty_string_bug" >&5

7166

echo "${ECHO_T}$ac_cv_func_lstat_empty_string_bug" >&6

7167

if test $ac_cv_func_lstat_empty_string_bug = yes; then

7168

LIBOBJS="$LIBOBJS lstat.$ac_objext"

7169

7170

cat >>confdefs.h <<_ACEOF

7171

#define HAVE_LSTAT_EMPTY_STRING_BUG 1

7172

_ACEOF

7173

7174

7175

7176

if test $ac_cv_func_lstat_empty_string_bug = yes; then

7177

7178

7179

7180

7181

7182

7183

7184

7185

7186

7187

7188

7189

7190

7191

7192

7193

7194

7195

7196

7197

7198

for ac_header in stdlib.h

7199

7200

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

7201

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7202

echo "$as_me:$LINENO: checking for $ac_header" >&5

7203

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

7204

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7205

echo $ECHO_N "(cached) $ECHO_C" >&6

7206

7207

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

7208

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

7209

else

7210

# Is the header compilable?

7211

echo "$as_me:$LINENO: checking $ac_header usability" >&5

7212

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

7213

cat >conftest.$ac_ext <<_ACEOF

7214

#line $LINENO "configure"

7215

/* confdefs.h. */

7216

_ACEOF

7217

cat confdefs.h >>conftest.$ac_ext

7218

cat >>conftest.$ac_ext <<_ACEOF

7219

/* end confdefs.h. */

7220

$ac_includes_default

7221

#include <$ac_header>

7222

_ACEOF

7223

rm -f conftest.$ac_objext

7224

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7225

(eval $ac_compile) 2>&5

7226

ac_status=$?

7227

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7228

(exit $ac_status); } &&

7229

{ ac_try='test -s conftest.$ac_objext'

7230

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7231

(eval $ac_try) 2>&5

7232

ac_status=$?

7233

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7234

(exit $ac_status); }; }; then

7235

ac_header_compiler=yes

7236

else

7237

echo "$as_me: failed program was:" >&5

7238

sed 's/^/| /' conftest.$ac_ext >&5

7239

7240

ac_header_compiler=no

7241

7242

rm -f conftest.$ac_objext conftest.$ac_ext

7243

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

7244

echo "${ECHO_T}$ac_header_compiler" >&6

7245

7246

# Is the header present?

7247

echo "$as_me:$LINENO: checking $ac_header presence" >&5

7248

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

7249

cat >conftest.$ac_ext <<_ACEOF

7250

#line $LINENO "configure"

7251

/* confdefs.h. */

7252

_ACEOF

7253

cat confdefs.h >>conftest.$ac_ext

7254

cat >>conftest.$ac_ext <<_ACEOF

7255

/* end confdefs.h. */

7256

#include <$ac_header>

7257

_ACEOF

7258

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

7259

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

7260

ac_status=$?

7261

grep -v '^ *+' conftest.er1 >conftest.err

7262

rm -f conftest.er1

7263

cat conftest.err >&5

7264

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7265

(exit $ac_status); } >/dev/null; then

7266

if test -s conftest.err; then

7267

ac_cpp_err=$ac_c_preproc_warn_flag

7268

else

7269

ac_cpp_err=

7270

7271

else

7272

ac_cpp_err=yes

7273

7274

if test -z "$ac_cpp_err"; then

7275

ac_header_preproc=yes

7276

else

7277

echo "$as_me: failed program was:" >&5

7278

sed 's/^/| /' conftest.$ac_ext >&5

7279

7280

ac_header_preproc=no

7281

7282

rm -f conftest.err conftest.$ac_ext

7283

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

7284

echo "${ECHO_T}$ac_header_preproc" >&6

7285

7286

# So? What about this header?

7287

case $ac_header_compiler:$ac_header_preproc in

7288

yes:no )

7289

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

7290

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

7291

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

7292

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

7293

(

7294

cat <<\_ASBOX

7295

## ------------------------------------ ##

7296

## Report this to bug-autoconf@gnu.org. ##

7297

## ------------------------------------ ##

7298

_ASBOX

7299

) |

7300

sed "s/^/$as_me: WARNING: /" >&2

7301

;;

7302

no:yes )

7303

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

7304

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

7305

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

7306

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

7307

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

7308

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

7309

(

7310

cat <<\_ASBOX

7311

## ------------------------------------ ##

7312

## Report this to bug-autoconf@gnu.org. ##

7313

## ------------------------------------ ##

7314

_ASBOX

7315

) |

7316

sed "s/^/$as_me: WARNING: /" >&2

7317

;;

7318

esac

7319

echo "$as_me:$LINENO: checking for $ac_header" >&5

7320

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

7321

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7322

echo $ECHO_N "(cached) $ECHO_C" >&6

7323

else

7324

eval "$as_ac_Header=$ac_header_preproc"

7325

7326

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

7327

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

7328

7329

7330

if test `eval echo '${'$as_ac_Header'}'` = yes; then

7331

cat >>confdefs.h <<_ACEOF

7332

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

7333

_ACEOF

7334

7335

7336

7337

done

7338

7339

echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5

7340

echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6

7341

if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then

7342

echo $ECHO_N "(cached) $ECHO_C" >&6

7343

else

7344

if test "$cross_compiling" = yes; then

7345

ac_cv_func_malloc_0_nonnull=no

7346

else

7347

cat >conftest.$ac_ext <<_ACEOF

7348

#line $LINENO "configure"

7349

/* confdefs.h. */

7350

_ACEOF

7351

cat confdefs.h >>conftest.$ac_ext

7352

cat >>conftest.$ac_ext <<_ACEOF

7353

/* end confdefs.h. */

7354

#if STDC_HEADERS || HAVE_STDLIB_H

7355

# include <stdlib.h>

7356

#else

7357

char *malloc ();

7358

#endif

7359

7360

int

7361

main ()

7362

{

7363

exit (malloc (0) ? 0 : 1);

7364

;

7365

return 0;

7366

}

7367

_ACEOF

7368

rm -f conftest$ac_exeext

7369

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7370

(eval $ac_link) 2>&5

7371

ac_status=$?

7372

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7373

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

7374

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7375

(eval $ac_try) 2>&5

7376

ac_status=$?

7377

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7378

(exit $ac_status); }; }; then

7379

ac_cv_func_malloc_0_nonnull=yes

7380

else

7381

echo "$as_me: program exited with status $ac_status" >&5

7382

echo "$as_me: failed program was:" >&5

7383

sed 's/^/| /' conftest.$ac_ext >&5

7384

7385

( exit $ac_status )

7386

ac_cv_func_malloc_0_nonnull=no

7387

7388

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

7389

7390

7391

echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5

7392

echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6

7393

if test $ac_cv_func_malloc_0_nonnull = yes; then

7394

7395

cat >>confdefs.h <<\_ACEOF

7396

#define HAVE_MALLOC 1

7397

_ACEOF

7398

7399

else

7400

cat >>confdefs.h <<\_ACEOF

7401

#define HAVE_MALLOC 0

7402

_ACEOF

7403

7404

LIBOBJS="$LIBOBJS malloc.$ac_objext"

7405

7406

cat >>confdefs.h <<\_ACEOF

7407

#define malloc rpl_malloc

7408

_ACEOF

7409

7410

7411

7412

7413

7414

7415

7416

if test X"$ac_cv_func_malloc_0_nonnull" = Xno || test X"$ac_cv_func_malloc_works" = Xno; then

7417

7418

7419

7420

7421

7422

7423

echo "$as_me:$LINENO: checking for working memcmp" >&5

7424

echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6

7425

if test "${ac_cv_func_memcmp_working+set}" = set; then

7426

echo $ECHO_N "(cached) $ECHO_C" >&6

7427

else

7428

if test "$cross_compiling" = yes; then

7429

ac_cv_func_memcmp_working=no

7430

else

7431

cat >conftest.$ac_ext <<_ACEOF

7432

#line $LINENO "configure"

7433

/* confdefs.h. */

7434

_ACEOF

7435

cat confdefs.h >>conftest.$ac_ext

7436

cat >>conftest.$ac_ext <<_ACEOF

7437

/* end confdefs.h. */

7438

7439

int

7440

main ()

7441

{

7442

7443

/* Some versions of memcmp are not 8-bit clean. */

7444

char c0 = 0x40, c1 = 0x80, c2 = 0x81;

7445

if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)

7446

exit (1);

7447

7448

/* The Next x86 OpenStep bug shows up only when comparing 16 bytes

7449

or more and with at least one buffer not starting on a 4-byte boundary.

7450

William Lewis provided this test program. */

7451

{

7452

char foo[21];

7453

char bar[21];

7454

int i;

7455

for (i = 0; i < 4; i++)

7456

{

7457

char *a = foo + i;

7458

char *b = bar + i;

7459

strcpy (a, "--------01111111");

7460

strcpy (b, "--------10000000");

7461

if (memcmp (a, b, 16) >= 0)

7462

exit (1);

7463

}

7464

exit (0);

7465

}

7466

7467

;

7468

return 0;

7469

}

7470

_ACEOF

7471

rm -f conftest$ac_exeext

7472

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7473

(eval $ac_link) 2>&5

7474

ac_status=$?

7475

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7476

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

7477

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7478

(eval $ac_try) 2>&5

7479

ac_status=$?

7480

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7481

(exit $ac_status); }; }; then

7482

ac_cv_func_memcmp_working=yes

7483

else

7484

echo "$as_me: program exited with status $ac_status" >&5

7485

echo "$as_me: failed program was:" >&5

7486

sed 's/^/| /' conftest.$ac_ext >&5

7487

7488

( exit $ac_status )

7489

ac_cv_func_memcmp_working=no

7490

7491

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

7492

7493

7494

echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5

7495

echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6

7496

test $ac_cv_func_memcmp_working = no && LIBOBJS="$LIBOBJS memcmp.$ac_objext"

7497

7498

7499

7500

if test $ac_cv_func_memcmp_working = no; then

7501

7502

cat >>confdefs.h <<\_ACEOF

7503

#define memcmp rpl_memcmp

7504

_ACEOF

7505

7506

7507

7508

7509

7510

7511

7512

7513

7514

7515

7516

7517

7518

7519

7520

for ac_func in memset

7521

7522

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

7523

echo "$as_me:$LINENO: checking for $ac_func" >&5

7524

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

7525

if eval "test \"\${$as_ac_var+set}\" = set"; then

7526

echo $ECHO_N "(cached) $ECHO_C" >&6

7527

else

7528

cat >conftest.$ac_ext <<_ACEOF

7529

#line $LINENO "configure"

7530

/* confdefs.h. */

7531

_ACEOF

7532

cat confdefs.h >>conftest.$ac_ext

7533

cat >>conftest.$ac_ext <<_ACEOF

7534

/* end confdefs.h. */

7535

/* System header to define __stub macros and hopefully few prototypes,

7536

which can conflict with char $ac_func (); below.

7537

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

7538

<limits.h> exists even on freestanding compilers. */

7539

#ifdef __STDC__

7540

# include <limits.h>

7541

#else

7542

# include <assert.h>

7543

#endif

7544

/* Override any gcc2 internal prototype to avoid an error. */

7545

#ifdef __cplusplus

7546

extern "C"

7547

{

7548

#endif

7549

/* We use char because int might match the return type of a gcc2

7550

builtin and then its argument prototype would still apply. */

7551

char $ac_func ();

7552

/* The GNU C library defines this for functions which it implements

7553

to always fail with ENOSYS. Some functions are actually named

7554

something starting with __ and the normal name is an alias. */

7555

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

7556

choke me

7557

#else

7558

char (*f) () = $ac_func;

7559

#endif

7560

#ifdef __cplusplus

7561

}

7562

#endif

7563

7564

int

7565

main ()

7566

{

7567

return f != $ac_func;

7568

;

7569

return 0;

7570

}

7571

_ACEOF

7572

rm -f conftest.$ac_objext conftest$ac_exeext

7573

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7574

(eval $ac_link) 2>&5

7575

ac_status=$?

7576

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7577

(exit $ac_status); } &&

7578

{ ac_try='test -s conftest$ac_exeext'

7579

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7580

(eval $ac_try) 2>&5

7581

ac_status=$?

7582

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7583

(exit $ac_status); }; }; then

7584

eval "$as_ac_var=yes"

7585

else

7586

echo "$as_me: failed program was:" >&5

7587

sed 's/^/| /' conftest.$ac_ext >&5

7588

7589

eval "$as_ac_var=no"

7590

7591

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

7592

7593

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

7594

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

7595

if test `eval echo '${'$as_ac_var'}'` = yes; then

7596

cat >>confdefs.h <<_ACEOF

7597

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

7598

_ACEOF

7599

7600

else

7601

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

7602

7603

done

7604

7605

7606

if test $ac_cv_func_memset = no; then

7607

7608

7609

7610

7611

7612

7613

echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5

7614

echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6

7615

if test "${ac_cv_header_time+set}" = set; then

7616

echo $ECHO_N "(cached) $ECHO_C" >&6

7617

else

7618

cat >conftest.$ac_ext <<_ACEOF

7619

#line $LINENO "configure"

7620

/* confdefs.h. */

7621

_ACEOF

7622

cat confdefs.h >>conftest.$ac_ext

7623

cat >>conftest.$ac_ext <<_ACEOF

7624

/* end confdefs.h. */

7625

#include <sys/types.h>

7626

#include <sys/time.h>

7627

#include <time.h>

7628

7629

int

7630

main ()

7631

{

7632

if ((struct tm *) 0)

7633

return 0;

7634

;

7635

return 0;

7636

}

7637

_ACEOF

7638

rm -f conftest.$ac_objext

7639

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7640

(eval $ac_compile) 2>&5

7641

ac_status=$?

7642

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7643

(exit $ac_status); } &&

7644

{ ac_try='test -s conftest.$ac_objext'

7645

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7646

(eval $ac_try) 2>&5

7647

ac_status=$?

7648

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7649

(exit $ac_status); }; }; then

7650

ac_cv_header_time=yes

7651

else

7652

echo "$as_me: failed program was:" >&5

7653

sed 's/^/| /' conftest.$ac_ext >&5

7654

7655

ac_cv_header_time=no

7656

7657

rm -f conftest.$ac_objext conftest.$ac_ext

7658

7659

echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5

7660

echo "${ECHO_T}$ac_cv_header_time" >&6

7661

if test $ac_cv_header_time = yes; then

7662

7663

cat >>confdefs.h <<\_ACEOF

7664

#define TIME_WITH_SYS_TIME 1

7665

_ACEOF

7666

7667

7668

7669

7670

7671

for ac_header in sys/time.h unistd.h

7672

7673

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

7674

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7675

echo "$as_me:$LINENO: checking for $ac_header" >&5

7676

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

7677

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7678

echo $ECHO_N "(cached) $ECHO_C" >&6

7679

7680

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

7681

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

7682

else

7683

# Is the header compilable?

7684

echo "$as_me:$LINENO: checking $ac_header usability" >&5

7685

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

7686

cat >conftest.$ac_ext <<_ACEOF

7687

#line $LINENO "configure"

7688

/* confdefs.h. */

7689

_ACEOF

7690

cat confdefs.h >>conftest.$ac_ext

7691

cat >>conftest.$ac_ext <<_ACEOF

7692

/* end confdefs.h. */

7693

$ac_includes_default

7694

#include <$ac_header>

7695

_ACEOF

7696

rm -f conftest.$ac_objext

7697

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7698

(eval $ac_compile) 2>&5

7699

ac_status=$?

7700

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7701

(exit $ac_status); } &&

7702

{ ac_try='test -s conftest.$ac_objext'

7703

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7704

(eval $ac_try) 2>&5

7705

ac_status=$?

7706

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7707

(exit $ac_status); }; }; then

7708

ac_header_compiler=yes

7709

else

7710

echo "$as_me: failed program was:" >&5

7711

sed 's/^/| /' conftest.$ac_ext >&5

7712

7713

ac_header_compiler=no

7714

7715

rm -f conftest.$ac_objext conftest.$ac_ext

7716

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

7717

echo "${ECHO_T}$ac_header_compiler" >&6

7718

7719

# Is the header present?

7720

echo "$as_me:$LINENO: checking $ac_header presence" >&5

7721

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

7722

cat >conftest.$ac_ext <<_ACEOF

7723

#line $LINENO "configure"

7724

/* confdefs.h. */

7725

_ACEOF

7726

cat confdefs.h >>conftest.$ac_ext

7727

cat >>conftest.$ac_ext <<_ACEOF

7728

/* end confdefs.h. */

7729

#include <$ac_header>

7730

_ACEOF

7731

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

7732

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

7733

ac_status=$?

7734

grep -v '^ *+' conftest.er1 >conftest.err

7735

rm -f conftest.er1

7736

cat conftest.err >&5

7737

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7738

(exit $ac_status); } >/dev/null; then

7739

if test -s conftest.err; then

7740

ac_cpp_err=$ac_c_preproc_warn_flag

7741

else

7742

ac_cpp_err=

7743

7744

else

7745

ac_cpp_err=yes

7746

7747

if test -z "$ac_cpp_err"; then

7748

ac_header_preproc=yes

7749

else

7750

echo "$as_me: failed program was:" >&5

7751

sed 's/^/| /' conftest.$ac_ext >&5

7752

7753

ac_header_preproc=no

7754

7755

rm -f conftest.err conftest.$ac_ext

7756

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

7757

echo "${ECHO_T}$ac_header_preproc" >&6

7758

7759

# So? What about this header?

7760

case $ac_header_compiler:$ac_header_preproc in

7761

yes:no )

7762

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

7763

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

7764

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

7765

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

7766

(

7767

cat <<\_ASBOX

7768

## ------------------------------------ ##

7769

## Report this to bug-autoconf@gnu.org. ##

7770

## ------------------------------------ ##

7771

_ASBOX

7772

) |

7773

sed "s/^/$as_me: WARNING: /" >&2

7774

;;

7775

no:yes )

7776

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

7777

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

7778

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

7779

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

7780

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

7781

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

7782

(

7783

cat <<\_ASBOX

7784

## ------------------------------------ ##

7785

## Report this to bug-autoconf@gnu.org. ##

7786

## ------------------------------------ ##

7787

_ASBOX

7788

) |

7789

sed "s/^/$as_me: WARNING: /" >&2

7790

;;

7791

esac

7792

echo "$as_me:$LINENO: checking for $ac_header" >&5

7793

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

7794

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7795

echo $ECHO_N "(cached) $ECHO_C" >&6

7796

else

7797

eval "$as_ac_Header=$ac_header_preproc"

7798

7799

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

7800

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

7801

7802

7803

if test `eval echo '${'$as_ac_Header'}'` = yes; then

7804

cat >>confdefs.h <<_ACEOF

7805

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

7806

_ACEOF

7807

7808

7809

7810

done

7811

7812

7813

for ac_func in alarm

7814

7815

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

7816

echo "$as_me:$LINENO: checking for $ac_func" >&5

7817

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

7818

if eval "test \"\${$as_ac_var+set}\" = set"; then

7819

echo $ECHO_N "(cached) $ECHO_C" >&6

7820

else

7821

cat >conftest.$ac_ext <<_ACEOF

7822

#line $LINENO "configure"

7823

/* confdefs.h. */

7824

_ACEOF

7825

cat confdefs.h >>conftest.$ac_ext

7826

cat >>conftest.$ac_ext <<_ACEOF

7827

/* end confdefs.h. */

7828

/* System header to define __stub macros and hopefully few prototypes,

7829

which can conflict with char $ac_func (); below.

7830

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

7831

<limits.h> exists even on freestanding compilers. */

7832

#ifdef __STDC__

7833

# include <limits.h>

7834

#else

7835

# include <assert.h>

7836

#endif

7837

/* Override any gcc2 internal prototype to avoid an error. */

7838

#ifdef __cplusplus

7839

extern "C"

7840

{

7841

#endif

7842

/* We use char because int might match the return type of a gcc2

7843

builtin and then its argument prototype would still apply. */

7844

char $ac_func ();

7845

/* The GNU C library defines this for functions which it implements

7846

to always fail with ENOSYS. Some functions are actually named

7847

something starting with __ and the normal name is an alias. */

7848

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

7849

choke me

7850

#else

7851

char (*f) () = $ac_func;

7852

#endif

7853

#ifdef __cplusplus

7854

}

7855

#endif

7856

7857

int

7858

main ()

7859

{

7860

return f != $ac_func;

7861

;

7862

return 0;

7863

}

7864

_ACEOF

7865

rm -f conftest.$ac_objext conftest$ac_exeext

7866

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7867

(eval $ac_link) 2>&5

7868

ac_status=$?

7869

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7870

(exit $ac_status); } &&

7871

{ ac_try='test -s conftest$ac_exeext'

7872

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7873

(eval $ac_try) 2>&5

7874

ac_status=$?

7875

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7876

(exit $ac_status); }; }; then

7877

eval "$as_ac_var=yes"

7878

else

7879

echo "$as_me: failed program was:" >&5

7880

sed 's/^/| /' conftest.$ac_ext >&5

7881

7882

eval "$as_ac_var=no"

7883

7884

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

7885

7886

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

7887

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

7888

if test `eval echo '${'$as_ac_var'}'` = yes; then

7889

cat >>confdefs.h <<_ACEOF

7890

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

7891

_ACEOF

7892

7893

7894

done

7895

7896

echo "$as_me:$LINENO: checking for working mktime" >&5

7897

echo $ECHO_N "checking for working mktime... $ECHO_C" >&6

7898

if test "${ac_cv_func_working_mktime+set}" = set; then

7899

echo $ECHO_N "(cached) $ECHO_C" >&6

7900

else

7901

if test "$cross_compiling" = yes; then

7902

ac_cv_func_working_mktime=no

7903

else

7904

cat >conftest.$ac_ext <<_ACEOF

7905

#line $LINENO "configure"

7906

/* confdefs.h. */

7907

_ACEOF

7908

cat confdefs.h >>conftest.$ac_ext

7909

cat >>conftest.$ac_ext <<_ACEOF

7910

/* end confdefs.h. */

7911

/* Test program from Paul Eggert and Tony Leneis. */

7912

#if TIME_WITH_SYS_TIME

7913

# include <sys/time.h>

7914

# include <time.h>

7915

#else

7916

# if HAVE_SYS_TIME_H

7917

# include <sys/time.h>

7918

# else

7919

# include <time.h>

7920

# endif

7921

#endif

7922

7923

#if HAVE_UNISTD_H

7924

# include <unistd.h>

7925

#endif

7926

7927

#if !HAVE_ALARM

7928

# define alarm(X) /* empty */

7929

#endif

7930

7931

/* Work around redefinition to rpl_putenv by other config tests. */

7932

#undef putenv

7933

7934

static time_t time_t_max;

7935

7936

/* Values we'll use to set the TZ environment variable. */

7937

static const char *const tz_strings[] = {

7938

(const char *) 0, "TZ=GMT0", "TZ=JST-9",

7939

"TZ=EST+3EDT+2,M10.1.0/00:00:00,M2.3.0/00:00:00"

7940

};

7941

#define N_STRINGS (sizeof (tz_strings) / sizeof (tz_strings[0]))

7942

7943

/* Fail if mktime fails to convert a date in the spring-forward gap.

7944

Based on a problem report from Andreas Jaeger. */

7945

static void

7946

spring_forward_gap ()

7947

{

7948

/* glibc (up to about 1998-10-07) failed this test. */

7949

struct tm tm;

7950

7951

/* Use the portable POSIX.1 specification "TZ=PST8PDT,M4.1.0,M10.5.0"

7952

instead of "TZ=America/Vancouver" in order to detect the bug even

7953

on systems that don't support the Olson extension, or don't have the

7954

full zoneinfo tables installed. */

7955

putenv ("TZ=PST8PDT,M4.1.0,M10.5.0");

7956

7957

tm.tm_year = 98;

7958

tm.tm_mon = 3;

7959

tm.tm_mday = 5;

7960

tm.tm_hour = 2;

7961

tm.tm_min = 0;

7962

tm.tm_sec = 0;

7963

tm.tm_isdst = -1;

7964

if (mktime (&tm) == (time_t)-1)

7965

exit (1);

7966

}

7967

7968

static void

7969

mktime_test (now)

7970

time_t now;

7971

{

7972

struct tm *lt;

7973

if ((lt = localtime (&now)) && mktime (lt) != now)

7974

exit (1);

7975

now = time_t_max - now;

7976

if ((lt = localtime (&now)) && mktime (lt) != now)

7977

exit (1);

7978

}

7979

7980

static void

7981

irix_6_4_bug ()

7982

{

7983

/* Based on code from Ariel Faigon. */

7984

struct tm tm;

7985

tm.tm_year = 96;

7986

tm.tm_mon = 3;

7987

tm.tm_mday = 0;

7988

tm.tm_hour = 0;

7989

tm.tm_min = 0;

7990

tm.tm_sec = 0;

7991

tm.tm_isdst = -1;

7992

mktime (&tm);

7993

if (tm.tm_mon != 2 || tm.tm_mday != 31)

7994

exit (1);

7995

}

7996

7997

static void

7998

bigtime_test (j)

7999

int j;

8000

{

8001

struct tm tm;

8002

time_t now;

8003

tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = j;

8004

now = mktime (&tm);

8005

if (now != (time_t) -1)

8006

{

8007

struct tm *lt = localtime (&now);

8008

if (! (lt

8009

&& lt->tm_year == tm.tm_year

8010

&& lt->tm_mon == tm.tm_mon

8011

&& lt->tm_mday == tm.tm_mday

8012

&& lt->tm_hour == tm.tm_hour

8013

&& lt->tm_min == tm.tm_min

8014

&& lt->tm_sec == tm.tm_sec

8015

&& lt->tm_yday == tm.tm_yday

8016

&& lt->tm_wday == tm.tm_wday

8017

&& ((lt->tm_isdst < 0 ? -1 : 0 < lt->tm_isdst)

8018

== (tm.tm_isdst < 0 ? -1 : 0 < tm.tm_isdst))))

8019

exit (1);

8020

}

8021

}

8022

8023

int

8024

main ()

8025

{

8026

time_t t, delta;

8027

int i, j;

8028

8029

/* This test makes some buggy mktime implementations loop.

8030

Give up after 60 seconds; a mktime slower than that

8031

isn't worth using anyway. */

8032

alarm (60);

8033

8034

for (time_t_max = 1; 0 < time_t_max; time_t_max *= 2)

8035

continue;

8036

time_t_max--;

8037

delta = time_t_max / 997; /* a suitable prime number */

8038

for (i = 0; i < N_STRINGS; i++)

8039

{

8040

if (tz_strings[i])

8041

putenv (tz_strings[i]);

8042

8043

for (t = 0; t <= time_t_max - delta; t += delta)

8044

mktime_test (t);

8045

mktime_test ((time_t) 60 * 60);

8046

mktime_test ((time_t) 60 * 60 * 24);

8047

8048

for (j = 1; 0 < j; j *= 2)

8049

bigtime_test (j);

8050

bigtime_test (j - 1);

8051

}

8052

irix_6_4_bug ();

8053

spring_forward_gap ();

8054

exit (0);

8055

}

8056

_ACEOF

8057

rm -f conftest$ac_exeext

8058

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8059

(eval $ac_link) 2>&5

8060

ac_status=$?

8061

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8062

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

8063

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8064

(eval $ac_try) 2>&5

8065

ac_status=$?

8066

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8067

(exit $ac_status); }; }; then

8068

ac_cv_func_working_mktime=yes

8069

else

8070

echo "$as_me: program exited with status $ac_status" >&5

8071

echo "$as_me: failed program was:" >&5

8072

sed 's/^/| /' conftest.$ac_ext >&5

8073

8074

( exit $ac_status )

8075

ac_cv_func_working_mktime=no

8076

8077

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

8078

8079

8080

echo "$as_me:$LINENO: result: $ac_cv_func_working_mktime" >&5

8081

echo "${ECHO_T}$ac_cv_func_working_mktime" >&6

8082

if test $ac_cv_func_working_mktime = no; then

8083

LIBOBJS="$LIBOBJS mktime.$ac_objext"

8084

8085

8086

8087

8088

if test $ac_cv_func_working_mktime = no; then

8089

8090

cat >>confdefs.h <<\_ACEOF

8091

#define mktime rpl_mktime

8092

_ACEOF

8093

8094

8095

8096

8097

8098

8099

8100

8101

8102

8103

8104

8105

8106

8107

8108

8109

8110

8111

8112

8113

8114

8115

8116

8117

8118

8119

8120

8121

8122

8123

8124

8125

8126

8127

8128

8129

8130

8131

8132

8133

8134

8135

8136

8137

8138

8139

8140

8141

8142

8143

8144

8145

8146

8147

8148

8149

8150

8151

8152

8153

8154

8155

8156

8157

8158

8159

8160

8161

for ac_func in $gl_func_list

8162

8163

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8164

echo "$as_me:$LINENO: checking for $ac_func" >&5

8165

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8166

if eval "test \"\${$as_ac_var+set}\" = set"; then

8167

echo $ECHO_N "(cached) $ECHO_C" >&6

8168

else

8169

cat >conftest.$ac_ext <<_ACEOF

8170

#line $LINENO "configure"

8171

/* confdefs.h. */

8172

_ACEOF

8173

cat confdefs.h >>conftest.$ac_ext

8174

cat >>conftest.$ac_ext <<_ACEOF

8175

/* end confdefs.h. */

8176

/* System header to define __stub macros and hopefully few prototypes,

8177

which can conflict with char $ac_func (); below.

8178

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8179

<limits.h> exists even on freestanding compilers. */

8180

#ifdef __STDC__

8181

# include <limits.h>

8182

#else

8183

# include <assert.h>

8184

#endif

8185

/* Override any gcc2 internal prototype to avoid an error. */

8186

#ifdef __cplusplus

8187

extern "C"

8188

{

8189

#endif

8190

/* We use char because int might match the return type of a gcc2

8191

builtin and then its argument prototype would still apply. */

8192

char $ac_func ();

8193

/* The GNU C library defines this for functions which it implements

8194

to always fail with ENOSYS. Some functions are actually named

8195

something starting with __ and the normal name is an alias. */

8196

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8197

choke me

8198

#else

8199

char (*f) () = $ac_func;

8200

#endif

8201

#ifdef __cplusplus

8202

}

8203

#endif

8204

8205

int

8206

main ()

8207

{

8208

return f != $ac_func;

8209

;

8210

return 0;

8211

}

8212

_ACEOF

8213

rm -f conftest.$ac_objext conftest$ac_exeext

8214

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8215

(eval $ac_link) 2>&5

8216

ac_status=$?

8217

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8218

(exit $ac_status); } &&

8219

{ ac_try='test -s conftest$ac_exeext'

8220

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8221

(eval $ac_try) 2>&5

8222

ac_status=$?

8223

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8224

(exit $ac_status); }; }; then

8225

eval "$as_ac_var=yes"

8226

else

8227

echo "$as_me: failed program was:" >&5

8228

sed 's/^/| /' conftest.$ac_ext >&5

8229

8230

eval "$as_ac_var=no"

8231

8232

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

8233

8234

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8235

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8236

if test `eval echo '${'$as_ac_var'}'` = yes; then

8237

cat >>confdefs.h <<_ACEOF

8238

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8239

_ACEOF

8240

8241

8242

done

8243

8244

8245

8246

8247

8248

8249

8250

8251

8252

8253

8254

8255

8256

8257

8258

8259

8260

8261

8262

8263

8264

8265

8266

8267

8268

8269

8270

8271

8272

8273

8274

8275

8276

echo "$as_me:$LINENO: checking for mbstate_t" >&5

8277

echo $ECHO_N "checking for mbstate_t... $ECHO_C" >&6

8278

if test "${ac_cv_type_mbstate_t+set}" = set; then

8279

echo $ECHO_N "(cached) $ECHO_C" >&6

8280

else

8281

cat >conftest.$ac_ext <<_ACEOF

8282

#line $LINENO "configure"

8283

/* confdefs.h. */

8284

_ACEOF

8285

cat confdefs.h >>conftest.$ac_ext

8286

cat >>conftest.$ac_ext <<_ACEOF

8287

/* end confdefs.h. */

8288

$ac_includes_default

8289

# include <wchar.h>

8290

int

8291

main ()

8292

{

8293

mbstate_t x; return sizeof x;

8294

;

8295

return 0;

8296

}

8297

_ACEOF

8298

rm -f conftest.$ac_objext

8299

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

8300

(eval $ac_compile) 2>&5

8301

ac_status=$?

8302

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8303

(exit $ac_status); } &&

8304

{ ac_try='test -s conftest.$ac_objext'

8305

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8306

(eval $ac_try) 2>&5

8307

ac_status=$?

8308

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8309

(exit $ac_status); }; }; then

8310

ac_cv_type_mbstate_t=yes

8311

else

8312

echo "$as_me: failed program was:" >&5

8313

sed 's/^/| /' conftest.$ac_ext >&5

8314

8315

ac_cv_type_mbstate_t=no

8316

8317

rm -f conftest.$ac_objext conftest.$ac_ext

8318

8319

echo "$as_me:$LINENO: result: $ac_cv_type_mbstate_t" >&5

8320

echo "${ECHO_T}$ac_cv_type_mbstate_t" >&6

8321

if test $ac_cv_type_mbstate_t = yes; then

8322

8323

cat >>confdefs.h <<\_ACEOF

8324

#define HAVE_MBSTATE_T 1

8325

_ACEOF

8326

8327

else

8328

8329

cat >>confdefs.h <<\_ACEOF

8330

#define mbstate_t int

8331

_ACEOF

8332

8333

8334

8335

echo "$as_me:$LINENO: checking whether mbrtowc and mbstate_t are properly declared" >&5

8336

echo $ECHO_N "checking whether mbrtowc and mbstate_t are properly declared... $ECHO_C" >&6

8337

if test "${jm_cv_func_mbrtowc+set}" = set; then

8338

echo $ECHO_N "(cached) $ECHO_C" >&6

8339

else

8340

cat >conftest.$ac_ext <<_ACEOF

8341

#line $LINENO "configure"

8342

/* confdefs.h. */

8343

_ACEOF

8344

cat confdefs.h >>conftest.$ac_ext

8345

cat >>conftest.$ac_ext <<_ACEOF

8346

/* end confdefs.h. */

8347

#include <wchar.h>

8348

int

8349

main ()

8350

{

8351

mbstate_t state; return ! (sizeof state && mbrtowc);

8352

;

8353

return 0;

8354

}

8355

_ACEOF

8356

rm -f conftest.$ac_objext conftest$ac_exeext

8357

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8358

(eval $ac_link) 2>&5

8359

ac_status=$?

8360

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8361

(exit $ac_status); } &&

8362

{ ac_try='test -s conftest$ac_exeext'

8363

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8364

(eval $ac_try) 2>&5

8365

ac_status=$?

8366

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8367

(exit $ac_status); }; }; then

8368

jm_cv_func_mbrtowc=yes

8369

else

8370

echo "$as_me: failed program was:" >&5

8371

sed 's/^/| /' conftest.$ac_ext >&5

8372

8373

jm_cv_func_mbrtowc=no

8374

8375

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

8376

8377

echo "$as_me:$LINENO: result: $jm_cv_func_mbrtowc" >&5

8378

echo "${ECHO_T}$jm_cv_func_mbrtowc" >&6

8379

if test $jm_cv_func_mbrtowc = yes; then

8380

8381

cat >>confdefs.h <<\_ACEOF

8382

#define HAVE_MBRTOWC 1

8383

_ACEOF

8384

8385

8386

8387

8388

8389

8390

for ac_header in stdlib.h

8391

8392

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

8393

if eval "test \"\${$as_ac_Header+set}\" = set"; then

8394

echo "$as_me:$LINENO: checking for $ac_header" >&5

8395

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

8396

if eval "test \"\${$as_ac_Header+set}\" = set"; then

8397

echo $ECHO_N "(cached) $ECHO_C" >&6

8398

8399

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

8400

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

8401

else

8402

# Is the header compilable?

8403

echo "$as_me:$LINENO: checking $ac_header usability" >&5

8404

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

8405

cat >conftest.$ac_ext <<_ACEOF

8406

#line $LINENO "configure"

8407

/* confdefs.h. */

8408

_ACEOF

8409

cat confdefs.h >>conftest.$ac_ext

8410

cat >>conftest.$ac_ext <<_ACEOF

8411

/* end confdefs.h. */

8412

$ac_includes_default

8413

#include <$ac_header>

8414

_ACEOF

8415

rm -f conftest.$ac_objext

8416

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

8417

(eval $ac_compile) 2>&5

8418

ac_status=$?

8419

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8420

(exit $ac_status); } &&

8421

{ ac_try='test -s conftest.$ac_objext'

8422

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8423

(eval $ac_try) 2>&5

8424

ac_status=$?

8425

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8426

(exit $ac_status); }; }; then

8427

ac_header_compiler=yes

8428

else

8429

echo "$as_me: failed program was:" >&5

8430

sed 's/^/| /' conftest.$ac_ext >&5

8431

8432

ac_header_compiler=no

8433

8434

rm -f conftest.$ac_objext conftest.$ac_ext

8435

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

8436

echo "${ECHO_T}$ac_header_compiler" >&6

8437

8438

# Is the header present?

8439

echo "$as_me:$LINENO: checking $ac_header presence" >&5

8440

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

8441

cat >conftest.$ac_ext <<_ACEOF

8442

#line $LINENO "configure"

8443

/* confdefs.h. */

8444

_ACEOF

8445

cat confdefs.h >>conftest.$ac_ext

8446

cat >>conftest.$ac_ext <<_ACEOF

8447

/* end confdefs.h. */

8448

#include <$ac_header>

8449

_ACEOF

8450

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

8451

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

8452

ac_status=$?

8453

grep -v '^ *+' conftest.er1 >conftest.err

8454

rm -f conftest.er1

8455

cat conftest.err >&5

8456

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8457

(exit $ac_status); } >/dev/null; then

8458

if test -s conftest.err; then

8459

ac_cpp_err=$ac_c_preproc_warn_flag

8460

else

8461

ac_cpp_err=

8462

8463

else

8464

ac_cpp_err=yes

8465

8466

if test -z "$ac_cpp_err"; then

8467

ac_header_preproc=yes

8468

else

8469

echo "$as_me: failed program was:" >&5

8470

sed 's/^/| /' conftest.$ac_ext >&5

8471

8472

ac_header_preproc=no

8473

8474

rm -f conftest.err conftest.$ac_ext

8475

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

8476

echo "${ECHO_T}$ac_header_preproc" >&6

8477

8478

# So? What about this header?

8479

case $ac_header_compiler:$ac_header_preproc in

8480

yes:no )

8481

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

8482

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

8483

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

8484

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

8485

(

8486

cat <<\_ASBOX

8487

## ------------------------------------ ##

8488

## Report this to bug-autoconf@gnu.org. ##

8489

## ------------------------------------ ##

8490

_ASBOX

8491

) |

8492

sed "s/^/$as_me: WARNING: /" >&2

8493

;;

8494

no:yes )

8495

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

8496

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

8497

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

8498

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

8499

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

8500

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

8501

(

8502

cat <<\_ASBOX

8503

## ------------------------------------ ##

8504

## Report this to bug-autoconf@gnu.org. ##

8505

## ------------------------------------ ##

8506

_ASBOX

8507

) |

8508

sed "s/^/$as_me: WARNING: /" >&2

8509

;;

8510

esac

8511

echo "$as_me:$LINENO: checking for $ac_header" >&5

8512

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

8513

if eval "test \"\${$as_ac_Header+set}\" = set"; then

8514

echo $ECHO_N "(cached) $ECHO_C" >&6

8515

else

8516

eval "$as_ac_Header=$ac_header_preproc"

8517

8518

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

8519

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

8520

8521

8522

if test `eval echo '${'$as_ac_Header'}'` = yes; then

8523

cat >>confdefs.h <<_ACEOF

8524

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

8525

_ACEOF

8526

8527

8528

8529

done

8530

8531

echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5

8532

echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6

8533

if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then

8534

echo $ECHO_N "(cached) $ECHO_C" >&6

8535

else

8536

if test "$cross_compiling" = yes; then

8537

ac_cv_func_realloc_0_nonnull=no

8538

else

8539

cat >conftest.$ac_ext <<_ACEOF

8540

#line $LINENO "configure"

8541

/* confdefs.h. */

8542

_ACEOF

8543

cat confdefs.h >>conftest.$ac_ext

8544

cat >>conftest.$ac_ext <<_ACEOF

8545

/* end confdefs.h. */

8546

#if STDC_HEADERS || HAVE_STDLIB_H

8547

# include <stdlib.h>

8548

#else

8549

char *realloc ();

8550

#endif

8551

8552

int

8553

main ()

8554

{

8555

exit (realloc (0, 0) ? 0 : 1);

8556

;

8557

return 0;

8558

}

8559

_ACEOF

8560

rm -f conftest$ac_exeext

8561

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8562

(eval $ac_link) 2>&5

8563

ac_status=$?

8564

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8565

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

8566

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8567

(eval $ac_try) 2>&5

8568

ac_status=$?

8569

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8570

(exit $ac_status); }; }; then

8571

ac_cv_func_realloc_0_nonnull=yes

8572

else

8573

echo "$as_me: program exited with status $ac_status" >&5

8574

echo "$as_me: failed program was:" >&5

8575

sed 's/^/| /' conftest.$ac_ext >&5

8576

8577

( exit $ac_status )

8578

ac_cv_func_realloc_0_nonnull=no

8579

8580

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

8581

8582

8583

echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5

8584

echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6

8585

if test $ac_cv_func_realloc_0_nonnull = yes; then

8586

8587

cat >>confdefs.h <<\_ACEOF

8588

#define HAVE_REALLOC 1

8589

_ACEOF

8590

8591

else

8592

cat >>confdefs.h <<\_ACEOF

8593

#define HAVE_REALLOC 0

8594

_ACEOF

8595

8596

LIBOBJS="$LIBOBJS realloc.$ac_objext"

8597

8598

cat >>confdefs.h <<\_ACEOF

8599

#define realloc rpl_realloc

8600

_ACEOF

8601

8602

8603

8604

8605

8606

8607

8608

if test X"$ac_cv_func_realloc_0_nonnull" = Xno || test X"$ac_cv_func_realloc_works" = Xno; then

8609

8610

8611

8612

8613

8614

8615

8616

8617

8618

8619

8620

8621

8622

8623

8624

8625

8626

8627

8628

8629

8630

# Assume we'll default to using the included regex.c.

8631

ac_use_included_regex=yes

8632

8633

# However, if the system regex support is good enough that it passes the

8634

# the following run test, then default to *not* using the included regex.c.

8635

# If cross compiling, assume the test would fail and use the included

8636

# regex.c. The first failing regular expression is from `Spencer ere

8637

# test #75' in grep-2.3.

8638

echo "$as_me:$LINENO: checking for working re_compile_pattern" >&5

8639

echo $ECHO_N "checking for working re_compile_pattern... $ECHO_C" >&6

8640

if test "${jm_cv_func_working_re_compile_pattern+set}" = set; then

8641

echo $ECHO_N "(cached) $ECHO_C" >&6

8642

else

8643

if test "$cross_compiling" = yes; then

8644

jm_cv_func_working_re_compile_pattern=no

8645

else

8646

cat >conftest.$ac_ext <<_ACEOF

8647

#line $LINENO "configure"

8648

/* confdefs.h. */

8649

_ACEOF

8650

cat confdefs.h >>conftest.$ac_ext

8651

cat >>conftest.$ac_ext <<_ACEOF

8652

/* end confdefs.h. */

8653

#include <stdio.h>

8654

#include <string.h>

8655

#include <regex.h>

8656

int

8657

main ()

8658

{

8659

static struct re_pattern_buffer regex;

8660

const char *s;

8661

struct re_registers regs;

8662

re_set_syntax (RE_SYNTAX_POSIX_EGREP);

8663

memset (&regex, 0, sizeof (regex));

8664

s = re_compile_pattern ("a[[:]:]]b\n", 9, &regex);

8665

/* This should fail with _Invalid character class name_ error. */

8666

if (!s)

8667

exit (1);

8668

8669

/* This should succeed, but doesn't for e.g. glibc-2.1.3. */

8670

memset (&regex, 0, sizeof (regex));

8671

s = re_compile_pattern ("{1", 2, &regex);

8672

8673

if (s)

8674

exit (1);

8675

8676

/* The following example is derived from a problem report

8677

against gawk from Jorge Stolfi <stolfi@ic.unicamp.br>. */

8678

memset (&regex, 0, sizeof (regex));

8679

s = re_compile_pattern ("[an�]*n", 7, &regex);

8680

if (s)

8681

exit (1);

8682

8683

/* This should match, but doesn't for e.g. glibc-2.2.1. */

8684

if (re_match (&regex, "an", 2, 0, &regs) != 2)

8685

exit (1);

8686

8687

memset (&regex, 0, sizeof (regex));

8688

s = re_compile_pattern ("x", 1, &regex);

8689

if (s)

8690

exit (1);

8691

8692

/* The version of regex.c in e.g. GNU libc-2.2.93 didn't

8693

work with a negative RANGE argument. */

8694

if (re_search (&regex, "wxy", 3, 2, -2, &regs) != 1)

8695

exit (1);

8696

8697

exit (0);

8698

}

8699

8700

_ACEOF

8701

rm -f conftest$ac_exeext

8702

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8703

(eval $ac_link) 2>&5

8704

ac_status=$?

8705

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8706

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

8707

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8708

(eval $ac_try) 2>&5

8709

ac_status=$?

8710

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8711

(exit $ac_status); }; }; then

8712

jm_cv_func_working_re_compile_pattern=yes

8713

else

8714

echo "$as_me: program exited with status $ac_status" >&5

8715

echo "$as_me: failed program was:" >&5

8716

sed 's/^/| /' conftest.$ac_ext >&5

8717

8718

( exit $ac_status )

8719

jm_cv_func_working_re_compile_pattern=no

8720

8721

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

8722

8723

8724

echo "$as_me:$LINENO: result: $jm_cv_func_working_re_compile_pattern" >&5

8725

echo "${ECHO_T}$jm_cv_func_working_re_compile_pattern" >&6

8726

if test $jm_cv_func_working_re_compile_pattern = yes; then

8727

ac_use_included_regex=no

8728

8729

8730

test -n "lib/regex.c" || { { echo "$as_me:$LINENO: error: missing argument" >&5

8731

echo "$as_me: error: missing argument" >&2;}

8732

{ (exit 1); exit 1; }; }

8733

8734

8735

8736

# Check whether --with-included-regex or --without-included-regex was given.

8737

if test "${with_included_regex+set}" = set; then

8738

withval="$with_included_regex"

8739

jm_with_regex=$withval

8740

else

8741

jm_with_regex=$ac_use_included_regex

8742

fi;

8743

if test "$jm_with_regex" = yes; then

8744

LIBOBJS="$LIBOBJS regex.$ac_objext"

8745

8746

8747

8748

8749

8750

8751

8752

8753

8754

8755

8756

8757

8758

8759

8760

8761

8762

8763

8764

8765

8766

8767

8768

8769

8770

8771

8772

8773

8774

8775

8776

8777

8778

for ac_func in btowc

8779

8780

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8781

echo "$as_me:$LINENO: checking for $ac_func" >&5

8782

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8783

if eval "test \"\${$as_ac_var+set}\" = set"; then

8784

echo $ECHO_N "(cached) $ECHO_C" >&6

8785

else

8786

cat >conftest.$ac_ext <<_ACEOF

8787

#line $LINENO "configure"

8788

/* confdefs.h. */

8789

_ACEOF

8790

cat confdefs.h >>conftest.$ac_ext

8791

cat >>conftest.$ac_ext <<_ACEOF

8792

/* end confdefs.h. */

8793

/* System header to define __stub macros and hopefully few prototypes,

8794

which can conflict with char $ac_func (); below.

8795

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8796

<limits.h> exists even on freestanding compilers. */

8797

#ifdef __STDC__

8798

# include <limits.h>

8799

#else

8800

# include <assert.h>

8801

#endif

8802

/* Override any gcc2 internal prototype to avoid an error. */

8803

#ifdef __cplusplus

8804

extern "C"

8805

{

8806

#endif

8807

/* We use char because int might match the return type of a gcc2

8808

builtin and then its argument prototype would still apply. */

8809

char $ac_func ();

8810

/* The GNU C library defines this for functions which it implements

8811

to always fail with ENOSYS. Some functions are actually named

8812

something starting with __ and the normal name is an alias. */

8813

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8814

choke me

8815

#else

8816

char (*f) () = $ac_func;

8817

#endif

8818

#ifdef __cplusplus

8819

}

8820

#endif

8821

8822

int

8823

main ()

8824

{

8825

return f != $ac_func;

8826

;

8827

return 0;

8828

}

8829

_ACEOF

8830

rm -f conftest.$ac_objext conftest$ac_exeext

8831

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8832

(eval $ac_link) 2>&5

8833

ac_status=$?

8834

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8835

(exit $ac_status); } &&

8836

{ ac_try='test -s conftest$ac_exeext'

8837

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8838

(eval $ac_try) 2>&5

8839

ac_status=$?

8840

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8841

(exit $ac_status); }; }; then

8842

eval "$as_ac_var=yes"

8843

else

8844

echo "$as_me: failed program was:" >&5

8845

sed 's/^/| /' conftest.$ac_ext >&5

8846

8847

eval "$as_ac_var=no"

8848

8849

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

8850

8851

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8852

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8853

if test `eval echo '${'$as_ac_var'}'` = yes; then

8854

cat >>confdefs.h <<_ACEOF

8855

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8856

_ACEOF

8857

8858

8859

done

8860

8861

8862

8863

8864

8865

8866

8867

8868

8869

8870

for ac_func in rpmatch

8871

8872

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8873

echo "$as_me:$LINENO: checking for $ac_func" >&5

8874

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8875

if eval "test \"\${$as_ac_var+set}\" = set"; then

8876

echo $ECHO_N "(cached) $ECHO_C" >&6

8877

else

8878

cat >conftest.$ac_ext <<_ACEOF

8879

#line $LINENO "configure"

8880

/* confdefs.h. */

8881

_ACEOF

8882

cat confdefs.h >>conftest.$ac_ext

8883

cat >>conftest.$ac_ext <<_ACEOF

8884

/* end confdefs.h. */

8885

/* System header to define __stub macros and hopefully few prototypes,

8886

which can conflict with char $ac_func (); below.

8887

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8888

<limits.h> exists even on freestanding compilers. */

8889

#ifdef __STDC__

8890

# include <limits.h>

8891

#else

8892

# include <assert.h>

8893

#endif

8894

/* Override any gcc2 internal prototype to avoid an error. */

8895

#ifdef __cplusplus

8896

extern "C"

8897

{

8898

#endif

8899

/* We use char because int might match the return type of a gcc2

8900

builtin and then its argument prototype would still apply. */

8901

char $ac_func ();

8902

/* The GNU C library defines this for functions which it implements

8903

to always fail with ENOSYS. Some functions are actually named

8904

something starting with __ and the normal name is an alias. */

8905

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8906

choke me

8907

#else

8908

char (*f) () = $ac_func;

8909

#endif

8910

#ifdef __cplusplus

8911

}

8912

#endif

8913

8914

int

8915

main ()

8916

{

8917

return f != $ac_func;

8918

;

8919

return 0;

8920

}

8921

_ACEOF

8922

rm -f conftest.$ac_objext conftest$ac_exeext

8923

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8924

(eval $ac_link) 2>&5

8925

ac_status=$?

8926

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8927

(exit $ac_status); } &&

8928

{ ac_try='test -s conftest$ac_exeext'

8929

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8930

(eval $ac_try) 2>&5

8931

ac_status=$?

8932

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8933

(exit $ac_status); }; }; then

8934

eval "$as_ac_var=yes"

8935

else

8936

echo "$as_me: failed program was:" >&5

8937

sed 's/^/| /' conftest.$ac_ext >&5

8938

8939

eval "$as_ac_var=no"

8940

8941

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

8942

8943

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8944

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8945

if test `eval echo '${'$as_ac_var'}'` = yes; then

8946

cat >>confdefs.h <<_ACEOF

8947

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8948

_ACEOF

8949

8950

else

8951

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

8952

8953

done

8954

8955

8956

if test $ac_cv_func_rpmatch = no; then

8957

8958

8959

8960

8961

8962

8963

8964

8965

8966

8967

8968

8969

8970

8971

8972

8973

8974

8975

ac_header_dirent=no

8976

for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do

8977

as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh`

8978

echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5

8979

echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6

8980

if eval "test \"\${$as_ac_Header+set}\" = set"; then

8981

echo $ECHO_N "(cached) $ECHO_C" >&6

8982

else

8983

cat >conftest.$ac_ext <<_ACEOF

8984

#line $LINENO "configure"

8985

/* confdefs.h. */

8986

_ACEOF

8987

cat confdefs.h >>conftest.$ac_ext

8988

cat >>conftest.$ac_ext <<_ACEOF

8989

/* end confdefs.h. */

8990

#include <sys/types.h>

8991

#include <$ac_hdr>

8992

8993

int

8994

main ()

8995

{

8996

if ((DIR *) 0)

8997

return 0;

8998

;

8999

return 0;

9000

}

9001

_ACEOF

9002

rm -f conftest.$ac_objext

9003

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

9004

(eval $ac_compile) 2>&5

9005

ac_status=$?

9006

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9007

(exit $ac_status); } &&

9008

{ ac_try='test -s conftest.$ac_objext'

9009

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9010

(eval $ac_try) 2>&5

9011

ac_status=$?

9012

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9013

(exit $ac_status); }; }; then

9014

eval "$as_ac_Header=yes"

9015

else

9016

echo "$as_me: failed program was:" >&5

9017

sed 's/^/| /' conftest.$ac_ext >&5

9018

9019

eval "$as_ac_Header=no"

9020

9021

rm -f conftest.$ac_objext conftest.$ac_ext

9022

9023

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

9024

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

9025

if test `eval echo '${'$as_ac_Header'}'` = yes; then

9026

cat >>confdefs.h <<_ACEOF

9027

#define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1

9028

_ACEOF

9029

9030

ac_header_dirent=$ac_hdr; break

9031

9032

9033

done

9034

# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.

9035

if test $ac_header_dirent = dirent.h; then

9036

echo "$as_me:$LINENO: checking for library containing opendir" >&5

9037

echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6

9038

if test "${ac_cv_search_opendir+set}" = set; then

9039

echo $ECHO_N "(cached) $ECHO_C" >&6

9040

else

9041

ac_func_search_save_LIBS=$LIBS

9042

ac_cv_search_opendir=no

9043

cat >conftest.$ac_ext <<_ACEOF

9044

#line $LINENO "configure"

9045

/* confdefs.h. */

9046

_ACEOF

9047

cat confdefs.h >>conftest.$ac_ext

9048

cat >>conftest.$ac_ext <<_ACEOF

9049

/* end confdefs.h. */

9050

9051

/* Override any gcc2 internal prototype to avoid an error. */

9052

#ifdef __cplusplus

9053

extern "C"

9054

#endif

9055

/* We use char because int might match the return type of a gcc2

9056

builtin and then its argument prototype would still apply. */

9057

char opendir ();

9058

int

9059

main ()

9060

{

9061

opendir ();

9062

;

9063

return 0;

9064

}

9065

_ACEOF

9066

rm -f conftest.$ac_objext conftest$ac_exeext

9067

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9068

(eval $ac_link) 2>&5

9069

ac_status=$?

9070

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9071

(exit $ac_status); } &&

9072

{ ac_try='test -s conftest$ac_exeext'

9073

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9074

(eval $ac_try) 2>&5

9075

ac_status=$?

9076

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9077

(exit $ac_status); }; }; then

9078

ac_cv_search_opendir="none required"

9079

else

9080

echo "$as_me: failed program was:" >&5

9081

sed 's/^/| /' conftest.$ac_ext >&5

9082

9083

9084

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9085

if test "$ac_cv_search_opendir" = no; then

9086

for ac_lib in dir; do

9087

LIBS="-l$ac_lib $ac_func_search_save_LIBS"

9088

cat >conftest.$ac_ext <<_ACEOF

9089

#line $LINENO "configure"

9090

/* confdefs.h. */

9091

_ACEOF

9092

cat confdefs.h >>conftest.$ac_ext

9093

cat >>conftest.$ac_ext <<_ACEOF

9094

/* end confdefs.h. */

9095

9096

/* Override any gcc2 internal prototype to avoid an error. */

9097

#ifdef __cplusplus

9098

extern "C"

9099

#endif

9100

/* We use char because int might match the return type of a gcc2

9101

builtin and then its argument prototype would still apply. */

9102

char opendir ();

9103

int

9104

main ()

9105

{

9106

opendir ();

9107

;

9108

return 0;

9109

}

9110

_ACEOF

9111

rm -f conftest.$ac_objext conftest$ac_exeext

9112

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9113

(eval $ac_link) 2>&5

9114

ac_status=$?

9115

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9116

(exit $ac_status); } &&

9117

{ ac_try='test -s conftest$ac_exeext'

9118

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9119

(eval $ac_try) 2>&5

9120

ac_status=$?

9121

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9122

(exit $ac_status); }; }; then

9123

ac_cv_search_opendir="-l$ac_lib"

9124

break

9125

else

9126

echo "$as_me: failed program was:" >&5

9127

sed 's/^/| /' conftest.$ac_ext >&5

9128

9129

9130

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9131

done

9132

9133

LIBS=$ac_func_search_save_LIBS

9134

9135

echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5

9136

echo "${ECHO_T}$ac_cv_search_opendir" >&6

9137

if test "$ac_cv_search_opendir" != no; then

9138

test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"

9139

9140

9141

9142

else

9143

echo "$as_me:$LINENO: checking for library containing opendir" >&5

9144

echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6

9145

if test "${ac_cv_search_opendir+set}" = set; then

9146

echo $ECHO_N "(cached) $ECHO_C" >&6

9147

else

9148

ac_func_search_save_LIBS=$LIBS

9149

ac_cv_search_opendir=no

9150

cat >conftest.$ac_ext <<_ACEOF

9151

#line $LINENO "configure"

9152

/* confdefs.h. */

9153

_ACEOF

9154

cat confdefs.h >>conftest.$ac_ext

9155

cat >>conftest.$ac_ext <<_ACEOF

9156

/* end confdefs.h. */

9157

9158

/* Override any gcc2 internal prototype to avoid an error. */

9159

#ifdef __cplusplus

9160

extern "C"

9161

#endif

9162

/* We use char because int might match the return type of a gcc2

9163

builtin and then its argument prototype would still apply. */

9164

char opendir ();

9165

int

9166

main ()

9167

{

9168

opendir ();

9169

;

9170

return 0;

9171

}

9172

_ACEOF

9173

rm -f conftest.$ac_objext conftest$ac_exeext

9174

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9175

(eval $ac_link) 2>&5

9176

ac_status=$?

9177

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9178

(exit $ac_status); } &&

9179

{ ac_try='test -s conftest$ac_exeext'

9180

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9181

(eval $ac_try) 2>&5

9182

ac_status=$?

9183

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9184

(exit $ac_status); }; }; then

9185

ac_cv_search_opendir="none required"

9186

else

9187

echo "$as_me: failed program was:" >&5

9188

sed 's/^/| /' conftest.$ac_ext >&5

9189

9190

9191

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9192

if test "$ac_cv_search_opendir" = no; then

9193

for ac_lib in x; do

9194

LIBS="-l$ac_lib $ac_func_search_save_LIBS"

9195

cat >conftest.$ac_ext <<_ACEOF

9196

#line $LINENO "configure"

9197

/* confdefs.h. */

9198

_ACEOF

9199

cat confdefs.h >>conftest.$ac_ext

9200

cat >>conftest.$ac_ext <<_ACEOF

9201

/* end confdefs.h. */

9202

9203

/* Override any gcc2 internal prototype to avoid an error. */

9204

#ifdef __cplusplus

9205

extern "C"

9206

#endif

9207

/* We use char because int might match the return type of a gcc2

9208

builtin and then its argument prototype would still apply. */

9209

char opendir ();

9210

int

9211

main ()

9212

{

9213

opendir ();

9214

;

9215

return 0;

9216

}

9217

_ACEOF

9218

rm -f conftest.$ac_objext conftest$ac_exeext

9219

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9220

(eval $ac_link) 2>&5

9221

ac_status=$?

9222

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9223

(exit $ac_status); } &&

9224

{ ac_try='test -s conftest$ac_exeext'

9225

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9226

(eval $ac_try) 2>&5

9227

ac_status=$?

9228

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9229

(exit $ac_status); }; }; then

9230

ac_cv_search_opendir="-l$ac_lib"

9231

break

9232

else

9233

echo "$as_me: failed program was:" >&5

9234

sed 's/^/| /' conftest.$ac_ext >&5

9235

9236

9237

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9238

done

9239

9240

LIBS=$ac_func_search_save_LIBS

9241

9242

echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5

9243

echo "${ECHO_T}$ac_cv_search_opendir" >&6

9244

if test "$ac_cv_search_opendir" != no; then

9245

test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"

9246

9247

9248

9249

9250

9251

echo "$as_me:$LINENO: checking whether closedir returns void" >&5

9252

echo $ECHO_N "checking whether closedir returns void... $ECHO_C" >&6

9253

if test "${ac_cv_func_closedir_void+set}" = set; then

9254

echo $ECHO_N "(cached) $ECHO_C" >&6

9255

else

9256

if test "$cross_compiling" = yes; then

9257

ac_cv_func_closedir_void=yes

9258

else

9259

cat >conftest.$ac_ext <<_ACEOF

9260

#line $LINENO "configure"

9261

/* confdefs.h. */

9262

_ACEOF

9263

cat confdefs.h >>conftest.$ac_ext

9264

cat >>conftest.$ac_ext <<_ACEOF

9265

/* end confdefs.h. */

9266

$ac_includes_default

9267

#include <$ac_header_dirent>

9268

#ifndef __cplusplus

9269

int closedir ();

9270

#endif

9271

9272

int

9273

main ()

9274

{

9275

exit (closedir (opendir (".")) != 0);

9276

;

9277

return 0;

9278

}

9279

_ACEOF

9280

rm -f conftest$ac_exeext

9281

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9282

(eval $ac_link) 2>&5

9283

ac_status=$?

9284

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9285

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

9286

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9287

(eval $ac_try) 2>&5

9288

ac_status=$?

9289

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9290

(exit $ac_status); }; }; then

9291

ac_cv_func_closedir_void=no

9292

else

9293

echo "$as_me: program exited with status $ac_status" >&5

9294

echo "$as_me: failed program was:" >&5

9295

sed 's/^/| /' conftest.$ac_ext >&5

9296

9297

( exit $ac_status )

9298

ac_cv_func_closedir_void=yes

9299

9300

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

9301

9302

9303

echo "$as_me:$LINENO: result: $ac_cv_func_closedir_void" >&5

9304

echo "${ECHO_T}$ac_cv_func_closedir_void" >&6

9305

if test $ac_cv_func_closedir_void = yes; then

9306

9307

cat >>confdefs.h <<\_ACEOF

9308

#define CLOSEDIR_VOID 1

9309

_ACEOF

9310

9311

9312

9313

9314

9315

9316

9317

9318

9319

9320

echo "$as_me:$LINENO: checking whether stat accepts an empty string" >&5

9321

echo $ECHO_N "checking whether stat accepts an empty string... $ECHO_C" >&6

9322

if test "${ac_cv_func_stat_empty_string_bug+set}" = set; then

9323

echo $ECHO_N "(cached) $ECHO_C" >&6

9324

else

9325

if test "$cross_compiling" = yes; then

9326

ac_cv_func_stat_empty_string_bug=yes

9327

else

9328

cat >conftest.$ac_ext <<_ACEOF

9329

#line $LINENO "configure"

9330

/* confdefs.h. */

9331

_ACEOF

9332

cat confdefs.h >>conftest.$ac_ext

9333

cat >>conftest.$ac_ext <<_ACEOF

9334

/* end confdefs.h. */

9335

$ac_includes_default

9336

int

9337

main ()

9338

{

9339

struct stat sbuf;

9340

exit (stat ("", &sbuf) ? 1 : 0);

9341

;

9342

return 0;

9343

}

9344

_ACEOF

9345

rm -f conftest$ac_exeext

9346

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9347

(eval $ac_link) 2>&5

9348

ac_status=$?

9349

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9350

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

9351

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9352

(eval $ac_try) 2>&5

9353

ac_status=$?

9354

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9355

(exit $ac_status); }; }; then

9356

ac_cv_func_stat_empty_string_bug=yes

9357

else

9358

echo "$as_me: program exited with status $ac_status" >&5

9359

echo "$as_me: failed program was:" >&5

9360

sed 's/^/| /' conftest.$ac_ext >&5

9361

9362

( exit $ac_status )

9363

ac_cv_func_stat_empty_string_bug=no

9364

9365

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

9366

9367

9368

echo "$as_me:$LINENO: result: $ac_cv_func_stat_empty_string_bug" >&5

9369

echo "${ECHO_T}$ac_cv_func_stat_empty_string_bug" >&6

9370

if test $ac_cv_func_stat_empty_string_bug = yes; then

9371

LIBOBJS="$LIBOBJS stat.$ac_objext"

9372

9373

cat >>confdefs.h <<_ACEOF

9374

#define HAVE_STAT_EMPTY_STRING_BUG 1

9375

_ACEOF

9376

9377

9378

9379

if test $ac_cv_func_stat_empty_string_bug = yes; then

9380

9381

9382

9383

9384

9385

9386

9387

9388

9389

9390

for ac_func in stpcpy

9391

9392

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

9393

echo "$as_me:$LINENO: checking for $ac_func" >&5

9394

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

9395

if eval "test \"\${$as_ac_var+set}\" = set"; then

9396

echo $ECHO_N "(cached) $ECHO_C" >&6

9397

else

9398

cat >conftest.$ac_ext <<_ACEOF

9399

#line $LINENO "configure"

9400

/* confdefs.h. */

9401

_ACEOF

9402

cat confdefs.h >>conftest.$ac_ext

9403

cat >>conftest.$ac_ext <<_ACEOF

9404

/* end confdefs.h. */

9405

/* System header to define __stub macros and hopefully few prototypes,

9406

which can conflict with char $ac_func (); below.

9407

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

9408

<limits.h> exists even on freestanding compilers. */

9409

#ifdef __STDC__

9410

# include <limits.h>

9411

#else

9412

# include <assert.h>

9413

#endif

9414

/* Override any gcc2 internal prototype to avoid an error. */

9415

#ifdef __cplusplus

9416

extern "C"

9417

{

9418

#endif

9419

/* We use char because int might match the return type of a gcc2

9420

builtin and then its argument prototype would still apply. */

9421

char $ac_func ();

9422

/* The GNU C library defines this for functions which it implements

9423

to always fail with ENOSYS. Some functions are actually named

9424

something starting with __ and the normal name is an alias. */

9425

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

9426

choke me

9427

#else

9428

char (*f) () = $ac_func;

9429

#endif

9430

#ifdef __cplusplus

9431

}

9432

#endif

9433

9434

int

9435

main ()

9436

{

9437

return f != $ac_func;

9438

;

9439

return 0;

9440

}

9441

_ACEOF

9442

rm -f conftest.$ac_objext conftest$ac_exeext

9443

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9444

(eval $ac_link) 2>&5

9445

ac_status=$?

9446

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9447

(exit $ac_status); } &&

9448

{ ac_try='test -s conftest$ac_exeext'

9449

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9450

(eval $ac_try) 2>&5

9451

ac_status=$?

9452

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9453

(exit $ac_status); }; }; then

9454

eval "$as_ac_var=yes"

9455

else

9456

echo "$as_me: failed program was:" >&5

9457

sed 's/^/| /' conftest.$ac_ext >&5

9458

9459

eval "$as_ac_var=no"

9460

9461

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9462

9463

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9464

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9465

if test `eval echo '${'$as_ac_var'}'` = yes; then

9466

cat >>confdefs.h <<_ACEOF

9467

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9468

_ACEOF

9469

9470

else

9471

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

9472

9473

done

9474

9475

9476

if test $ac_cv_func_stpcpy = no; then

9477

9478

9479

9480

9481

9482

9483

9484

9485

for ac_func in strdup

9486

9487

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

9488

echo "$as_me:$LINENO: checking for $ac_func" >&5

9489

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

9490

if eval "test \"\${$as_ac_var+set}\" = set"; then

9491

echo $ECHO_N "(cached) $ECHO_C" >&6

9492

else

9493

cat >conftest.$ac_ext <<_ACEOF

9494

#line $LINENO "configure"

9495

/* confdefs.h. */

9496

_ACEOF

9497

cat confdefs.h >>conftest.$ac_ext

9498

cat >>conftest.$ac_ext <<_ACEOF

9499

/* end confdefs.h. */

9500

/* System header to define __stub macros and hopefully few prototypes,

9501

which can conflict with char $ac_func (); below.

9502

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

9503

<limits.h> exists even on freestanding compilers. */

9504

#ifdef __STDC__

9505

# include <limits.h>

9506

#else

9507

# include <assert.h>

9508

#endif

9509

/* Override any gcc2 internal prototype to avoid an error. */

9510

#ifdef __cplusplus

9511

extern "C"

9512

{

9513

#endif

9514

/* We use char because int might match the return type of a gcc2

9515

builtin and then its argument prototype would still apply. */

9516

char $ac_func ();

9517

/* The GNU C library defines this for functions which it implements

9518

to always fail with ENOSYS. Some functions are actually named

9519

something starting with __ and the normal name is an alias. */

9520

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

9521

choke me

9522

#else

9523

char (*f) () = $ac_func;

9524

#endif

9525

#ifdef __cplusplus

9526

}

9527

#endif

9528

9529

int

9530

main ()

9531

{

9532

return f != $ac_func;

9533

;

9534

return 0;

9535

}

9536

_ACEOF

9537

rm -f conftest.$ac_objext conftest$ac_exeext

9538

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9539

(eval $ac_link) 2>&5

9540

ac_status=$?

9541

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9542

(exit $ac_status); } &&

9543

{ ac_try='test -s conftest$ac_exeext'

9544

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9545

(eval $ac_try) 2>&5

9546

ac_status=$?

9547

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9548

(exit $ac_status); }; }; then

9549

eval "$as_ac_var=yes"

9550

else

9551

echo "$as_me: failed program was:" >&5

9552

sed 's/^/| /' conftest.$ac_ext >&5

9553

9554

eval "$as_ac_var=no"

9555

9556

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9557

9558

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9559

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9560

if test `eval echo '${'$as_ac_var'}'` = yes; then

9561

cat >>confdefs.h <<_ACEOF

9562

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9563

_ACEOF

9564

9565

else

9566

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

9567

9568

done

9569

9570

9571

if test $ac_cv_func_strdup = no; then

9572

9573

9574

9575

9576

9577

9578

9579

9580

9581

9582

9583

9584

9585

echo "$as_me:$LINENO: checking whether struct tm is in sys/time.h or time.h" >&5

9586

echo $ECHO_N "checking whether struct tm is in sys/time.h or time.h... $ECHO_C" >&6

9587

if test "${ac_cv_struct_tm+set}" = set; then

9588

echo $ECHO_N "(cached) $ECHO_C" >&6

9589

else

9590

cat >conftest.$ac_ext <<_ACEOF

9591

#line $LINENO "configure"

9592

/* confdefs.h. */

9593

_ACEOF

9594

cat confdefs.h >>conftest.$ac_ext

9595

cat >>conftest.$ac_ext <<_ACEOF

9596

/* end confdefs.h. */

9597

#include <sys/types.h>

9598

#include <time.h>

9599

9600

int

9601

main ()

9602

{

9603

struct tm *tp; tp->tm_sec;

9604

;

9605

return 0;

9606

}

9607

_ACEOF

9608

rm -f conftest.$ac_objext

9609

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

9610

(eval $ac_compile) 2>&5

9611

ac_status=$?

9612

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9613

(exit $ac_status); } &&

9614

{ ac_try='test -s conftest.$ac_objext'

9615

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9616

(eval $ac_try) 2>&5

9617

ac_status=$?

9618

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9619

(exit $ac_status); }; }; then

9620

ac_cv_struct_tm=time.h

9621

else

9622

echo "$as_me: failed program was:" >&5

9623

sed 's/^/| /' conftest.$ac_ext >&5

9624

9625

ac_cv_struct_tm=sys/time.h

9626

9627

rm -f conftest.$ac_objext conftest.$ac_ext

9628

9629

echo "$as_me:$LINENO: result: $ac_cv_struct_tm" >&5

9630

echo "${ECHO_T}$ac_cv_struct_tm" >&6

9631

if test $ac_cv_struct_tm = sys/time.h; then

9632

9633

cat >>confdefs.h <<\_ACEOF

9634

#define TM_IN_SYS_TIME 1

9635

_ACEOF

9636

9637

9638

9639

9640

echo "$as_me:$LINENO: checking for struct tm.tm_gmtoff" >&5

9641

echo $ECHO_N "checking for struct tm.tm_gmtoff... $ECHO_C" >&6

9642

if test "${ac_cv_member_struct_tm_tm_gmtoff+set}" = set; then

9643

echo $ECHO_N "(cached) $ECHO_C" >&6

9644

else

9645

cat >conftest.$ac_ext <<_ACEOF

9646

#line $LINENO "configure"

9647

/* confdefs.h. */

9648

_ACEOF

9649

cat confdefs.h >>conftest.$ac_ext

9650

cat >>conftest.$ac_ext <<_ACEOF

9651

/* end confdefs.h. */

9652

#include <time.h>

9653

9654

int

9655

main ()

9656

{

9657

static struct tm ac_aggr;

9658

if (ac_aggr.tm_gmtoff)

9659

return 0;

9660

;

9661

return 0;

9662

}

9663

_ACEOF

9664

rm -f conftest.$ac_objext

9665

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

9666

(eval $ac_compile) 2>&5

9667

ac_status=$?

9668

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9669

(exit $ac_status); } &&

9670

{ ac_try='test -s conftest.$ac_objext'

9671

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9672

(eval $ac_try) 2>&5

9673

ac_status=$?

9674

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9675

(exit $ac_status); }; }; then

9676

ac_cv_member_struct_tm_tm_gmtoff=yes

9677

else

9678

echo "$as_me: failed program was:" >&5

9679

sed 's/^/| /' conftest.$ac_ext >&5

9680

9681

cat >conftest.$ac_ext <<_ACEOF

9682

#line $LINENO "configure"

9683

/* confdefs.h. */

9684

_ACEOF

9685

cat confdefs.h >>conftest.$ac_ext

9686

cat >>conftest.$ac_ext <<_ACEOF

9687

/* end confdefs.h. */

9688

#include <time.h>

9689

9690

int

9691

main ()

9692

{

9693

static struct tm ac_aggr;

9694

if (sizeof ac_aggr.tm_gmtoff)

9695

return 0;

9696

;

9697

return 0;

9698

}

9699

_ACEOF

9700

rm -f conftest.$ac_objext

9701

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

9702

(eval $ac_compile) 2>&5

9703

ac_status=$?

9704

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9705

(exit $ac_status); } &&

9706

{ ac_try='test -s conftest.$ac_objext'

9707

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9708

(eval $ac_try) 2>&5

9709

ac_status=$?

9710

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9711

(exit $ac_status); }; }; then

9712

ac_cv_member_struct_tm_tm_gmtoff=yes

9713

else

9714

echo "$as_me: failed program was:" >&5

9715

sed 's/^/| /' conftest.$ac_ext >&5

9716

9717

ac_cv_member_struct_tm_tm_gmtoff=no

9718

9719

rm -f conftest.$ac_objext conftest.$ac_ext

9720

9721

rm -f conftest.$ac_objext conftest.$ac_ext

9722

9723

echo "$as_me:$LINENO: result: $ac_cv_member_struct_tm_tm_gmtoff" >&5

9724

echo "${ECHO_T}$ac_cv_member_struct_tm_tm_gmtoff" >&6

9725

if test $ac_cv_member_struct_tm_tm_gmtoff = yes; then

9726

9727

cat >>confdefs.h <<\_ACEOF

9728

#define HAVE_TM_GMTOFF 1

9729

_ACEOF

9730

9731

9732

9733

9734

echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5

9735

echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6

9736

if test "${ac_cv_c_const+set}" = set; then

9737

echo $ECHO_N "(cached) $ECHO_C" >&6

9738

else

9739

cat >conftest.$ac_ext <<_ACEOF

9740

#line $LINENO "configure"

9741

/* confdefs.h. */

9742

_ACEOF

9743

cat confdefs.h >>conftest.$ac_ext

9744

cat >>conftest.$ac_ext <<_ACEOF

9745

/* end confdefs.h. */

9746

9747

int

9748

main ()

9749

{

9750

/* FIXME: Include the comments suggested by Paul. */

9751

#ifndef __cplusplus

9752

/* Ultrix mips cc rejects this. */

9753

typedef int charset[2];

9754

const charset x;

9755

/* SunOS 4.1.1 cc rejects this. */

9756

char const *const *ccp;

9757

char **p;

9758

/* NEC SVR4.0.2 mips cc rejects this. */

9759

struct point {int x, y;};

9760

static struct point const zero = {0,0};

9761

/* AIX XL C 1.02.0.0 rejects this.

9762

It does not let you subtract one const X* pointer from another in

9763

an arm of an if-expression whose if-part is not a constant

9764

expression */

9765

const char *g = "string";

9766

ccp = &g + (g ? g-g : 0);

9767

/* HPUX 7.0 cc rejects these. */

9768

++ccp;

9769

p = (char**) ccp;

9770

ccp = (char const *const *) p;

9771

{ /* SCO 3.2v4 cc rejects this. */

9772

char *t;

9773

char const *s = 0 ? (char *) 0 : (char const *) 0;

9774

9775

*t++ = 0;

9776

}

9777

{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */

9778

int x[] = {25, 17};

9779

const int *foo = &x[0];

9780

++foo;

9781

}

9782

{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */

9783

typedef const int *iptr;

9784

iptr p = 0;

9785

++p;

9786

}

9787

{ /* AIX XL C 1.02.0.0 rejects this saying

9788

"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */

9789

struct s { int j; const int *ap[3]; };

9790

struct s *b; b->j = 5;

9791

}

9792

{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */

9793

const int foo = 10;

9794

}

9795

#endif

9796

9797

;

9798

return 0;

9799

}

9800

_ACEOF

9801

rm -f conftest.$ac_objext

9802

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

9803

(eval $ac_compile) 2>&5

9804

ac_status=$?

9805

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9806

(exit $ac_status); } &&

9807

{ ac_try='test -s conftest.$ac_objext'

9808

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9809

(eval $ac_try) 2>&5

9810

ac_status=$?

9811

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9812

(exit $ac_status); }; }; then

9813

ac_cv_c_const=yes

9814

else

9815

echo "$as_me: failed program was:" >&5

9816

sed 's/^/| /' conftest.$ac_ext >&5

9817

9818

ac_cv_c_const=no

9819

9820

rm -f conftest.$ac_objext conftest.$ac_ext

9821

9822

echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5

9823

echo "${ECHO_T}$ac_cv_c_const" >&6

9824

if test $ac_cv_c_const = no; then

9825

9826

cat >>confdefs.h <<\_ACEOF

9827

#define const

9828

_ACEOF

9829

9830

9831

9832

9833

9834

9835

9836

9837

9838

9839

9840

9841

for ac_func in strftime

9842

9843

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

9844

echo "$as_me:$LINENO: checking for $ac_func" >&5

9845

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

9846

if eval "test \"\${$as_ac_var+set}\" = set"; then

9847

echo $ECHO_N "(cached) $ECHO_C" >&6

9848

else

9849

cat >conftest.$ac_ext <<_ACEOF

9850

#line $LINENO "configure"

9851

/* confdefs.h. */

9852

_ACEOF

9853

cat confdefs.h >>conftest.$ac_ext

9854

cat >>conftest.$ac_ext <<_ACEOF

9855

/* end confdefs.h. */

9856

/* System header to define __stub macros and hopefully few prototypes,

9857

which can conflict with char $ac_func (); below.

9858

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

9859

<limits.h> exists even on freestanding compilers. */

9860

#ifdef __STDC__

9861

# include <limits.h>

9862

#else

9863

# include <assert.h>

9864

#endif

9865

/* Override any gcc2 internal prototype to avoid an error. */

9866

#ifdef __cplusplus

9867

extern "C"

9868

{

9869

#endif

9870

/* We use char because int might match the return type of a gcc2

9871

builtin and then its argument prototype would still apply. */

9872

char $ac_func ();

9873

/* The GNU C library defines this for functions which it implements

9874

to always fail with ENOSYS. Some functions are actually named

9875

something starting with __ and the normal name is an alias. */

9876

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

9877

choke me

9878

#else

9879

char (*f) () = $ac_func;

9880

#endif

9881

#ifdef __cplusplus

9882

}

9883

#endif

9884

9885

int

9886

main ()

9887

{

9888

return f != $ac_func;

9889

;

9890

return 0;

9891

}

9892

_ACEOF

9893

rm -f conftest.$ac_objext conftest$ac_exeext

9894

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9895

(eval $ac_link) 2>&5

9896

ac_status=$?

9897

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9898

(exit $ac_status); } &&

9899

{ ac_try='test -s conftest$ac_exeext'

9900

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9901

(eval $ac_try) 2>&5

9902

ac_status=$?

9903

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9904

(exit $ac_status); }; }; then

9905

eval "$as_ac_var=yes"

9906

else

9907

echo "$as_me: failed program was:" >&5

9908

sed 's/^/| /' conftest.$ac_ext >&5

9909

9910

eval "$as_ac_var=no"

9911

9912

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9913

9914

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9915

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9916

if test `eval echo '${'$as_ac_var'}'` = yes; then

9917

cat >>confdefs.h <<_ACEOF

9918

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9919

_ACEOF

9920

9921

else

9922

# strftime is in -lintl on SCO UNIX.

9923

echo "$as_me:$LINENO: checking for strftime in -lintl" >&5

9924

echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6

9925

if test "${ac_cv_lib_intl_strftime+set}" = set; then

9926

echo $ECHO_N "(cached) $ECHO_C" >&6

9927

else

9928

ac_check_lib_save_LIBS=$LIBS

9929

LIBS="-lintl $LIBS"

9930

cat >conftest.$ac_ext <<_ACEOF

9931

#line $LINENO "configure"

9932

/* confdefs.h. */

9933

_ACEOF

9934

cat confdefs.h >>conftest.$ac_ext

9935

cat >>conftest.$ac_ext <<_ACEOF

9936

/* end confdefs.h. */

9937

9938

/* Override any gcc2 internal prototype to avoid an error. */

9939

#ifdef __cplusplus

9940

extern "C"

9941

#endif

9942

/* We use char because int might match the return type of a gcc2

9943

builtin and then its argument prototype would still apply. */

9944

char strftime ();

9945

int

9946

main ()

9947

{

9948

strftime ();

9949

;

9950

return 0;

9951

}

9952

_ACEOF

9953

rm -f conftest.$ac_objext conftest$ac_exeext

9954

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9955

(eval $ac_link) 2>&5

9956

ac_status=$?

9957

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9958

(exit $ac_status); } &&

9959

{ ac_try='test -s conftest$ac_exeext'

9960

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9961

(eval $ac_try) 2>&5

9962

ac_status=$?

9963

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9964

(exit $ac_status); }; }; then

9965

ac_cv_lib_intl_strftime=yes

9966

else

9967

echo "$as_me: failed program was:" >&5

9968

sed 's/^/| /' conftest.$ac_ext >&5

9969

9970

ac_cv_lib_intl_strftime=no

9971

9972

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

9973

LIBS=$ac_check_lib_save_LIBS

9974

9975

echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5

9976

echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6

9977

if test $ac_cv_lib_intl_strftime = yes; then

9978

cat >>confdefs.h <<\_ACEOF

9979

#define HAVE_STRFTIME 1

9980

_ACEOF

9981

9982

LIBS="-lintl $LIBS"

9983

9984

9985

9986

done

9987

9988

9989

9990

9991

9992

9993

9994

9995

9996

9997

9998

9999

10000

10001

10002

10003

10004

10005

10006

10007

10008

for ac_func in tzset memset

10009

10010

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10011

echo "$as_me:$LINENO: checking for $ac_func" >&5

10012

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10013

if eval "test \"\${$as_ac_var+set}\" = set"; then

10014

echo $ECHO_N "(cached) $ECHO_C" >&6

10015

else

10016

cat >conftest.$ac_ext <<_ACEOF

10017

#line $LINENO "configure"

10018

/* confdefs.h. */

10019

_ACEOF

10020

cat confdefs.h >>conftest.$ac_ext

10021

cat >>conftest.$ac_ext <<_ACEOF

10022

/* end confdefs.h. */

10023

/* System header to define __stub macros and hopefully few prototypes,

10024

which can conflict with char $ac_func (); below.

10025

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10026

<limits.h> exists even on freestanding compilers. */

10027

#ifdef __STDC__

10028

# include <limits.h>

10029

#else

10030

# include <assert.h>

10031

#endif

10032

/* Override any gcc2 internal prototype to avoid an error. */

10033

#ifdef __cplusplus

10034

extern "C"

10035

{

10036

#endif

10037

/* We use char because int might match the return type of a gcc2

10038

builtin and then its argument prototype would still apply. */

10039

char $ac_func ();

10040

/* The GNU C library defines this for functions which it implements

10041

to always fail with ENOSYS. Some functions are actually named

10042

something starting with __ and the normal name is an alias. */

10043

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

10044

choke me

10045

#else

10046

char (*f) () = $ac_func;

10047

#endif

10048

#ifdef __cplusplus

10049

}

10050

#endif

10051

10052

int

10053

main ()

10054

{

10055

return f != $ac_func;

10056

;

10057

return 0;

10058

}

10059

_ACEOF

10060

rm -f conftest.$ac_objext conftest$ac_exeext

10061

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10062

(eval $ac_link) 2>&5

10063

ac_status=$?

10064

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10065

(exit $ac_status); } &&

10066

{ ac_try='test -s conftest$ac_exeext'

10067

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10068

(eval $ac_try) 2>&5

10069

ac_status=$?

10070

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10071

(exit $ac_status); }; }; then

10072

eval "$as_ac_var=yes"

10073

else

10074

echo "$as_me: failed program was:" >&5

10075

sed 's/^/| /' conftest.$ac_ext >&5

10076

10077

eval "$as_ac_var=no"

10078

10079

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10080

10081

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

10082

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

10083

if test `eval echo '${'$as_ac_var'}'` = yes; then

10084

cat >>confdefs.h <<_ACEOF

10085

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

10086

_ACEOF

10087

10088

10089

done

10090

10091

10092

# This defines (or not) HAVE_TZNAME and HAVE_TM_ZONE.

10093

echo "$as_me:$LINENO: checking for struct tm.tm_zone" >&5

10094

echo $ECHO_N "checking for struct tm.tm_zone... $ECHO_C" >&6

10095

if test "${ac_cv_member_struct_tm_tm_zone+set}" = set; then

10096

echo $ECHO_N "(cached) $ECHO_C" >&6

10097

else

10098

cat >conftest.$ac_ext <<_ACEOF

10099

#line $LINENO "configure"

10100

/* confdefs.h. */

10101

_ACEOF

10102

cat confdefs.h >>conftest.$ac_ext

10103

cat >>conftest.$ac_ext <<_ACEOF

10104

/* end confdefs.h. */

10105

#include <sys/types.h>

10106

#include <$ac_cv_struct_tm>

10107

10108

10109

int

10110

main ()

10111

{

10112

static struct tm ac_aggr;

10113

if (ac_aggr.tm_zone)

10114

return 0;

10115

;

10116

return 0;

10117

}

10118

_ACEOF

10119

rm -f conftest.$ac_objext

10120

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

10121

(eval $ac_compile) 2>&5

10122

ac_status=$?

10123

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10124

(exit $ac_status); } &&

10125

{ ac_try='test -s conftest.$ac_objext'

10126

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10127

(eval $ac_try) 2>&5

10128

ac_status=$?

10129

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10130

(exit $ac_status); }; }; then

10131

ac_cv_member_struct_tm_tm_zone=yes

10132

else

10133

echo "$as_me: failed program was:" >&5

10134

sed 's/^/| /' conftest.$ac_ext >&5

10135

10136

cat >conftest.$ac_ext <<_ACEOF

10137

#line $LINENO "configure"

10138

/* confdefs.h. */

10139

_ACEOF

10140

cat confdefs.h >>conftest.$ac_ext

10141

cat >>conftest.$ac_ext <<_ACEOF

10142

/* end confdefs.h. */

10143

#include <sys/types.h>

10144

#include <$ac_cv_struct_tm>

10145

10146

10147

int

10148

main ()

10149

{

10150

static struct tm ac_aggr;

10151

if (sizeof ac_aggr.tm_zone)

10152

return 0;

10153

;

10154

return 0;

10155

}

10156

_ACEOF

10157

rm -f conftest.$ac_objext

10158

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

10159

(eval $ac_compile) 2>&5

10160

ac_status=$?

10161

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10162

(exit $ac_status); } &&

10163

{ ac_try='test -s conftest.$ac_objext'

10164

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10165

(eval $ac_try) 2>&5

10166

ac_status=$?

10167

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10168

(exit $ac_status); }; }; then

10169

ac_cv_member_struct_tm_tm_zone=yes

10170

else

10171

echo "$as_me: failed program was:" >&5

10172

sed 's/^/| /' conftest.$ac_ext >&5

10173

10174

ac_cv_member_struct_tm_tm_zone=no

10175

10176

rm -f conftest.$ac_objext conftest.$ac_ext

10177

10178

rm -f conftest.$ac_objext conftest.$ac_ext

10179

10180

echo "$as_me:$LINENO: result: $ac_cv_member_struct_tm_tm_zone" >&5

10181

echo "${ECHO_T}$ac_cv_member_struct_tm_tm_zone" >&6

10182

if test $ac_cv_member_struct_tm_tm_zone = yes; then

10183

10184

cat >>confdefs.h <<_ACEOF

10185

#define HAVE_STRUCT_TM_TM_ZONE 1

10186

_ACEOF

10187

10188

10189

10190

10191

if test "$ac_cv_member_struct_tm_tm_zone" = yes; then

10192

10193

cat >>confdefs.h <<\_ACEOF

10194

#define HAVE_TM_ZONE 1

10195

_ACEOF

10196

10197

else

10198

echo "$as_me:$LINENO: checking for tzname" >&5

10199

echo $ECHO_N "checking for tzname... $ECHO_C" >&6

10200

if test "${ac_cv_var_tzname+set}" = set; then

10201

echo $ECHO_N "(cached) $ECHO_C" >&6

10202

else

10203

cat >conftest.$ac_ext <<_ACEOF

10204

#line $LINENO "configure"

10205

/* confdefs.h. */

10206

_ACEOF

10207

cat confdefs.h >>conftest.$ac_ext

10208

cat >>conftest.$ac_ext <<_ACEOF

10209

/* end confdefs.h. */

10210

#include <time.h>

10211

#ifndef tzname /* For SGI. */

10212

extern char *tzname[]; /* RS6000 and others reject char **tzname. */

10213

#endif

10214

10215

int

10216

main ()

10217

{

10218

atoi(*tzname);

10219

;

10220

return 0;

10221

}

10222

_ACEOF

10223

rm -f conftest.$ac_objext conftest$ac_exeext

10224

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10225

(eval $ac_link) 2>&5

10226

ac_status=$?

10227

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10228

(exit $ac_status); } &&

10229

{ ac_try='test -s conftest$ac_exeext'

10230

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10231

(eval $ac_try) 2>&5

10232

ac_status=$?

10233

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10234

(exit $ac_status); }; }; then

10235

ac_cv_var_tzname=yes

10236

else

10237

echo "$as_me: failed program was:" >&5

10238

sed 's/^/| /' conftest.$ac_ext >&5

10239

10240

ac_cv_var_tzname=no

10241

10242

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10243

10244

echo "$as_me:$LINENO: result: $ac_cv_var_tzname" >&5

10245

echo "${ECHO_T}$ac_cv_var_tzname" >&6

10246

if test $ac_cv_var_tzname = yes; then

10247

10248

cat >>confdefs.h <<\_ACEOF

10249

#define HAVE_TZNAME 1

10250

_ACEOF

10251

10252

10253

10254

10255

10256

10257

10258

for ac_func in mblen mbrlen

10259

10260

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10261

echo "$as_me:$LINENO: checking for $ac_func" >&5

10262

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10263

if eval "test \"\${$as_ac_var+set}\" = set"; then

10264

echo $ECHO_N "(cached) $ECHO_C" >&6

10265

else

10266

cat >conftest.$ac_ext <<_ACEOF

10267

#line $LINENO "configure"

10268

/* confdefs.h. */

10269

_ACEOF

10270

cat confdefs.h >>conftest.$ac_ext

10271

cat >>conftest.$ac_ext <<_ACEOF

10272

/* end confdefs.h. */

10273

/* System header to define __stub macros and hopefully few prototypes,

10274

which can conflict with char $ac_func (); below.

10275

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10276

<limits.h> exists even on freestanding compilers. */

10277

#ifdef __STDC__

10278

# include <limits.h>

10279

#else

10280

# include <assert.h>

10281

#endif

10282

/* Override any gcc2 internal prototype to avoid an error. */

10283

#ifdef __cplusplus

10284

extern "C"

10285

{

10286

#endif

10287

/* We use char because int might match the return type of a gcc2

10288

builtin and then its argument prototype would still apply. */

10289

char $ac_func ();

10290

/* The GNU C library defines this for functions which it implements

10291

to always fail with ENOSYS. Some functions are actually named

10292

something starting with __ and the normal name is an alias. */

10293

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

10294

choke me

10295

#else

10296

char (*f) () = $ac_func;

10297

#endif

10298

#ifdef __cplusplus

10299

}

10300

#endif

10301

10302

int

10303

main ()

10304

{

10305

return f != $ac_func;

10306

;

10307

return 0;

10308

}

10309

_ACEOF

10310

rm -f conftest.$ac_objext conftest$ac_exeext

10311

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10312

(eval $ac_link) 2>&5

10313

ac_status=$?

10314

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10315

(exit $ac_status); } &&

10316

{ ac_try='test -s conftest$ac_exeext'

10317

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10318

(eval $ac_try) 2>&5

10319

ac_status=$?

10320

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10321

(exit $ac_status); }; }; then

10322

eval "$as_ac_var=yes"

10323

else

10324

echo "$as_me: failed program was:" >&5

10325

sed 's/^/| /' conftest.$ac_ext >&5

10326

10327

eval "$as_ac_var=no"

10328

10329

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10330

10331

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

10332

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

10333

if test `eval echo '${'$as_ac_var'}'` = yes; then

10334

cat >>confdefs.h <<_ACEOF

10335

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

10336

_ACEOF

10337

10338

10339

done

10340

10341

echo "$as_me:$LINENO: checking for mbstate_t" >&5

10342

echo $ECHO_N "checking for mbstate_t... $ECHO_C" >&6

10343

if test "${ac_cv_type_mbstate_t+set}" = set; then

10344

echo $ECHO_N "(cached) $ECHO_C" >&6

10345

else

10346

cat >conftest.$ac_ext <<_ACEOF

10347

#line $LINENO "configure"

10348

/* confdefs.h. */

10349

_ACEOF

10350

cat confdefs.h >>conftest.$ac_ext

10351

cat >>conftest.$ac_ext <<_ACEOF

10352

/* end confdefs.h. */

10353

$ac_includes_default

10354

# include <wchar.h>

10355

int

10356

main ()

10357

{

10358

mbstate_t x; return sizeof x;

10359

;

10360

return 0;

10361

}

10362

_ACEOF

10363

rm -f conftest.$ac_objext

10364

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

10365

(eval $ac_compile) 2>&5

10366

ac_status=$?

10367

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10368

(exit $ac_status); } &&

10369

{ ac_try='test -s conftest.$ac_objext'

10370

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10371

(eval $ac_try) 2>&5

10372

ac_status=$?

10373

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10374

(exit $ac_status); }; }; then

10375

ac_cv_type_mbstate_t=yes

10376

else

10377

echo "$as_me: failed program was:" >&5

10378

sed 's/^/| /' conftest.$ac_ext >&5

10379

10380

ac_cv_type_mbstate_t=no

10381

10382

rm -f conftest.$ac_objext conftest.$ac_ext

10383

10384

echo "$as_me:$LINENO: result: $ac_cv_type_mbstate_t" >&5

10385

echo "${ECHO_T}$ac_cv_type_mbstate_t" >&6

10386

if test $ac_cv_type_mbstate_t = yes; then

10387

10388

cat >>confdefs.h <<\_ACEOF

10389

#define HAVE_MBSTATE_T 1

10390

_ACEOF

10391

10392

else

10393

10394

cat >>confdefs.h <<\_ACEOF

10395

#define mbstate_t int

10396

_ACEOF

10397

10398

10399

10400

10401

10402

10403

10404

10405

10406

10407

10408

10409

10410

10411

cat >>confdefs.h <<\_ACEOF

10412

#define my_strftime nstrftime

10413

_ACEOF

10414

10415

10416

10417

10418

10419

for ac_func in strstr

10420

10421

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10422

echo "$as_me:$LINENO: checking for $ac_func" >&5

10423

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10424

if eval "test \"\${$as_ac_var+set}\" = set"; then

10425

echo $ECHO_N "(cached) $ECHO_C" >&6

10426

else

10427

cat >conftest.$ac_ext <<_ACEOF

10428

#line $LINENO "configure"

10429

/* confdefs.h. */

10430

_ACEOF

10431

cat confdefs.h >>conftest.$ac_ext

10432

cat >>conftest.$ac_ext <<_ACEOF

10433

/* end confdefs.h. */

10434

/* System header to define __stub macros and hopefully few prototypes,

10435

which can conflict with char $ac_func (); below.

10436

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10437

<limits.h> exists even on freestanding compilers. */

10438

#ifdef __STDC__

10439

# include <limits.h>

10440

#else

10441

# include <assert.h>

10442

#endif

10443

/* Override any gcc2 internal prototype to avoid an error. */

10444

#ifdef __cplusplus

10445

extern "C"

10446

{

10447

#endif

10448

/* We use char because int might match the return type of a gcc2

10449

builtin and then its argument prototype would still apply. */

10450

char $ac_func ();

10451

/* The GNU C library defines this for functions which it implements

10452

to always fail with ENOSYS. Some functions are actually named

10453

something starting with __ and the normal name is an alias. */

10454

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

10455

choke me

10456

#else

10457

char (*f) () = $ac_func;

10458

#endif

10459

#ifdef __cplusplus

10460

}

10461

#endif

10462

10463

int

10464

main ()

10465

{

10466

return f != $ac_func;

10467

;

10468

return 0;

10469

}

10470

_ACEOF

10471

rm -f conftest.$ac_objext conftest$ac_exeext

10472

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10473

(eval $ac_link) 2>&5

10474

ac_status=$?

10475

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10476

(exit $ac_status); } &&

10477

{ ac_try='test -s conftest$ac_exeext'

10478

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10479

(eval $ac_try) 2>&5

10480

ac_status=$?

10481

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10482

(exit $ac_status); }; }; then

10483

eval "$as_ac_var=yes"

10484

else

10485

echo "$as_me: failed program was:" >&5

10486

sed 's/^/| /' conftest.$ac_ext >&5

10487

10488

eval "$as_ac_var=no"

10489

10490

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10491

10492

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

10493

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

10494

if test `eval echo '${'$as_ac_var'}'` = yes; then

10495

cat >>confdefs.h <<_ACEOF

10496

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

10497

_ACEOF

10498

10499

else

10500

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

10501

10502

done

10503

10504

10505

if test $ac_cv_func_strstr = no; then

10506

10507

10508

10509

10510

10511

10512

10513

10514

10515

10516

10517

10518

10519

echo "$as_me:$LINENO: checking for long long" >&5

10520

echo $ECHO_N "checking for long long... $ECHO_C" >&6

10521

if test "${ac_cv_type_long_long+set}" = set; then

10522

echo $ECHO_N "(cached) $ECHO_C" >&6

10523

else

10524

cat >conftest.$ac_ext <<_ACEOF

10525

#line $LINENO "configure"

10526

/* confdefs.h. */

10527

_ACEOF

10528

cat confdefs.h >>conftest.$ac_ext

10529

cat >>conftest.$ac_ext <<_ACEOF

10530

/* end confdefs.h. */

10531

long long ll = 1LL; int i = 63;

10532

int

10533

main ()

10534

{

10535

long long llmax = (long long) -1;

10536

return ll << i | ll >> i | llmax / ll | llmax % ll;

10537

;

10538

return 0;

10539

}

10540

_ACEOF

10541

rm -f conftest.$ac_objext conftest$ac_exeext

10542

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10543

(eval $ac_link) 2>&5

10544

ac_status=$?

10545

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10546

(exit $ac_status); } &&

10547

{ ac_try='test -s conftest$ac_exeext'

10548

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10549

(eval $ac_try) 2>&5

10550

ac_status=$?

10551

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10552

(exit $ac_status); }; }; then

10553

ac_cv_type_long_long=yes

10554

else

10555

echo "$as_me: failed program was:" >&5

10556

sed 's/^/| /' conftest.$ac_ext >&5

10557

10558

ac_cv_type_long_long=no

10559

10560

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10561

10562

echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5

10563

echo "${ECHO_T}$ac_cv_type_long_long" >&6

10564

if test $ac_cv_type_long_long = yes; then

10565

10566

cat >>confdefs.h <<\_ACEOF

10567

#define HAVE_LONG_LONG 1

10568

_ACEOF

10569

10570

10571

10572

10573

echo "$as_me:$LINENO: checking whether strtol is declared" >&5

10574

echo $ECHO_N "checking whether strtol is declared... $ECHO_C" >&6

10575

if test "${ac_cv_have_decl_strtol+set}" = set; then

10576

echo $ECHO_N "(cached) $ECHO_C" >&6

10577

else

10578

cat >conftest.$ac_ext <<_ACEOF

10579

#line $LINENO "configure"

10580

/* confdefs.h. */

10581

_ACEOF

10582

cat confdefs.h >>conftest.$ac_ext

10583

cat >>conftest.$ac_ext <<_ACEOF

10584

/* end confdefs.h. */

10585

$ac_includes_default

10586

int

10587

main ()

10588

{

10589

#ifndef strtol

10590

char *p = (char *) strtol;

10591

#endif

10592

10593

;

10594

return 0;

10595

}

10596

_ACEOF

10597

rm -f conftest.$ac_objext

10598

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

10599

(eval $ac_compile) 2>&5

10600

ac_status=$?

10601

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10602

(exit $ac_status); } &&

10603

{ ac_try='test -s conftest.$ac_objext'

10604

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10605

(eval $ac_try) 2>&5

10606

ac_status=$?

10607

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10608

(exit $ac_status); }; }; then

10609

ac_cv_have_decl_strtol=yes

10610

else

10611

echo "$as_me: failed program was:" >&5

10612

sed 's/^/| /' conftest.$ac_ext >&5

10613

10614

ac_cv_have_decl_strtol=no

10615

10616

rm -f conftest.$ac_objext conftest.$ac_ext

10617

10618

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtol" >&5

10619

echo "${ECHO_T}$ac_cv_have_decl_strtol" >&6

10620

if test $ac_cv_have_decl_strtol = yes; then

10621

10622

cat >>confdefs.h <<_ACEOF

10623

#define HAVE_DECL_STRTOL 1

10624

_ACEOF

10625

10626

10627

else

10628

cat >>confdefs.h <<_ACEOF

10629

#define HAVE_DECL_STRTOL 0

10630

_ACEOF

10631

10632

10633

10634

10635

10636

10637

10638

10639

10640

10641

echo "$as_me:$LINENO: checking whether <inttypes.h> defines strtoimax as a macro" >&5

10642

echo $ECHO_N "checking whether <inttypes.h> defines strtoimax as a macro... $ECHO_C" >&6

10643

if test "${jm_cv_func_strtoimax_macro+set}" = set; then

10644

echo $ECHO_N "(cached) $ECHO_C" >&6

10645

else

10646

cat >conftest.$ac_ext <<_ACEOF

10647

#line $LINENO "configure"

10648

/* confdefs.h. */

10649

_ACEOF

10650

cat confdefs.h >>conftest.$ac_ext

10651

cat >>conftest.$ac_ext <<_ACEOF

10652

/* end confdefs.h. */

10653

#include <inttypes.h>

10654

#ifdef strtoimax

10655

inttypes_h_defines_strtoimax

10656

#endif

10657

_ACEOF

10658

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

10659

$EGREP "inttypes_h_defines_strtoimax" >/dev/null 2>&1; then

10660

jm_cv_func_strtoimax_macro=yes

10661

else

10662

jm_cv_func_strtoimax_macro=no

10663

10664

rm -f conftest*

10665

10666

10667

echo "$as_me:$LINENO: result: $jm_cv_func_strtoimax_macro" >&5

10668

echo "${ECHO_T}$jm_cv_func_strtoimax_macro" >&6

10669

10670

if test "$jm_cv_func_strtoimax_macro" != yes; then

10671

10672

for ac_func in strtoimax

10673

10674

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10675

echo "$as_me:$LINENO: checking for $ac_func" >&5

10676

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10677

if eval "test \"\${$as_ac_var+set}\" = set"; then

10678

echo $ECHO_N "(cached) $ECHO_C" >&6

10679

else

10680

cat >conftest.$ac_ext <<_ACEOF

10681

#line $LINENO "configure"

10682

/* confdefs.h. */

10683

_ACEOF

10684

cat confdefs.h >>conftest.$ac_ext

10685

cat >>conftest.$ac_ext <<_ACEOF

10686

/* end confdefs.h. */

10687

/* System header to define __stub macros and hopefully few prototypes,

10688

which can conflict with char $ac_func (); below.

10689

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10690

<limits.h> exists even on freestanding compilers. */

10691

#ifdef __STDC__

10692

# include <limits.h>

10693

#else

10694

# include <assert.h>

10695

#endif

10696

/* Override any gcc2 internal prototype to avoid an error. */

10697

#ifdef __cplusplus

10698

extern "C"

10699

{

10700

#endif

10701

/* We use char because int might match the return type of a gcc2

10702

builtin and then its argument prototype would still apply. */

10703

char $ac_func ();

10704

/* The GNU C library defines this for functions which it implements

10705

to always fail with ENOSYS. Some functions are actually named

10706

something starting with __ and the normal name is an alias. */

10707

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

10708

choke me

10709

#else

10710

char (*f) () = $ac_func;

10711

#endif

10712

#ifdef __cplusplus

10713

}

10714

#endif

10715

10716

int

10717

main ()

10718

{

10719

return f != $ac_func;

10720

;

10721

return 0;

10722

}

10723

_ACEOF

10724

rm -f conftest.$ac_objext conftest$ac_exeext

10725

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10726

(eval $ac_link) 2>&5

10727

ac_status=$?

10728

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10729

(exit $ac_status); } &&

10730

{ ac_try='test -s conftest$ac_exeext'

10731

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10732

(eval $ac_try) 2>&5

10733

ac_status=$?

10734

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10735

(exit $ac_status); }; }; then

10736

eval "$as_ac_var=yes"

10737

else

10738

echo "$as_me: failed program was:" >&5

10739

sed 's/^/| /' conftest.$ac_ext >&5

10740

10741

eval "$as_ac_var=no"

10742

10743

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10744

10745

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

10746

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

10747

if test `eval echo '${'$as_ac_var'}'` = yes; then

10748

cat >>confdefs.h <<_ACEOF

10749

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

10750

_ACEOF

10751

10752

else

10753

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

10754

10755

done

10756

10757

10758

if test $ac_cv_func_strtoimax = no; then

10759

10760

10761

10762

10763

if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then

10764

10765

test $ac_cv_type_long_long = yes \

10766

&& ac_type='long long' \

10767

|| ac_type='long'

10768

10769

cat >>confdefs.h <<_ACEOF

10770

#define intmax_t $ac_type

10771

_ACEOF

10772

10773

else

10774

10775

cat >>confdefs.h <<\_ACEOF

10776

#define HAVE_INTMAX_T 1

10777

_ACEOF

10778

10779

10780

10781

10782

10783

10784

10785

10786

10787

10788

10789

10790

10791

10792

10793

10794

10795

echo "$as_me:$LINENO: checking whether strtoll is declared" >&5

10796

echo $ECHO_N "checking whether strtoll is declared... $ECHO_C" >&6

10797

if test "${ac_cv_have_decl_strtoll+set}" = set; then

10798

echo $ECHO_N "(cached) $ECHO_C" >&6

10799

else

10800

cat >conftest.$ac_ext <<_ACEOF

10801

#line $LINENO "configure"

10802

/* confdefs.h. */

10803

_ACEOF

10804

cat confdefs.h >>conftest.$ac_ext

10805

cat >>conftest.$ac_ext <<_ACEOF

10806

/* end confdefs.h. */

10807

$ac_includes_default

10808

int

10809

main ()

10810

{

10811

#ifndef strtoll

10812

char *p = (char *) strtoll;

10813

#endif

10814

10815

;

10816

return 0;

10817

}

10818

_ACEOF

10819

rm -f conftest.$ac_objext

10820

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

10821

(eval $ac_compile) 2>&5

10822

ac_status=$?

10823

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10824

(exit $ac_status); } &&

10825

{ ac_try='test -s conftest.$ac_objext'

10826

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10827

(eval $ac_try) 2>&5

10828

ac_status=$?

10829

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10830

(exit $ac_status); }; }; then

10831

ac_cv_have_decl_strtoll=yes

10832

else

10833

echo "$as_me: failed program was:" >&5

10834

sed 's/^/| /' conftest.$ac_ext >&5

10835

10836

ac_cv_have_decl_strtoll=no

10837

10838

rm -f conftest.$ac_objext conftest.$ac_ext

10839

10840

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtoll" >&5

10841

echo "${ECHO_T}$ac_cv_have_decl_strtoll" >&6

10842

if test $ac_cv_have_decl_strtoll = yes; then

10843

10844

cat >>confdefs.h <<_ACEOF

10845

#define HAVE_DECL_STRTOLL 1

10846

_ACEOF

10847

10848

10849

else

10850

cat >>confdefs.h <<_ACEOF

10851

#define HAVE_DECL_STRTOLL 0

10852

_ACEOF

10853

10854

10855

10856

10857

10858

10859

10860

10861

10862

10863

10864

10865

10866

for ac_func in strtol

10867

10868

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10869

echo "$as_me:$LINENO: checking for $ac_func" >&5

10870

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10871

if eval "test \"\${$as_ac_var+set}\" = set"; then

10872

echo $ECHO_N "(cached) $ECHO_C" >&6

10873

else

10874

cat >conftest.$ac_ext <<_ACEOF

10875

#line $LINENO "configure"

10876

/* confdefs.h. */

10877

_ACEOF

10878

cat confdefs.h >>conftest.$ac_ext

10879

cat >>conftest.$ac_ext <<_ACEOF

10880

/* end confdefs.h. */

10881

/* System header to define __stub macros and hopefully few prototypes,

10882

which can conflict with char $ac_func (); below.

10883

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10884

<limits.h> exists even on freestanding compilers. */

10885

#ifdef __STDC__

10886

# include <limits.h>

10887

#else

10888

# include <assert.h>

10889

#endif

10890

/* Override any gcc2 internal prototype to avoid an error. */

10891

#ifdef __cplusplus

10892

extern "C"

10893

{

10894

#endif

10895

/* We use char because int might match the return type of a gcc2

10896

builtin and then its argument prototype would still apply. */

10897

char $ac_func ();

10898

/* The GNU C library defines this for functions which it implements

10899

to always fail with ENOSYS. Some functions are actually named

10900

something starting with __ and the normal name is an alias. */

10901

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

10902

choke me

10903

#else

10904

char (*f) () = $ac_func;

10905

#endif

10906

#ifdef __cplusplus

10907

}

10908

#endif

10909

10910

int

10911

main ()

10912

{

10913

return f != $ac_func;

10914

;

10915

return 0;

10916

}

10917

_ACEOF

10918

rm -f conftest.$ac_objext conftest$ac_exeext

10919

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

10920

(eval $ac_link) 2>&5

10921

ac_status=$?

10922

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10923

(exit $ac_status); } &&

10924

{ ac_try='test -s conftest$ac_exeext'

10925

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

10926

(eval $ac_try) 2>&5

10927

ac_status=$?

10928

echo "$as_me:$LINENO: \$? = $ac_status" >&5

10929

(exit $ac_status); }; }; then

10930

eval "$as_ac_var=yes"

10931

else

10932

echo "$as_me: failed program was:" >&5

10933

sed 's/^/| /' conftest.$ac_ext >&5

10934

10935

eval "$as_ac_var=no"

10936

10937

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

10938

10939

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

10940

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

10941

if test `eval echo '${'$as_ac_var'}'` = yes; then

10942

cat >>confdefs.h <<_ACEOF

10943

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

10944

_ACEOF

10945

10946

else

10947

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

10948

10949

done

10950

10951

10952

if test $ac_cv_func_strtol = no; then

10953

10954

10955

10956

10957

10958

10959

10960

10961

10962

10963

10964

10965

10966

10967

10968

10969

10970

10971

10972

10973

10974

10975

if test "$ac_cv_type_long_long" = yes; then

10976

10977

for ac_func in strtoll

10978

10979

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

10980

echo "$as_me:$LINENO: checking for $ac_func" >&5

10981

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

10982

if eval "test \"\${$as_ac_var+set}\" = set"; then

10983

echo $ECHO_N "(cached) $ECHO_C" >&6

10984

else

10985

cat >conftest.$ac_ext <<_ACEOF

10986

#line $LINENO "configure"

10987

/* confdefs.h. */

10988

_ACEOF

10989

cat confdefs.h >>conftest.$ac_ext

10990

cat >>conftest.$ac_ext <<_ACEOF

10991

/* end confdefs.h. */

10992

/* System header to define __stub macros and hopefully few prototypes,

10993

which can conflict with char $ac_func (); below.

10994

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

10995

<limits.h> exists even on freestanding compilers. */

10996

#ifdef __STDC__

10997

# include <limits.h>

10998

#else

10999

# include <assert.h>

11000

#endif

11001

/* Override any gcc2 internal prototype to avoid an error. */

11002

#ifdef __cplusplus

11003

extern "C"

11004

{

11005

#endif

11006

/* We use char because int might match the return type of a gcc2

11007

builtin and then its argument prototype would still apply. */

11008

char $ac_func ();

11009

/* The GNU C library defines this for functions which it implements

11010

to always fail with ENOSYS. Some functions are actually named

11011

something starting with __ and the normal name is an alias. */

11012

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

11013

choke me

11014

#else

11015

char (*f) () = $ac_func;

11016

#endif

11017

#ifdef __cplusplus

11018

}

11019

#endif

11020

11021

int

11022

main ()

11023

{

11024

return f != $ac_func;

11025

;

11026

return 0;

11027

}

11028

_ACEOF

11029

rm -f conftest.$ac_objext conftest$ac_exeext

11030

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

11031

(eval $ac_link) 2>&5

11032

ac_status=$?

11033

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11034

(exit $ac_status); } &&

11035

{ ac_try='test -s conftest$ac_exeext'

11036

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11037

(eval $ac_try) 2>&5

11038

ac_status=$?

11039

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11040

(exit $ac_status); }; }; then

11041

eval "$as_ac_var=yes"

11042

else

11043

echo "$as_me: failed program was:" >&5

11044

sed 's/^/| /' conftest.$ac_ext >&5

11045

11046

eval "$as_ac_var=no"

11047

11048

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

11049

11050

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

11051

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

11052

if test `eval echo '${'$as_ac_var'}'` = yes; then

11053

cat >>confdefs.h <<_ACEOF

11054

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

11055

_ACEOF

11056

11057

else

11058

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

11059

11060

done

11061

11062

11063

if test $ac_cv_func_strtoll = no; then

11064

11065

11066

11067

11068

11069

11070

11071

11072

11073

for ac_func in strtoul

11074

11075

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

11076

echo "$as_me:$LINENO: checking for $ac_func" >&5

11077

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

11078

if eval "test \"\${$as_ac_var+set}\" = set"; then

11079

echo $ECHO_N "(cached) $ECHO_C" >&6

11080

else

11081

cat >conftest.$ac_ext <<_ACEOF

11082

#line $LINENO "configure"

11083

/* confdefs.h. */

11084

_ACEOF

11085

cat confdefs.h >>conftest.$ac_ext

11086

cat >>conftest.$ac_ext <<_ACEOF

11087

/* end confdefs.h. */

11088

/* System header to define __stub macros and hopefully few prototypes,

11089

which can conflict with char $ac_func (); below.

11090

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

11091

<limits.h> exists even on freestanding compilers. */

11092

#ifdef __STDC__

11093

# include <limits.h>

11094

#else

11095

# include <assert.h>

11096

#endif

11097

/* Override any gcc2 internal prototype to avoid an error. */

11098

#ifdef __cplusplus

11099

extern "C"

11100

{

11101

#endif

11102

/* We use char because int might match the return type of a gcc2

11103

builtin and then its argument prototype would still apply. */

11104

char $ac_func ();

11105

/* The GNU C library defines this for functions which it implements

11106

to always fail with ENOSYS. Some functions are actually named

11107

something starting with __ and the normal name is an alias. */

11108

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

11109

choke me

11110

#else

11111

char (*f) () = $ac_func;

11112

#endif

11113

#ifdef __cplusplus

11114

}

11115

#endif

11116

11117

int

11118

main ()

11119

{

11120

return f != $ac_func;

11121

;

11122

return 0;

11123

}

11124

_ACEOF

11125

rm -f conftest.$ac_objext conftest$ac_exeext

11126

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

11127

(eval $ac_link) 2>&5

11128

ac_status=$?

11129

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11130

(exit $ac_status); } &&

11131

{ ac_try='test -s conftest$ac_exeext'

11132

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11133

(eval $ac_try) 2>&5

11134

ac_status=$?

11135

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11136

(exit $ac_status); }; }; then

11137

eval "$as_ac_var=yes"

11138

else

11139

echo "$as_me: failed program was:" >&5

11140

sed 's/^/| /' conftest.$ac_ext >&5

11141

11142

eval "$as_ac_var=no"

11143

11144

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

11145

11146

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

11147

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

11148

if test `eval echo '${'$as_ac_var'}'` = yes; then

11149

cat >>confdefs.h <<_ACEOF

11150

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

11151

_ACEOF

11152

11153

else

11154

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

11155

11156

done

11157

11158

11159

if test $ac_cv_func_strtoul = no; then

11160

11161

11162

11163

11164

11165

11166

11167

11168

11169

11170

11171

11172

11173

11174

11175

11176

11177

11178

11179

11180

11181

11182

11183

11184

if test "$ac_cv_type_unsigned_long_long" = yes; then

11185

11186

for ac_func in strtoull

11187

11188

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

11189

echo "$as_me:$LINENO: checking for $ac_func" >&5

11190

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

11191

if eval "test \"\${$as_ac_var+set}\" = set"; then

11192

echo $ECHO_N "(cached) $ECHO_C" >&6

11193

else

11194

cat >conftest.$ac_ext <<_ACEOF

11195

#line $LINENO "configure"

11196

/* confdefs.h. */

11197

_ACEOF

11198

cat confdefs.h >>conftest.$ac_ext

11199

cat >>conftest.$ac_ext <<_ACEOF

11200

/* end confdefs.h. */

11201

/* System header to define __stub macros and hopefully few prototypes,

11202

which can conflict with char $ac_func (); below.

11203

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

11204

<limits.h> exists even on freestanding compilers. */

11205

#ifdef __STDC__

11206

# include <limits.h>

11207

#else

11208

# include <assert.h>

11209

#endif

11210

/* Override any gcc2 internal prototype to avoid an error. */

11211

#ifdef __cplusplus

11212

extern "C"

11213

{

11214

#endif

11215

/* We use char because int might match the return type of a gcc2

11216

builtin and then its argument prototype would still apply. */

11217

char $ac_func ();

11218

/* The GNU C library defines this for functions which it implements

11219

to always fail with ENOSYS. Some functions are actually named

11220

something starting with __ and the normal name is an alias. */

11221

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

11222

choke me

11223

#else

11224

char (*f) () = $ac_func;

11225

#endif

11226

#ifdef __cplusplus

11227

}

11228

#endif

11229

11230

int

11231

main ()

11232

{

11233

return f != $ac_func;

11234

;

11235

return 0;

11236

}

11237

_ACEOF

11238

rm -f conftest.$ac_objext conftest$ac_exeext

11239

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

11240

(eval $ac_link) 2>&5

11241

ac_status=$?

11242

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11243

(exit $ac_status); } &&

11244

{ ac_try='test -s conftest$ac_exeext'

11245

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11246

(eval $ac_try) 2>&5

11247

ac_status=$?

11248

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11249

(exit $ac_status); }; }; then

11250

eval "$as_ac_var=yes"

11251

else

11252

echo "$as_me: failed program was:" >&5

11253

sed 's/^/| /' conftest.$ac_ext >&5

11254

11255

eval "$as_ac_var=no"

11256

11257

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

11258

11259

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

11260

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

11261

if test `eval echo '${'$as_ac_var'}'` = yes; then

11262

cat >>confdefs.h <<_ACEOF

11263

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

11264

_ACEOF

11265

11266

else

11267

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

11268

11269

done

11270

11271

11272

if test $ac_cv_func_strtoull = no; then

11273

11274

11275

11276

11277

11278

11279

11280

11281

echo "$as_me:$LINENO: checking whether strtoul is declared" >&5

11282

echo $ECHO_N "checking whether strtoul is declared... $ECHO_C" >&6

11283

if test "${ac_cv_have_decl_strtoul+set}" = set; then

11284

echo $ECHO_N "(cached) $ECHO_C" >&6

11285

else

11286

cat >conftest.$ac_ext <<_ACEOF

11287

#line $LINENO "configure"

11288

/* confdefs.h. */

11289

_ACEOF

11290

cat confdefs.h >>conftest.$ac_ext

11291

cat >>conftest.$ac_ext <<_ACEOF

11292

/* end confdefs.h. */

11293

$ac_includes_default

11294

int

11295

main ()

11296

{

11297

#ifndef strtoul

11298

char *p = (char *) strtoul;

11299

#endif

11300

11301

;

11302

return 0;

11303

}

11304

_ACEOF

11305

rm -f conftest.$ac_objext

11306

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11307

(eval $ac_compile) 2>&5

11308

ac_status=$?

11309

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11310

(exit $ac_status); } &&

11311

{ ac_try='test -s conftest.$ac_objext'

11312

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11313

(eval $ac_try) 2>&5

11314

ac_status=$?

11315

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11316

(exit $ac_status); }; }; then

11317

ac_cv_have_decl_strtoul=yes

11318

else

11319

echo "$as_me: failed program was:" >&5

11320

sed 's/^/| /' conftest.$ac_ext >&5

11321

11322

ac_cv_have_decl_strtoul=no

11323

11324

rm -f conftest.$ac_objext conftest.$ac_ext

11325

11326

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtoul" >&5

11327

echo "${ECHO_T}$ac_cv_have_decl_strtoul" >&6

11328

if test $ac_cv_have_decl_strtoul = yes; then

11329

11330

cat >>confdefs.h <<_ACEOF

11331

#define HAVE_DECL_STRTOUL 1

11332

_ACEOF

11333

11334

11335

else

11336

cat >>confdefs.h <<_ACEOF

11337

#define HAVE_DECL_STRTOUL 0

11338

_ACEOF

11339

11340

11341

11342

11343

11344

11345

11346

11347

11348

11349

echo "$as_me:$LINENO: checking whether <inttypes.h> defines strtoumax as a macro" >&5

11350

echo $ECHO_N "checking whether <inttypes.h> defines strtoumax as a macro... $ECHO_C" >&6

11351

if test "${jm_cv_func_strtoumax_macro+set}" = set; then

11352

echo $ECHO_N "(cached) $ECHO_C" >&6

11353

else

11354

cat >conftest.$ac_ext <<_ACEOF

11355

#line $LINENO "configure"

11356

/* confdefs.h. */

11357

_ACEOF

11358

cat confdefs.h >>conftest.$ac_ext

11359

cat >>conftest.$ac_ext <<_ACEOF

11360

/* end confdefs.h. */

11361

#include <inttypes.h>

11362

#ifdef strtoumax

11363

inttypes_h_defines_strtoumax

11364

#endif

11365

_ACEOF

11366

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

11367

$EGREP "inttypes_h_defines_strtoumax" >/dev/null 2>&1; then

11368

jm_cv_func_strtoumax_macro=yes

11369

else

11370

jm_cv_func_strtoumax_macro=no

11371

11372

rm -f conftest*

11373

11374

11375

echo "$as_me:$LINENO: result: $jm_cv_func_strtoumax_macro" >&5

11376

echo "${ECHO_T}$jm_cv_func_strtoumax_macro" >&6

11377

11378

if test "$jm_cv_func_strtoumax_macro" != yes; then

11379

11380

for ac_func in strtoumax

11381

11382

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

11383

echo "$as_me:$LINENO: checking for $ac_func" >&5

11384

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

11385

if eval "test \"\${$as_ac_var+set}\" = set"; then

11386

echo $ECHO_N "(cached) $ECHO_C" >&6

11387

else

11388

cat >conftest.$ac_ext <<_ACEOF

11389

#line $LINENO "configure"

11390

/* confdefs.h. */

11391

_ACEOF

11392

cat confdefs.h >>conftest.$ac_ext

11393

cat >>conftest.$ac_ext <<_ACEOF

11394

/* end confdefs.h. */

11395

/* System header to define __stub macros and hopefully few prototypes,

11396

which can conflict with char $ac_func (); below.

11397

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

11398

<limits.h> exists even on freestanding compilers. */

11399

#ifdef __STDC__

11400

# include <limits.h>

11401

#else

11402

# include <assert.h>

11403

#endif

11404

/* Override any gcc2 internal prototype to avoid an error. */

11405

#ifdef __cplusplus

11406

extern "C"

11407

{

11408

#endif

11409

/* We use char because int might match the return type of a gcc2

11410

builtin and then its argument prototype would still apply. */

11411

char $ac_func ();

11412

/* The GNU C library defines this for functions which it implements

11413

to always fail with ENOSYS. Some functions are actually named

11414

something starting with __ and the normal name is an alias. */

11415

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

11416

choke me

11417

#else

11418

char (*f) () = $ac_func;

11419

#endif

11420

#ifdef __cplusplus

11421

}

11422

#endif

11423

11424

int

11425

main ()

11426

{

11427

return f != $ac_func;

11428

;

11429

return 0;

11430

}

11431

_ACEOF

11432

rm -f conftest.$ac_objext conftest$ac_exeext

11433

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

11434

(eval $ac_link) 2>&5

11435

ac_status=$?

11436

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11437

(exit $ac_status); } &&

11438

{ ac_try='test -s conftest$ac_exeext'

11439

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11440

(eval $ac_try) 2>&5

11441

ac_status=$?

11442

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11443

(exit $ac_status); }; }; then

11444

eval "$as_ac_var=yes"

11445

else

11446

echo "$as_me: failed program was:" >&5

11447

sed 's/^/| /' conftest.$ac_ext >&5

11448

11449

eval "$as_ac_var=no"

11450

11451

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

11452

11453

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

11454

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

11455

if test `eval echo '${'$as_ac_var'}'` = yes; then

11456

cat >>confdefs.h <<_ACEOF

11457

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

11458

_ACEOF

11459

11460

else

11461

LIBOBJS="$LIBOBJS $ac_func.$ac_objext"

11462

11463

done

11464

11465

11466

if test $ac_cv_func_strtoumax = no; then

11467

11468

11469

11470

11471

if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then

11472

11473

test $ac_cv_type_unsigned_long_long = yes \

11474

&& ac_type='unsigned long long' \

11475

|| ac_type='unsigned long'

11476

11477

cat >>confdefs.h <<_ACEOF

11478

#define uintmax_t $ac_type

11479

_ACEOF

11480

11481

else

11482

11483

cat >>confdefs.h <<\_ACEOF

11484

#define HAVE_UINTMAX_T 1

11485

_ACEOF

11486

11487

11488

11489

11490

11491

11492

11493

11494

11495

11496

11497

11498

11499

11500

11501

11502

11503

echo "$as_me:$LINENO: checking whether strtoull is declared" >&5

11504

echo $ECHO_N "checking whether strtoull is declared... $ECHO_C" >&6

11505

if test "${ac_cv_have_decl_strtoull+set}" = set; then

11506

echo $ECHO_N "(cached) $ECHO_C" >&6

11507

else

11508

cat >conftest.$ac_ext <<_ACEOF

11509

#line $LINENO "configure"

11510

/* confdefs.h. */

11511

_ACEOF

11512

cat confdefs.h >>conftest.$ac_ext

11513

cat >>conftest.$ac_ext <<_ACEOF

11514

/* end confdefs.h. */

11515

$ac_includes_default

11516

int

11517

main ()

11518

{

11519

#ifndef strtoull

11520

char *p = (char *) strtoull;

11521

#endif

11522

11523

;

11524

return 0;

11525

}

11526

_ACEOF

11527

rm -f conftest.$ac_objext

11528

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11529

(eval $ac_compile) 2>&5

11530

ac_status=$?

11531

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11532

(exit $ac_status); } &&

11533

{ ac_try='test -s conftest.$ac_objext'

11534

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11535

(eval $ac_try) 2>&5

11536

ac_status=$?

11537

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11538

(exit $ac_status); }; }; then

11539

ac_cv_have_decl_strtoull=yes

11540

else

11541

echo "$as_me: failed program was:" >&5

11542

sed 's/^/| /' conftest.$ac_ext >&5

11543

11544

ac_cv_have_decl_strtoull=no

11545

11546

rm -f conftest.$ac_objext conftest.$ac_ext

11547

11548

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtoull" >&5

11549

echo "${ECHO_T}$ac_cv_have_decl_strtoull" >&6

11550

if test $ac_cv_have_decl_strtoull = yes; then

11551

11552

cat >>confdefs.h <<_ACEOF

11553

#define HAVE_DECL_STRTOULL 1

11554

_ACEOF

11555

11556

11557

else

11558

cat >>confdefs.h <<_ACEOF

11559

#define HAVE_DECL_STRTOULL 0

11560

_ACEOF

11561

11562

11563

11564

11565

11566

11567

11568

11569

11570

11571

11572

11573

echo "$as_me:$LINENO: checking whether clearerr_unlocked is declared" >&5

11574

echo $ECHO_N "checking whether clearerr_unlocked is declared... $ECHO_C" >&6

11575

if test "${ac_cv_have_decl_clearerr_unlocked+set}" = set; then

11576

echo $ECHO_N "(cached) $ECHO_C" >&6

11577

else

11578

cat >conftest.$ac_ext <<_ACEOF

11579

#line $LINENO "configure"

11580

/* confdefs.h. */

11581

_ACEOF

11582

cat confdefs.h >>conftest.$ac_ext

11583

cat >>conftest.$ac_ext <<_ACEOF

11584

/* end confdefs.h. */

11585

$ac_includes_default

11586

int

11587

main ()

11588

{

11589

#ifndef clearerr_unlocked

11590

char *p = (char *) clearerr_unlocked;

11591

#endif

11592

11593

;

11594

return 0;

11595

}

11596

_ACEOF

11597

rm -f conftest.$ac_objext

11598

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11599

(eval $ac_compile) 2>&5

11600

ac_status=$?

11601

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11602

(exit $ac_status); } &&

11603

{ ac_try='test -s conftest.$ac_objext'

11604

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11605

(eval $ac_try) 2>&5

11606

ac_status=$?

11607

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11608

(exit $ac_status); }; }; then

11609

ac_cv_have_decl_clearerr_unlocked=yes

11610

else

11611

echo "$as_me: failed program was:" >&5

11612

sed 's/^/| /' conftest.$ac_ext >&5

11613

11614

ac_cv_have_decl_clearerr_unlocked=no

11615

11616

rm -f conftest.$ac_objext conftest.$ac_ext

11617

11618

echo "$as_me:$LINENO: result: $ac_cv_have_decl_clearerr_unlocked" >&5

11619

echo "${ECHO_T}$ac_cv_have_decl_clearerr_unlocked" >&6

11620

if test $ac_cv_have_decl_clearerr_unlocked = yes; then

11621

11622

cat >>confdefs.h <<_ACEOF

11623

#define HAVE_DECL_CLEARERR_UNLOCKED 1

11624

_ACEOF

11625

11626

11627

else

11628

cat >>confdefs.h <<_ACEOF

11629

#define HAVE_DECL_CLEARERR_UNLOCKED 0

11630

_ACEOF

11631

11632

11633

11634

11635

11636

11637

11638

echo "$as_me:$LINENO: checking whether feof_unlocked is declared" >&5

11639

echo $ECHO_N "checking whether feof_unlocked is declared... $ECHO_C" >&6

11640

if test "${ac_cv_have_decl_feof_unlocked+set}" = set; then

11641

echo $ECHO_N "(cached) $ECHO_C" >&6

11642

else

11643

cat >conftest.$ac_ext <<_ACEOF

11644

#line $LINENO "configure"

11645

/* confdefs.h. */

11646

_ACEOF

11647

cat confdefs.h >>conftest.$ac_ext

11648

cat >>conftest.$ac_ext <<_ACEOF

11649

/* end confdefs.h. */

11650

$ac_includes_default

11651

int

11652

main ()

11653

{

11654

#ifndef feof_unlocked

11655

char *p = (char *) feof_unlocked;

11656

#endif

11657

11658

;

11659

return 0;

11660

}

11661

_ACEOF

11662

rm -f conftest.$ac_objext

11663

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11664

(eval $ac_compile) 2>&5

11665

ac_status=$?

11666

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11667

(exit $ac_status); } &&

11668

{ ac_try='test -s conftest.$ac_objext'

11669

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11670

(eval $ac_try) 2>&5

11671

ac_status=$?

11672

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11673

(exit $ac_status); }; }; then

11674

ac_cv_have_decl_feof_unlocked=yes

11675

else

11676

echo "$as_me: failed program was:" >&5

11677

sed 's/^/| /' conftest.$ac_ext >&5

11678

11679

ac_cv_have_decl_feof_unlocked=no

11680

11681

rm -f conftest.$ac_objext conftest.$ac_ext

11682

11683

echo "$as_me:$LINENO: result: $ac_cv_have_decl_feof_unlocked" >&5

11684

echo "${ECHO_T}$ac_cv_have_decl_feof_unlocked" >&6

11685

if test $ac_cv_have_decl_feof_unlocked = yes; then

11686

11687

cat >>confdefs.h <<_ACEOF

11688

#define HAVE_DECL_FEOF_UNLOCKED 1

11689

_ACEOF

11690

11691

11692

else

11693

cat >>confdefs.h <<_ACEOF

11694

#define HAVE_DECL_FEOF_UNLOCKED 0

11695

_ACEOF

11696

11697

11698

11699

11700

11701

11702

11703

echo "$as_me:$LINENO: checking whether ferror_unlocked is declared" >&5

11704

echo $ECHO_N "checking whether ferror_unlocked is declared... $ECHO_C" >&6

11705

if test "${ac_cv_have_decl_ferror_unlocked+set}" = set; then

11706

echo $ECHO_N "(cached) $ECHO_C" >&6

11707

else

11708

cat >conftest.$ac_ext <<_ACEOF

11709

#line $LINENO "configure"

11710

/* confdefs.h. */

11711

_ACEOF

11712

cat confdefs.h >>conftest.$ac_ext

11713

cat >>conftest.$ac_ext <<_ACEOF

11714

/* end confdefs.h. */

11715

$ac_includes_default

11716

int

11717

main ()

11718

{

11719

#ifndef ferror_unlocked

11720

char *p = (char *) ferror_unlocked;

11721

#endif

11722

11723

;

11724

return 0;

11725

}

11726

_ACEOF

11727

rm -f conftest.$ac_objext

11728

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11729

(eval $ac_compile) 2>&5

11730

ac_status=$?

11731

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11732

(exit $ac_status); } &&

11733

{ ac_try='test -s conftest.$ac_objext'

11734

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11735

(eval $ac_try) 2>&5

11736

ac_status=$?

11737

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11738

(exit $ac_status); }; }; then

11739

ac_cv_have_decl_ferror_unlocked=yes

11740

else

11741

echo "$as_me: failed program was:" >&5

11742

sed 's/^/| /' conftest.$ac_ext >&5

11743

11744

ac_cv_have_decl_ferror_unlocked=no

11745

11746

rm -f conftest.$ac_objext conftest.$ac_ext

11747

11748

echo "$as_me:$LINENO: result: $ac_cv_have_decl_ferror_unlocked" >&5

11749

echo "${ECHO_T}$ac_cv_have_decl_ferror_unlocked" >&6

11750

if test $ac_cv_have_decl_ferror_unlocked = yes; then

11751

11752

cat >>confdefs.h <<_ACEOF

11753

#define HAVE_DECL_FERROR_UNLOCKED 1

11754

_ACEOF

11755

11756

11757

else

11758

cat >>confdefs.h <<_ACEOF

11759

#define HAVE_DECL_FERROR_UNLOCKED 0

11760

_ACEOF

11761

11762

11763

11764

11765

11766

11767

11768

echo "$as_me:$LINENO: checking whether fflush_unlocked is declared" >&5

11769

echo $ECHO_N "checking whether fflush_unlocked is declared... $ECHO_C" >&6

11770

if test "${ac_cv_have_decl_fflush_unlocked+set}" = set; then

11771

echo $ECHO_N "(cached) $ECHO_C" >&6

11772

else

11773

cat >conftest.$ac_ext <<_ACEOF

11774

#line $LINENO "configure"

11775

/* confdefs.h. */

11776

_ACEOF

11777

cat confdefs.h >>conftest.$ac_ext

11778

cat >>conftest.$ac_ext <<_ACEOF

11779

/* end confdefs.h. */

11780

$ac_includes_default

11781

int

11782

main ()

11783

{

11784

#ifndef fflush_unlocked

11785

char *p = (char *) fflush_unlocked;

11786

#endif

11787

11788

;

11789

return 0;

11790

}

11791

_ACEOF

11792

rm -f conftest.$ac_objext

11793

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11794

(eval $ac_compile) 2>&5

11795

ac_status=$?

11796

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11797

(exit $ac_status); } &&

11798

{ ac_try='test -s conftest.$ac_objext'

11799

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11800

(eval $ac_try) 2>&5

11801

ac_status=$?

11802

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11803

(exit $ac_status); }; }; then

11804

ac_cv_have_decl_fflush_unlocked=yes

11805

else

11806

echo "$as_me: failed program was:" >&5

11807

sed 's/^/| /' conftest.$ac_ext >&5

11808

11809

ac_cv_have_decl_fflush_unlocked=no

11810

11811

rm -f conftest.$ac_objext conftest.$ac_ext

11812

11813

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fflush_unlocked" >&5

11814

echo "${ECHO_T}$ac_cv_have_decl_fflush_unlocked" >&6

11815

if test $ac_cv_have_decl_fflush_unlocked = yes; then

11816

11817

cat >>confdefs.h <<_ACEOF

11818

#define HAVE_DECL_FFLUSH_UNLOCKED 1

11819

_ACEOF

11820

11821

11822

else

11823

cat >>confdefs.h <<_ACEOF

11824

#define HAVE_DECL_FFLUSH_UNLOCKED 0

11825

_ACEOF

11826

11827

11828

11829

11830

11831

11832

11833

echo "$as_me:$LINENO: checking whether fgets_unlocked is declared" >&5

11834

echo $ECHO_N "checking whether fgets_unlocked is declared... $ECHO_C" >&6

11835

if test "${ac_cv_have_decl_fgets_unlocked+set}" = set; then

11836

echo $ECHO_N "(cached) $ECHO_C" >&6

11837

else

11838

cat >conftest.$ac_ext <<_ACEOF

11839

#line $LINENO "configure"

11840

/* confdefs.h. */

11841

_ACEOF

11842

cat confdefs.h >>conftest.$ac_ext

11843

cat >>conftest.$ac_ext <<_ACEOF

11844

/* end confdefs.h. */

11845

$ac_includes_default

11846

int

11847

main ()

11848

{

11849

#ifndef fgets_unlocked

11850

char *p = (char *) fgets_unlocked;

11851

#endif

11852

11853

;

11854

return 0;

11855

}

11856

_ACEOF

11857

rm -f conftest.$ac_objext

11858

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11859

(eval $ac_compile) 2>&5

11860

ac_status=$?

11861

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11862

(exit $ac_status); } &&

11863

{ ac_try='test -s conftest.$ac_objext'

11864

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11865

(eval $ac_try) 2>&5

11866

ac_status=$?

11867

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11868

(exit $ac_status); }; }; then

11869

ac_cv_have_decl_fgets_unlocked=yes

11870

else

11871

echo "$as_me: failed program was:" >&5

11872

sed 's/^/| /' conftest.$ac_ext >&5

11873

11874

ac_cv_have_decl_fgets_unlocked=no

11875

11876

rm -f conftest.$ac_objext conftest.$ac_ext

11877

11878

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fgets_unlocked" >&5

11879

echo "${ECHO_T}$ac_cv_have_decl_fgets_unlocked" >&6

11880

if test $ac_cv_have_decl_fgets_unlocked = yes; then

11881

11882

cat >>confdefs.h <<_ACEOF

11883

#define HAVE_DECL_FGETS_UNLOCKED 1

11884

_ACEOF

11885

11886

11887

else

11888

cat >>confdefs.h <<_ACEOF

11889

#define HAVE_DECL_FGETS_UNLOCKED 0

11890

_ACEOF

11891

11892

11893

11894

11895

11896

11897

11898

echo "$as_me:$LINENO: checking whether fputc_unlocked is declared" >&5

11899

echo $ECHO_N "checking whether fputc_unlocked is declared... $ECHO_C" >&6

11900

if test "${ac_cv_have_decl_fputc_unlocked+set}" = set; then

11901

echo $ECHO_N "(cached) $ECHO_C" >&6

11902

else

11903

cat >conftest.$ac_ext <<_ACEOF

11904

#line $LINENO "configure"

11905

/* confdefs.h. */

11906

_ACEOF

11907

cat confdefs.h >>conftest.$ac_ext

11908

cat >>conftest.$ac_ext <<_ACEOF

11909

/* end confdefs.h. */

11910

$ac_includes_default

11911

int

11912

main ()

11913

{

11914

#ifndef fputc_unlocked

11915

char *p = (char *) fputc_unlocked;

11916

#endif

11917

11918

;

11919

return 0;

11920

}

11921

_ACEOF

11922

rm -f conftest.$ac_objext

11923

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11924

(eval $ac_compile) 2>&5

11925

ac_status=$?

11926

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11927

(exit $ac_status); } &&

11928

{ ac_try='test -s conftest.$ac_objext'

11929

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11930

(eval $ac_try) 2>&5

11931

ac_status=$?

11932

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11933

(exit $ac_status); }; }; then

11934

ac_cv_have_decl_fputc_unlocked=yes

11935

else

11936

echo "$as_me: failed program was:" >&5

11937

sed 's/^/| /' conftest.$ac_ext >&5

11938

11939

ac_cv_have_decl_fputc_unlocked=no

11940

11941

rm -f conftest.$ac_objext conftest.$ac_ext

11942

11943

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fputc_unlocked" >&5

11944

echo "${ECHO_T}$ac_cv_have_decl_fputc_unlocked" >&6

11945

if test $ac_cv_have_decl_fputc_unlocked = yes; then

11946

11947

cat >>confdefs.h <<_ACEOF

11948

#define HAVE_DECL_FPUTC_UNLOCKED 1

11949

_ACEOF

11950

11951

11952

else

11953

cat >>confdefs.h <<_ACEOF

11954

#define HAVE_DECL_FPUTC_UNLOCKED 0

11955

_ACEOF

11956

11957

11958

11959

11960

11961

11962

11963

echo "$as_me:$LINENO: checking whether fputs_unlocked is declared" >&5

11964

echo $ECHO_N "checking whether fputs_unlocked is declared... $ECHO_C" >&6

11965

if test "${ac_cv_have_decl_fputs_unlocked+set}" = set; then

11966

echo $ECHO_N "(cached) $ECHO_C" >&6

11967

else

11968

cat >conftest.$ac_ext <<_ACEOF

11969

#line $LINENO "configure"

11970

/* confdefs.h. */

11971

_ACEOF

11972

cat confdefs.h >>conftest.$ac_ext

11973

cat >>conftest.$ac_ext <<_ACEOF

11974

/* end confdefs.h. */

11975

$ac_includes_default

11976

int

11977

main ()

11978

{

11979

#ifndef fputs_unlocked

11980

char *p = (char *) fputs_unlocked;

11981

#endif

11982

11983

;

11984

return 0;

11985

}

11986

_ACEOF

11987

rm -f conftest.$ac_objext

11988

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

11989

(eval $ac_compile) 2>&5

11990

ac_status=$?

11991

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11992

(exit $ac_status); } &&

11993

{ ac_try='test -s conftest.$ac_objext'

11994

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

11995

(eval $ac_try) 2>&5

11996

ac_status=$?

11997

echo "$as_me:$LINENO: \$? = $ac_status" >&5

11998

(exit $ac_status); }; }; then

11999

ac_cv_have_decl_fputs_unlocked=yes

12000

else

12001

echo "$as_me: failed program was:" >&5

12002

sed 's/^/| /' conftest.$ac_ext >&5

12003

12004

ac_cv_have_decl_fputs_unlocked=no

12005

12006

rm -f conftest.$ac_objext conftest.$ac_ext

12007

12008

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fputs_unlocked" >&5

12009

echo "${ECHO_T}$ac_cv_have_decl_fputs_unlocked" >&6

12010

if test $ac_cv_have_decl_fputs_unlocked = yes; then

12011

12012

cat >>confdefs.h <<_ACEOF

12013

#define HAVE_DECL_FPUTS_UNLOCKED 1

12014

_ACEOF

12015

12016

12017

else

12018

cat >>confdefs.h <<_ACEOF

12019

#define HAVE_DECL_FPUTS_UNLOCKED 0

12020

_ACEOF

12021

12022

12023

12024

12025

12026

12027

12028

echo "$as_me:$LINENO: checking whether fread_unlocked is declared" >&5

12029

echo $ECHO_N "checking whether fread_unlocked is declared... $ECHO_C" >&6

12030

if test "${ac_cv_have_decl_fread_unlocked+set}" = set; then

12031

echo $ECHO_N "(cached) $ECHO_C" >&6

12032

else

12033

cat >conftest.$ac_ext <<_ACEOF

12034

#line $LINENO "configure"

12035

/* confdefs.h. */

12036

_ACEOF

12037

cat confdefs.h >>conftest.$ac_ext

12038

cat >>conftest.$ac_ext <<_ACEOF

12039

/* end confdefs.h. */

12040

$ac_includes_default

12041

int

12042

main ()

12043

{

12044

#ifndef fread_unlocked

12045

char *p = (char *) fread_unlocked;

12046

#endif

12047

12048

;

12049

return 0;

12050

}

12051

_ACEOF

12052

rm -f conftest.$ac_objext

12053

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12054

(eval $ac_compile) 2>&5

12055

ac_status=$?

12056

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12057

(exit $ac_status); } &&

12058

{ ac_try='test -s conftest.$ac_objext'

12059

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12060

(eval $ac_try) 2>&5

12061

ac_status=$?

12062

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12063

(exit $ac_status); }; }; then

12064

ac_cv_have_decl_fread_unlocked=yes

12065

else

12066

echo "$as_me: failed program was:" >&5

12067

sed 's/^/| /' conftest.$ac_ext >&5

12068

12069

ac_cv_have_decl_fread_unlocked=no

12070

12071

rm -f conftest.$ac_objext conftest.$ac_ext

12072

12073

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fread_unlocked" >&5

12074

echo "${ECHO_T}$ac_cv_have_decl_fread_unlocked" >&6

12075

if test $ac_cv_have_decl_fread_unlocked = yes; then

12076

12077

cat >>confdefs.h <<_ACEOF

12078

#define HAVE_DECL_FREAD_UNLOCKED 1

12079

_ACEOF

12080

12081

12082

else

12083

cat >>confdefs.h <<_ACEOF

12084

#define HAVE_DECL_FREAD_UNLOCKED 0

12085

_ACEOF

12086

12087

12088

12089

12090

12091

12092

12093

echo "$as_me:$LINENO: checking whether fwrite_unlocked is declared" >&5

12094

echo $ECHO_N "checking whether fwrite_unlocked is declared... $ECHO_C" >&6

12095

if test "${ac_cv_have_decl_fwrite_unlocked+set}" = set; then

12096

echo $ECHO_N "(cached) $ECHO_C" >&6

12097

else

12098

cat >conftest.$ac_ext <<_ACEOF

12099

#line $LINENO "configure"

12100

/* confdefs.h. */

12101

_ACEOF

12102

cat confdefs.h >>conftest.$ac_ext

12103

cat >>conftest.$ac_ext <<_ACEOF

12104

/* end confdefs.h. */

12105

$ac_includes_default

12106

int

12107

main ()

12108

{

12109

#ifndef fwrite_unlocked

12110

char *p = (char *) fwrite_unlocked;

12111

#endif

12112

12113

;

12114

return 0;

12115

}

12116

_ACEOF

12117

rm -f conftest.$ac_objext

12118

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12119

(eval $ac_compile) 2>&5

12120

ac_status=$?

12121

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12122

(exit $ac_status); } &&

12123

{ ac_try='test -s conftest.$ac_objext'

12124

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12125

(eval $ac_try) 2>&5

12126

ac_status=$?

12127

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12128

(exit $ac_status); }; }; then

12129

ac_cv_have_decl_fwrite_unlocked=yes

12130

else

12131

echo "$as_me: failed program was:" >&5

12132

sed 's/^/| /' conftest.$ac_ext >&5

12133

12134

ac_cv_have_decl_fwrite_unlocked=no

12135

12136

rm -f conftest.$ac_objext conftest.$ac_ext

12137

12138

echo "$as_me:$LINENO: result: $ac_cv_have_decl_fwrite_unlocked" >&5

12139

echo "${ECHO_T}$ac_cv_have_decl_fwrite_unlocked" >&6

12140

if test $ac_cv_have_decl_fwrite_unlocked = yes; then

12141

12142

cat >>confdefs.h <<_ACEOF

12143

#define HAVE_DECL_FWRITE_UNLOCKED 1

12144

_ACEOF

12145

12146

12147

else

12148

cat >>confdefs.h <<_ACEOF

12149

#define HAVE_DECL_FWRITE_UNLOCKED 0

12150

_ACEOF

12151

12152

12153

12154

12155

12156

12157

12158

echo "$as_me:$LINENO: checking whether getc_unlocked is declared" >&5

12159

echo $ECHO_N "checking whether getc_unlocked is declared... $ECHO_C" >&6

12160

if test "${ac_cv_have_decl_getc_unlocked+set}" = set; then

12161

echo $ECHO_N "(cached) $ECHO_C" >&6

12162

else

12163

cat >conftest.$ac_ext <<_ACEOF

12164

#line $LINENO "configure"

12165

/* confdefs.h. */

12166

_ACEOF

12167

cat confdefs.h >>conftest.$ac_ext

12168

cat >>conftest.$ac_ext <<_ACEOF

12169

/* end confdefs.h. */

12170

$ac_includes_default

12171

int

12172

main ()

12173

{

12174

#ifndef getc_unlocked

12175

char *p = (char *) getc_unlocked;

12176

#endif

12177

12178

;

12179

return 0;

12180

}

12181

_ACEOF

12182

rm -f conftest.$ac_objext

12183

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12184

(eval $ac_compile) 2>&5

12185

ac_status=$?

12186

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12187

(exit $ac_status); } &&

12188

{ ac_try='test -s conftest.$ac_objext'

12189

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12190

(eval $ac_try) 2>&5

12191

ac_status=$?

12192

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12193

(exit $ac_status); }; }; then

12194

ac_cv_have_decl_getc_unlocked=yes

12195

else

12196

echo "$as_me: failed program was:" >&5

12197

sed 's/^/| /' conftest.$ac_ext >&5

12198

12199

ac_cv_have_decl_getc_unlocked=no

12200

12201

rm -f conftest.$ac_objext conftest.$ac_ext

12202

12203

echo "$as_me:$LINENO: result: $ac_cv_have_decl_getc_unlocked" >&5

12204

echo "${ECHO_T}$ac_cv_have_decl_getc_unlocked" >&6

12205

if test $ac_cv_have_decl_getc_unlocked = yes; then

12206

12207

cat >>confdefs.h <<_ACEOF

12208

#define HAVE_DECL_GETC_UNLOCKED 1

12209

_ACEOF

12210

12211

12212

else

12213

cat >>confdefs.h <<_ACEOF

12214

#define HAVE_DECL_GETC_UNLOCKED 0

12215

_ACEOF

12216

12217

12218

12219

12220

12221

12222

12223

echo "$as_me:$LINENO: checking whether getchar_unlocked is declared" >&5

12224

echo $ECHO_N "checking whether getchar_unlocked is declared... $ECHO_C" >&6

12225

if test "${ac_cv_have_decl_getchar_unlocked+set}" = set; then

12226

echo $ECHO_N "(cached) $ECHO_C" >&6

12227

else

12228

cat >conftest.$ac_ext <<_ACEOF

12229

#line $LINENO "configure"

12230

/* confdefs.h. */

12231

_ACEOF

12232

cat confdefs.h >>conftest.$ac_ext

12233

cat >>conftest.$ac_ext <<_ACEOF

12234

/* end confdefs.h. */

12235

$ac_includes_default

12236

int

12237

main ()

12238

{

12239

#ifndef getchar_unlocked

12240

char *p = (char *) getchar_unlocked;

12241

#endif

12242

12243

;

12244

return 0;

12245

}

12246

_ACEOF

12247

rm -f conftest.$ac_objext

12248

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12249

(eval $ac_compile) 2>&5

12250

ac_status=$?

12251

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12252

(exit $ac_status); } &&

12253

{ ac_try='test -s conftest.$ac_objext'

12254

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12255

(eval $ac_try) 2>&5

12256

ac_status=$?

12257

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12258

(exit $ac_status); }; }; then

12259

ac_cv_have_decl_getchar_unlocked=yes

12260

else

12261

echo "$as_me: failed program was:" >&5

12262

sed 's/^/| /' conftest.$ac_ext >&5

12263

12264

ac_cv_have_decl_getchar_unlocked=no

12265

12266

rm -f conftest.$ac_objext conftest.$ac_ext

12267

12268

echo "$as_me:$LINENO: result: $ac_cv_have_decl_getchar_unlocked" >&5

12269

echo "${ECHO_T}$ac_cv_have_decl_getchar_unlocked" >&6

12270

if test $ac_cv_have_decl_getchar_unlocked = yes; then

12271

12272

cat >>confdefs.h <<_ACEOF

12273

#define HAVE_DECL_GETCHAR_UNLOCKED 1

12274

_ACEOF

12275

12276

12277

else

12278

cat >>confdefs.h <<_ACEOF

12279

#define HAVE_DECL_GETCHAR_UNLOCKED 0

12280

_ACEOF

12281

12282

12283

12284

12285

12286

12287

12288

echo "$as_me:$LINENO: checking whether putc_unlocked is declared" >&5

12289

echo $ECHO_N "checking whether putc_unlocked is declared... $ECHO_C" >&6

12290

if test "${ac_cv_have_decl_putc_unlocked+set}" = set; then

12291

echo $ECHO_N "(cached) $ECHO_C" >&6

12292

else

12293

cat >conftest.$ac_ext <<_ACEOF

12294

#line $LINENO "configure"

12295

/* confdefs.h. */

12296

_ACEOF

12297

cat confdefs.h >>conftest.$ac_ext

12298

cat >>conftest.$ac_ext <<_ACEOF

12299

/* end confdefs.h. */

12300

$ac_includes_default

12301

int

12302

main ()

12303

{

12304

#ifndef putc_unlocked

12305

char *p = (char *) putc_unlocked;

12306

#endif

12307

12308

;

12309

return 0;

12310

}

12311

_ACEOF

12312

rm -f conftest.$ac_objext

12313

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12314

(eval $ac_compile) 2>&5

12315

ac_status=$?

12316

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12317

(exit $ac_status); } &&

12318

{ ac_try='test -s conftest.$ac_objext'

12319

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12320

(eval $ac_try) 2>&5

12321

ac_status=$?

12322

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12323

(exit $ac_status); }; }; then

12324

ac_cv_have_decl_putc_unlocked=yes

12325

else

12326

echo "$as_me: failed program was:" >&5

12327

sed 's/^/| /' conftest.$ac_ext >&5

12328

12329

ac_cv_have_decl_putc_unlocked=no

12330

12331

rm -f conftest.$ac_objext conftest.$ac_ext

12332

12333

echo "$as_me:$LINENO: result: $ac_cv_have_decl_putc_unlocked" >&5

12334

echo "${ECHO_T}$ac_cv_have_decl_putc_unlocked" >&6

12335

if test $ac_cv_have_decl_putc_unlocked = yes; then

12336

12337

cat >>confdefs.h <<_ACEOF

12338

#define HAVE_DECL_PUTC_UNLOCKED 1

12339

_ACEOF

12340

12341

12342

else

12343

cat >>confdefs.h <<_ACEOF

12344

#define HAVE_DECL_PUTC_UNLOCKED 0

12345

_ACEOF

12346

12347

12348

12349

12350

12351

12352

12353

echo "$as_me:$LINENO: checking whether putchar_unlocked is declared" >&5

12354

echo $ECHO_N "checking whether putchar_unlocked is declared... $ECHO_C" >&6

12355

if test "${ac_cv_have_decl_putchar_unlocked+set}" = set; then

12356

echo $ECHO_N "(cached) $ECHO_C" >&6

12357

else

12358

cat >conftest.$ac_ext <<_ACEOF

12359

#line $LINENO "configure"

12360

/* confdefs.h. */

12361

_ACEOF

12362

cat confdefs.h >>conftest.$ac_ext

12363

cat >>conftest.$ac_ext <<_ACEOF

12364

/* end confdefs.h. */

12365

$ac_includes_default

12366

int

12367

main ()

12368

{

12369

#ifndef putchar_unlocked

12370

char *p = (char *) putchar_unlocked;

12371

#endif

12372

12373

;

12374

return 0;

12375

}

12376

_ACEOF

12377

rm -f conftest.$ac_objext

12378

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12379

(eval $ac_compile) 2>&5

12380

ac_status=$?

12381

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12382

(exit $ac_status); } &&

12383

{ ac_try='test -s conftest.$ac_objext'

12384

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12385

(eval $ac_try) 2>&5

12386

ac_status=$?

12387

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12388

(exit $ac_status); }; }; then

12389

ac_cv_have_decl_putchar_unlocked=yes

12390

else

12391

echo "$as_me: failed program was:" >&5

12392

sed 's/^/| /' conftest.$ac_ext >&5

12393

12394

ac_cv_have_decl_putchar_unlocked=no

12395

12396

rm -f conftest.$ac_objext conftest.$ac_ext

12397

12398

echo "$as_me:$LINENO: result: $ac_cv_have_decl_putchar_unlocked" >&5

12399

echo "${ECHO_T}$ac_cv_have_decl_putchar_unlocked" >&6

12400

if test $ac_cv_have_decl_putchar_unlocked = yes; then

12401

12402

cat >>confdefs.h <<_ACEOF

12403

#define HAVE_DECL_PUTCHAR_UNLOCKED 1

12404

_ACEOF

12405

12406

12407

else

12408

cat >>confdefs.h <<_ACEOF

12409

#define HAVE_DECL_PUTCHAR_UNLOCKED 0

12410

_ACEOF

12411

12412

12413

12414

12415

12416

12417

12418

12419

12420

12421

12422

12423

12424

12425

12426

12427

12428

12429

12430

12431

12432

12433

12434

12435

12436

12437

12438

12439

12440

12441

12442

12443

12444

12445

12446

12447

12448

12449

12450

12451

12452

12453

12454

12455

12456

12457

12458

12459

12460

12461

12462

12463

12464

12465

12466

12467

12468

12469

12470

12471

12472

12473

12474

12475

12476

12477

12478

12479

12480

12481

12482

12483

12484

12485

12486

12487

12488

12489

12490

12491

12492

12493

12494

12495

for ac_func in getcwd

12496

12497

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

12498

echo "$as_me:$LINENO: checking for $ac_func" >&5

12499

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

12500

if eval "test \"\${$as_ac_var+set}\" = set"; then

12501

echo $ECHO_N "(cached) $ECHO_C" >&6

12502

else

12503

cat >conftest.$ac_ext <<_ACEOF

12504

#line $LINENO "configure"

12505

/* confdefs.h. */

12506

_ACEOF

12507

cat confdefs.h >>conftest.$ac_ext

12508

cat >>conftest.$ac_ext <<_ACEOF

12509

/* end confdefs.h. */

12510

/* System header to define __stub macros and hopefully few prototypes,

12511

which can conflict with char $ac_func (); below.

12512

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

12513

<limits.h> exists even on freestanding compilers. */

12514

#ifdef __STDC__

12515

# include <limits.h>

12516

#else

12517

# include <assert.h>

12518

#endif

12519

/* Override any gcc2 internal prototype to avoid an error. */

12520

#ifdef __cplusplus

12521

extern "C"

12522

{

12523

#endif

12524

/* We use char because int might match the return type of a gcc2

12525

builtin and then its argument prototype would still apply. */

12526

char $ac_func ();

12527

/* The GNU C library defines this for functions which it implements

12528

to always fail with ENOSYS. Some functions are actually named

12529

something starting with __ and the normal name is an alias. */

12530

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

12531

choke me

12532

#else

12533

char (*f) () = $ac_func;

12534

#endif

12535

#ifdef __cplusplus

12536

}

12537

#endif

12538

12539

int

12540

main ()

12541

{

12542

return f != $ac_func;

12543

;

12544

return 0;

12545

}

12546

_ACEOF

12547

rm -f conftest.$ac_objext conftest$ac_exeext

12548

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

12549

(eval $ac_link) 2>&5

12550

ac_status=$?

12551

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12552

(exit $ac_status); } &&

12553

{ ac_try='test -s conftest$ac_exeext'

12554

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12555

(eval $ac_try) 2>&5

12556

ac_status=$?

12557

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12558

(exit $ac_status); }; }; then

12559

eval "$as_ac_var=yes"

12560

else

12561

echo "$as_me: failed program was:" >&5

12562

sed 's/^/| /' conftest.$ac_ext >&5

12563

12564

eval "$as_ac_var=no"

12565

12566

rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext

12567

12568

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

12569

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

12570

if test `eval echo '${'$as_ac_var'}'` = yes; then

12571

cat >>confdefs.h <<_ACEOF

12572

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

12573

_ACEOF

12574

12575

12576

done

12577

12578

12579

12580

12581

12582

12583

12584

12585

12586

12587

12588

12589

echo "$as_me:$LINENO: checking whether getcwd (NULL, 0) allocates memory for result" >&5

12590

echo $ECHO_N "checking whether getcwd (NULL, 0) allocates memory for result... $ECHO_C" >&6

12591

if test "${ac_cv_func_getcwd_null+set}" = set; then

12592

echo $ECHO_N "(cached) $ECHO_C" >&6

12593

else

12594

if test "$cross_compiling" = yes; then

12595

ac_cv_func_getcwd_null=no

12596

else

12597

cat >conftest.$ac_ext <<_ACEOF

12598

#line $LINENO "configure"

12599

/* confdefs.h. */

12600

_ACEOF

12601

cat confdefs.h >>conftest.$ac_ext

12602

cat >>conftest.$ac_ext <<_ACEOF

12603

/* end confdefs.h. */

12604

12605

# ifdef HAVE_STDLIB_H

12606

# include <stdlib.h>

12607

# endif

12608

# ifdef HAVE_UNISTD_H

12609

# include <unistd.h>

12610

# endif

12611

# ifndef getcwd

12612

char *getcwd ();

12613

# endif

12614

int

12615

main ()

12616

{

12617

if (chdir ("/") != 0)

12618

exit (1);

12619

else

12620

{

12621

char *f = getcwd (NULL, 0);

12622

exit (! (f && f[0] == '/' && !f[1]));

12623

}

12624

}

12625

_ACEOF

12626

rm -f conftest$ac_exeext

12627

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

12628

(eval $ac_link) 2>&5

12629

ac_status=$?

12630

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12631

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

12632

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12633

(eval $ac_try) 2>&5

12634

ac_status=$?

12635

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12636

(exit $ac_status); }; }; then

12637

ac_cv_func_getcwd_null=yes

12638

else

12639

echo "$as_me: program exited with status $ac_status" >&5

12640

echo "$as_me: failed program was:" >&5

12641

sed 's/^/| /' conftest.$ac_ext >&5

12642

12643

( exit $ac_status )

12644

ac_cv_func_getcwd_null=no

12645

12646

rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

12647

12648

12649

echo "$as_me:$LINENO: result: $ac_cv_func_getcwd_null" >&5

12650

echo "${ECHO_T}$ac_cv_func_getcwd_null" >&6

12651

if test $ac_cv_func_getcwd_null = yes; then

12652

12653

cat >>confdefs.h <<\_ACEOF

12654

#define HAVE_GETCWD_NULL 1

12655

_ACEOF

12656

12657

12658

12659

12660

12661

12662

12663

12664

12665

12666

12667

12668

12669

12670

12671

12672

12673

12674

12675

12676

12677

12678

12679

12680

12681

12682

12683

12684

12685

12686

12687

12688

12689

12690

12691

12692

12693

12694

echo "$as_me:$LINENO: checking whether strtoimax is declared" >&5

12695

echo $ECHO_N "checking whether strtoimax is declared... $ECHO_C" >&6

12696

if test "${ac_cv_have_decl_strtoimax+set}" = set; then

12697

echo $ECHO_N "(cached) $ECHO_C" >&6

12698

else

12699

cat >conftest.$ac_ext <<_ACEOF

12700

#line $LINENO "configure"

12701

/* confdefs.h. */

12702

_ACEOF

12703

cat confdefs.h >>conftest.$ac_ext

12704

cat >>conftest.$ac_ext <<_ACEOF

12705

/* end confdefs.h. */

12706

$ac_includes_default

12707

int

12708

main ()

12709

{

12710

#ifndef strtoimax

12711

char *p = (char *) strtoimax;

12712

#endif

12713

12714

;

12715

return 0;

12716

}

12717

_ACEOF

12718

rm -f conftest.$ac_objext

12719

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12720

(eval $ac_compile) 2>&5

12721

ac_status=$?

12722

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12723

(exit $ac_status); } &&

12724

{ ac_try='test -s conftest.$ac_objext'

12725

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12726

(eval $ac_try) 2>&5

12727

ac_status=$?

12728

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12729

(exit $ac_status); }; }; then

12730

ac_cv_have_decl_strtoimax=yes

12731

else

12732

echo "$as_me: failed program was:" >&5

12733

sed 's/^/| /' conftest.$ac_ext >&5

12734

12735

ac_cv_have_decl_strtoimax=no

12736

12737

rm -f conftest.$ac_objext conftest.$ac_ext

12738

12739

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtoimax" >&5

12740

echo "${ECHO_T}$ac_cv_have_decl_strtoimax" >&6

12741

if test $ac_cv_have_decl_strtoimax = yes; then

12742

12743

cat >>confdefs.h <<_ACEOF

12744

#define HAVE_DECL_STRTOIMAX 1

12745

_ACEOF

12746

12747

12748

else

12749

cat >>confdefs.h <<_ACEOF

12750

#define HAVE_DECL_STRTOIMAX 0

12751

_ACEOF

12752

12753

12754

12755

echo "$as_me:$LINENO: checking whether strtoumax is declared" >&5

12756

echo $ECHO_N "checking whether strtoumax is declared... $ECHO_C" >&6

12757

if test "${ac_cv_have_decl_strtoumax+set}" = set; then

12758

echo $ECHO_N "(cached) $ECHO_C" >&6

12759

else

12760

cat >conftest.$ac_ext <<_ACEOF

12761

#line $LINENO "configure"

12762

/* confdefs.h. */

12763

_ACEOF

12764

cat confdefs.h >>conftest.$ac_ext

12765

cat >>conftest.$ac_ext <<_ACEOF

12766

/* end confdefs.h. */

12767

$ac_includes_default

12768

int

12769

main ()

12770

{

12771

#ifndef strtoumax

12772

char *p = (char *) strtoumax;

12773

#endif

12774

12775

;

12776

return 0;

12777

}

12778

_ACEOF

12779

rm -f conftest.$ac_objext

12780

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

12781

(eval $ac_compile) 2>&5

12782

ac_status=$?

12783

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12784

(exit $ac_status); } &&

12785

{ ac_try='test -s conftest.$ac_objext'

12786

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

12787

(eval $ac_try) 2>&5

12788

ac_status=$?

12789

echo "$as_me:$LINENO: \$? = $ac_status" >&5

12790

(exit $ac_status); }; }; then

12791

ac_cv_have_decl_strtoumax=yes

12792

else

12793

echo "$as_me: failed program was:" >&5

12794

sed 's/^/| /' conftest.$ac_ext >&5

12795

12796

ac_cv_have_decl_strtoumax=no

12797

12798

rm -f conftest.$ac_objext conftest.$ac_ext

12799

12800

echo "$as_me:$LINENO: result: $ac_cv_have_decl_strtoumax" >&5

12801

echo "${ECHO_T}$ac_cv_have_decl_strtoumax" >&6

12802

if test $ac_cv_have_decl_strtoumax = yes; then

12803

12804

cat >>confdefs.h <<_ACEOF

12805

#define HAVE_DECL_STRTOUMAX 1

12806

_ACEOF

12807

12808

12809

else

12810

cat >>confdefs.h <<_ACEOF

12811

#define HAVE_DECL_STRTOUMAX 0

12812

_ACEOF

12813

12814

12815

12816

12817

12818

12819

12820

12821

12822

12823

12824

12825

12826

12827

12828

12829

12830

12831

12832

12833

12834

12835

12836

12837

12838

12839

12840

12841

12842

12843

ac_config_files="$ac_config_files Makefile lib/Makefile m4/Makefile po/Makefile"

12844

cat >confcache <<\_ACEOF

12845

# This file is a shell script that caches the results of configure

12846

# tests run on this system so they can be shared between configure

12847

# scripts and configure runs, see configure's option --config-cache.

12848

# It is not useful on other systems. If it contains results you don't

12849

# want to keep, you may remove or edit it.

12850

12851

# config.status only pays attention to the cache file if you give it

12852

# the --recheck option to rerun configure.

12853

12854

# `ac_cv_env_foo' variables (set or unset) will be overridden when

12855

# loading this file, other *unset* `ac_cv_foo' will be assigned the

12856

# following values.

12857

12858

_ACEOF

12859

12860

# The following way of writing the cache mishandles newlines in values,

12861

# but we know of no workaround that is simple, portable, and efficient.

12862

# So, don't put newlines in cache variables' values.

12863

# Ultrix sh set writes to stderr and can't be redirected directly,

12864

# and sets the high bit in the cache file unless we assign to the vars.

12865

{

12866

(set) 2>&1 |

12867

case `(ac_space=' '; set | grep ac_space) 2>&1` in

12868

*ac_space=\ *)

12869

# `set' does not quote correctly, so add quotes (double-quote

12870

# substitution turns \\\\ into \\, and sed turns \\ into \).

12871

sed -n \

12872

"s/'/'\\\\''/g;

12873

s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1='\\2'/p"

12874

;;

12875

12876

# `set' quotes correctly as required by POSIX, so do not add quotes.

12877

sed -n \

12878

"s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1=\\2/p"

12879

;;

12880

esac;

12881

} |

12882

sed '

12883

t clear

12884

: clear

12885

s/^$[^=]*$=$.*[{}].*$$/test "${\1+set}" = set || &/

12886

t end

12887

/^ac_cv_env/!s/^$[^=]*$=$.*$$/\1=${\1=\2}/

12888

: end' >>confcache

12889

if diff $cache_file confcache >/dev/null 2>&1; then :; else

12890

if test -w $cache_file; then

12891

test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"

12892

cat confcache >$cache_file

12893

else

12894

echo "not updating unwritable cache $cache_file"

12895

12896

12897

rm -f confcache

12898

12899

test "x$prefix" = xNONE && prefix=$ac_default_prefix

12900

# Let make expand exec_prefix.

12901

test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

12902

12903

# VPATH may cause trouble with some makes, so we remove $(srcdir),

12904

# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and

12905

# trailing colons and then remove the whole line if VPATH becomes empty

12906

# (actually we leave an empty line to preserve line numbers).

12907

if test "x$srcdir" = x.; then

12908

ac_vpsub='/^[ ]*VPATH[ ]*=/{

12909

s/:*\$(srcdir):*/:/;

12910

s/:*\${srcdir}:*/:/;

12911

s/:*@srcdir@:*/:/;

12912

s/^$[^=]*=[ ]*$:*/\1/;

12913

s/:*$//;

12914

s/^[^=]*=[ ]*$//;

12915

12916

12917

12918

DEFS=-DHAVE_CONFIG_H

12919

12920

ac_libobjs=

12921

ac_ltlibobjs=

12922

for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue

12923

# 1. Remove the extension, and $U if already installed.

12924

ac_i=`echo "$ac_i" |

12925

sed 's/\$U\././;s/\.o$//;s/\.obj$//'`

12926

# 2. Add them.

12927

ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"

12928

ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'

12929

done

12930

LIBOBJS=$ac_libobjs

12931

12932

LTLIBOBJS=$ac_ltlibobjs

12933

12934

12935

if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then

12936

{ { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.

12937

Usually this means the macro was only invoked conditionally." >&5

12938

echo "$as_me: error: conditional \"AMDEP\" was never defined.

12939

Usually this means the macro was only invoked conditionally." >&2;}

12940

{ (exit 1); exit 1; }; }

12941

12942

if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then

12943

{ { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.

12944

Usually this means the macro was only invoked conditionally." >&5

12945

echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.

12946

Usually this means the macro was only invoked conditionally." >&2;}

12947

{ (exit 1); exit 1; }; }

12948

12949

12950

: ${CONFIG_STATUS=./config.status}

12951

ac_clean_files_save=$ac_clean_files

12952

ac_clean_files="$ac_clean_files $CONFIG_STATUS"

12953

{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5

12954

echo "$as_me: creating $CONFIG_STATUS" >&6;}

12955

cat >$CONFIG_STATUS <<_ACEOF

12956

#! $SHELL

12957

# Generated by $as_me.

12958

# Run this file to recreate the current configuration.

12959

# Compiler output produced by configure, useful for debugging

12960

# configure, is in config.log if it exists.

12961

12962

debug=false

12963

ac_cs_recheck=false

12964

ac_cs_silent=false

12965

SHELL=\${CONFIG_SHELL-$SHELL}

12966

_ACEOF

12967

12968

cat >>$CONFIG_STATUS <<\_ACEOF

12969

## --------------------- ##

12970

## M4sh Initialization. ##

12971

## --------------------- ##

12972

12973

# Be Bourne compatible

12974

if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

12975

emulate sh

12976

NULLCMD=:

12977

# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

12978

# is contrary to our usage. Disable this feature.

12979

alias -g '${1+"$@"}'='"$@"'

12980

elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then

12981

set -o posix

12982

12983

12984

# Support unset when possible.

12985

if (FOO=FOO; unset FOO) >/dev/null 2>&1; then

12986

as_unset=unset

12987

else

12988

as_unset=false

12989

12990

12991

12992

# Work around bugs in pre-3.0 UWIN ksh.

12993

$as_unset ENV MAIL MAILPATH

12994

PS1='$ '

12995

PS2='> '

12996

PS4='+ '

12997

12998

# NLS nuisances.

12999

for as_var in \

13000

LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \

13001

LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \

13002

LC_TELEPHONE LC_TIME

13003

13004

if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then

13005

eval $as_var=C; export $as_var

13006

else

13007

$as_unset $as_var

13008

13009

done

13010

13011

# Required to use basename.

13012

if expr a : '$a$' >/dev/null 2>&1; then

13013

as_expr=expr

13014

else

13015

as_expr=false

13016

13017

13018

if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then

13019

as_basename=basename

13020

else

13021

as_basename=false

13022

13023

13024

13025

# Name of the executable.

13026

as_me=`$as_basename "$0" ||

13027

$as_expr X/"$0" : '.*/$[^/][^/]*$/*$' \| \

13028

X"$0" : 'X$//$$' \| \

13029

X"$0" : 'X$/$$' \| \

13030

. : '$.$' 2>/dev/null ||

13031

echo X/"$0" |

13032

sed '/^.*\/$[^/][^/]*$\/*$/{ s//\1/; q; }

13033

/^X\/$\/\/$$/{ s//\1/; q; }

13034

/^X\/$\/$.*/{ s//\1/; q; }

13035

s/.*/./; q'`

13036

13037

13038

# PATH needs CR, and LINENO needs CR and PATH.

13039

# Avoid depending upon Character Ranges.

13040

as_cr_letters='abcdefghijklmnopqrstuvwxyz'

13041

as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

13042

as_cr_Letters=$as_cr_letters$as_cr_LETTERS

13043

as_cr_digits='0123456789'

13044

as_cr_alnum=$as_cr_Letters$as_cr_digits

13045

13046

# The user is always right.

13047

if test "${PATH_SEPARATOR+set}" != set; then

13048

echo "#! /bin/sh" >conf$$.sh

13049

echo "exit 0" >>conf$$.sh

13050

chmod +x conf$$.sh

13051

if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then

13052

PATH_SEPARATOR=';'

13053

else

13054

PATH_SEPARATOR=:

13055

13056

rm -f conf$$.sh

13057

13058

13059

13060

as_lineno_1=$LINENO

13061

as_lineno_2=$LINENO

13062

as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

13063

test "x$as_lineno_1" != "x$as_lineno_2" &&

13064

test "x$as_lineno_3" = "x$as_lineno_2" || {

13065

# Find who we are. Look in the path if we contain no path at all

13066

# relative or not.

13067

case $0 in

13068

*[\\/]* ) as_myself=$0 ;;

13069

*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

13070

for as_dir in $PATH

13071

13072

IFS=$as_save_IFS

13073

test -z "$as_dir" && as_dir=.

13074

test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break

13075

done

13076

13077

;;

13078

esac

13079

# We did not find ourselves, most probably we were run as `sh COMMAND'

13080

# in which case we are not to be found in the path.

13081

if test "x$as_myself" = x; then

13082

as_myself=$0

13083

13084

if test ! -f "$as_myself"; then

13085

{ { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5

13086

echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}

13087

{ (exit 1); exit 1; }; }

13088

13089

case $CONFIG_SHELL in

13090

'')

13091

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

13092

for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH

13093

13094

IFS=$as_save_IFS

13095

test -z "$as_dir" && as_dir=.

13096

for as_base in sh bash ksh sh5; do

13097

case $as_dir in

13098

/*)

13099

if ("$as_dir/$as_base" -c '

13100

as_lineno_1=$LINENO

13101

as_lineno_2=$LINENO

13102

as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

13103

test "x$as_lineno_1" != "x$as_lineno_2" &&

13104

test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then

13105

$as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }

13106

$as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }

13107

CONFIG_SHELL=$as_dir/$as_base

13108

export CONFIG_SHELL

13109

exec "$CONFIG_SHELL" "$0" ${1+"$@"}

13110

fi;;

13111

esac

13112

done

13113

done

13114

;;

13115

esac

13116

13117

# Create $as_me.lineno as a copy of $as_myself, but with $LINENO

13118

# uniformly replaced by the line number. The first 'sed' inserts a

13119

# line-number line before each line; the second 'sed' does the real

13120

# work. The second script uses 'N' to pair each line-number line

13121

# with the numbered line, and appends trailing '-' during

13122

# substitution so that $LINENO is not a special case at line end.

13123

# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the

13124

# second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-)

13125

sed '=' <$as_myself |

13126

sed '

13127

13128

s,$,-,

13129

: loop

13130

s,^$['$as_cr_digits']*$$.*$[$]LINENO$[^'$as_cr_alnum'_]$,\1\2\1\3,

13131

t loop

13132

s,-$,,

13133

s,^['$as_cr_digits']*\n,,

13134

' >$as_me.lineno &&

13135

chmod +x $as_me.lineno ||

13136

{ { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5

13137

echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}

13138

{ (exit 1); exit 1; }; }

13139

13140

# Don't try to exec as it changes $[0], causing all sort of problems

13141

# (the dirname of $[0] is not the place where we might find the

13142

# original and so on. Autoconf is especially sensible to this).

13143

. ./$as_me.lineno

13144

# Exit status is that of the last command.

13145

exit

13146

}

13147

13148

13149

case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in

13150

*c*,-n*) ECHO_N= ECHO_C='

13151

' ECHO_T=' ' ;;

13152

*c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;;

13153

*) ECHO_N= ECHO_C='\c' ECHO_T= ;;

13154

esac

13155

13156

if expr a : '$a$' >/dev/null 2>&1; then

13157

as_expr=expr

13158

else

13159

as_expr=false

13160

13161

13162

rm -f conf$$ conf$$.exe conf$$.file

13163

echo >conf$$.file

13164

if ln -s conf$$.file conf$$ 2>/dev/null; then

13165

# We could just check for DJGPP; but this test a) works b) is more generic

13166

# and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).

13167

if test -f conf$$.exe; then

13168

# Don't use ln at all; we don't have any links

13169

as_ln_s='cp -p'

13170

else

13171

as_ln_s='ln -s'

13172

13173

elif ln conf$$.file conf$$ 2>/dev/null; then

13174

as_ln_s=ln

13175

else

13176

as_ln_s='cp -p'

13177

13178

rm -f conf$$ conf$$.exe conf$$.file

13179

13180

if mkdir -p . 2>/dev/null; then

13181

as_mkdir_p=:

13182

else

13183

as_mkdir_p=false

13184

13185

13186

as_executable_p="test -f"

13187

13188

# Sed expression to map a string onto a valid CPP name.

13189

as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"

13190

13191

# Sed expression to map a string onto a valid variable name.

13192

as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"

13193

13194

13195

# IFS

13196

# We need space, tab and new line, in precisely that order.

13197

as_nl='

13198

13199

IFS=" $as_nl"

13200

13201

# CDPATH.

13202

$as_unset CDPATH

13203

13204

exec 6>&1

13205

13206

# Open the log real soon, to keep \$[0] and so on meaningful, and to

13207

# report actual input values of CONFIG_FILES etc. instead of their

13208

# values after options handling. Logging --version etc. is OK.

13209

exec 5>>config.log

13210

{

13211

echo

13212

sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX

13213

## Running $as_me. ##

13214

_ASBOX

13215

} >&5

13216

cat >&5 <<_CSEOF

13217

13218

This file was extended by dummy $as_me 0, which was

13219

generated by GNU Autoconf 2.57. Invocation command line was

13220

13221

CONFIG_FILES = $CONFIG_FILES

13222

CONFIG_HEADERS = $CONFIG_HEADERS

13223

CONFIG_LINKS = $CONFIG_LINKS

13224

CONFIG_COMMANDS = $CONFIG_COMMANDS

13225

$ $0 $@

13226

13227

_CSEOF

13228

echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5

13229

echo >&5

13230

_ACEOF

13231

13232

# Files that config.status was made for.

13233

if test -n "$ac_config_files"; then

13234

echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS

13235

13236

13237

if test -n "$ac_config_headers"; then

13238

echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS

13239

13240

13241

if test -n "$ac_config_links"; then

13242

echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS

13243

13244

13245

if test -n "$ac_config_commands"; then

13246

echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS

13247

13248

13249

cat >>$CONFIG_STATUS <<\_ACEOF

13250

13251

ac_cs_usage="\

13252

\`$as_me' instantiates files from templates according to the

13253

current configuration.

13254

13255

Usage: $0 [OPTIONS] [FILE]...

13256

13257

-h, --help print this help, then exit

13258

-V, --version print version number, then exit

13259

-q, --quiet do not print progress messages

13260

-d, --debug don't remove temporary files

13261

--recheck update $as_me by reconfiguring in the same conditions

13262

--file=FILE[:TEMPLATE]

13263

instantiate the configuration file FILE

13264

--header=FILE[:TEMPLATE]

13265

instantiate the configuration header FILE

13266

13267

Configuration files:

13268

$config_files

13269

13270

Configuration headers:

13271

$config_headers

13272

13273

Configuration commands:

13274

$config_commands

13275

13276

Report bugs to <bug-autoconf@gnu.org>."

13277

_ACEOF

13278

13279

cat >>$CONFIG_STATUS <<_ACEOF

13280

ac_cs_version="\\

13281

dummy config.status 0

13282

configured by $0, generated by GNU Autoconf 2.57,

13283

with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

13284

13285

13286

Free Software Foundation, Inc.

13287

This config.status script is free software; the Free Software Foundation

13288

gives unlimited permission to copy, distribute and modify it."

13289

srcdir=$srcdir

13290

INSTALL="$INSTALL"

13291

_ACEOF

13292

13293

cat >>$CONFIG_STATUS <<\_ACEOF

13294

# If no file are specified by the user, then we need to provide default

13295

# value. By we need to know if files were specified by the user.

13296

ac_need_defaults=:

13297

while test $# != 0

13298

13299

case $1 in

13300

--*=*)

13301

ac_option=`expr "x$1" : 'x$[^=]*$='`

13302

ac_optarg=`expr "x$1" : 'x[^=]*=$.*$'`

13303

ac_shift=:

13304

;;

13305

-*)

13306

ac_option=$1

13307

ac_optarg=$2

13308

ac_shift=shift

13309

;;

13310

*) # This is not an option, so the user has probably given explicit

13311

# arguments.

13312

ac_option=$1

13313

ac_need_defaults=false;;

13314

esac

13315

13316

case $ac_option in

13317

# Handling of the options.

13318

_ACEOF

13319

cat >>$CONFIG_STATUS <<\_ACEOF

13320

13321

ac_cs_recheck=: ;;

13322

--version | --vers* | -V )

13323

echo "$ac_cs_version"; exit 0 ;;

13324

--he | --h)

13325

# Conflict between --help and --header

13326

{ { echo "$as_me:$LINENO: error: ambiguous option: $1

13327

Try \`$0 --help' for more information." >&5

13328

echo "$as_me: error: ambiguous option: $1

13329

Try \`$0 --help' for more information." >&2;}

13330

{ (exit 1); exit 1; }; };;

13331

--help | --hel | -h )

13332

echo "$ac_cs_usage"; exit 0 ;;

13333

--debug | --d* | -d )

13334

debug=: ;;

13335

--file | --fil | --fi | --f )

13336

$ac_shift

13337

CONFIG_FILES="$CONFIG_FILES $ac_optarg"

13338

ac_need_defaults=false;;

13339

--header | --heade | --head | --hea )

13340

$ac_shift

13341

CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"

13342

ac_need_defaults=false;;

13343

-q | -quiet | --quiet | --quie | --qui | --qu | --q \

13344

| -silent | --silent | --silen | --sile | --sil | --si | --s)

13345

ac_cs_silent=: ;;

13346

13347

# This is an error.

13348

-*) { { echo "$as_me:$LINENO: error: unrecognized option: $1

13349

Try \`$0 --help' for more information." >&5

13350

echo "$as_me: error: unrecognized option: $1

13351

Try \`$0 --help' for more information." >&2;}

13352

{ (exit 1); exit 1; }; } ;;

13353

13354

*) ac_config_targets="$ac_config_targets $1" ;;

13355

13356

esac

13357

shift

13358

done

13359

13360

ac_configure_extra_args=

13361

13362

if $ac_cs_silent; then

13363

exec 6>/dev/null

13364

ac_configure_extra_args="$ac_configure_extra_args --silent"

13365

13366

13367

_ACEOF

13368

cat >>$CONFIG_STATUS <<_ACEOF

13369

if \$ac_cs_recheck; then

13370

echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6

13371

exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion

13372

13373

13374

_ACEOF

13375

13376

cat >>$CONFIG_STATUS <<_ACEOF

13377

13378

# INIT-COMMANDS section.

13379

13380

13381

AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"

13382

# Capture the value of obsolete ALL_LINGUAS because we need it to compute

13383

# POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it

13384

# from automake.

13385

eval 'ALL_LINGUAS''="$ALL_LINGUAS"'

13386

# Capture the value of LINGUAS because we need it to compute CATALOGS.

13387

LINGUAS="${LINGUAS-%UNSET%}"

13388

13389

13390

_ACEOF

13391

13392

13393

13394

cat >>$CONFIG_STATUS <<\_ACEOF

13395

for ac_config_target in $ac_config_targets

13396

13397

case "$ac_config_target" in

13398

# Handling of arguments.

13399

"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;

13400

"lib/Makefile" ) CONFIG_FILES="$CONFIG_FILES lib/Makefile" ;;

13401

"m4/Makefile" ) CONFIG_FILES="$CONFIG_FILES m4/Makefile" ;;

13402

"po/Makefile" ) CONFIG_FILES="$CONFIG_FILES po/Makefile" ;;

13403

"depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;

13404

"default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;

13405

"config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;

13406

*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5

13407

echo "$as_me: error: invalid argument: $ac_config_target" >&2;}

13408

{ (exit 1); exit 1; }; };;

13409

esac

13410

done

13411

13412

# If the user did not use the arguments to specify the items to instantiate,

13413

# then the envvar interface is used. Set only those that are not.

13414

# We use the long form for the default assignment because of an extremely

13415

# bizarre bug on SunOS 4.1.3.

13416

if $ac_need_defaults; then

13417

test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files

13418

test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers

13419

test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands

13420

13421

13422

# Have a temporary directory for convenience. Make it in the build tree

13423

# simply because there is no reason to put it here, and in addition,

13424

# creating and moving files from /tmp can sometimes cause problems.

13425

# Create a temporary directory, and hook for its removal unless debugging.

13426

$debug ||

13427

{

13428

trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0

13429

trap '{ (exit 1); exit 1; }' 1 2 13 15

13430

}

13431

13432

# Create a (secure) tmp directory for tmp files.

13433

13434

{

13435

tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&

13436

test -n "$tmp" && test -d "$tmp"

13437

} ||

13438

{

13439

tmp=./confstat$$-$RANDOM

13440

(umask 077 && mkdir $tmp)

13441

} ||

13442

{

13443

echo "$me: cannot create a temporary directory in ." >&2

13444

{ (exit 1); exit 1; }

13445

}

13446

13447

_ACEOF

13448

13449

cat >>$CONFIG_STATUS <<_ACEOF

13450

13451

13452

# CONFIG_FILES section.

13453

13454

13455

# No need to generate the scripts if there are no CONFIG_FILES.

13456

# This happens for instance when ./config.status config.h

13457

if test -n "\$CONFIG_FILES"; then

13458

# Protect against being on the right side of a sed subst in config.status.

13459

sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;

13460

s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF

13461

s,@SHELL@,$SHELL,;t t

13462

s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t

13463

s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t

13464

s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t

13465

s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t

13466

s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t

13467

s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t

13468

s,@exec_prefix@,$exec_prefix,;t t

13469

s,@prefix@,$prefix,;t t

13470

s,@program_transform_name@,$program_transform_name,;t t

13471

s,@bindir@,$bindir,;t t

13472

s,@sbindir@,$sbindir,;t t

13473

s,@libexecdir@,$libexecdir,;t t

13474

s,@datadir@,$datadir,;t t

13475

s,@sysconfdir@,$sysconfdir,;t t

13476

s,@sharedstatedir@,$sharedstatedir,;t t

13477

s,@localstatedir@,$localstatedir,;t t

13478

s,@libdir@,$libdir,;t t

13479

s,@includedir@,$includedir,;t t

13480

s,@oldincludedir@,$oldincludedir,;t t

13481

s,@infodir@,$infodir,;t t

13482

s,@mandir@,$mandir,;t t

13483

s,@build_alias@,$build_alias,;t t

13484

s,@host_alias@,$host_alias,;t t

13485

s,@target_alias@,$target_alias,;t t

13486

s,@DEFS@,$DEFS,;t t

13487

s,@ECHO_C@,$ECHO_C,;t t

13488

s,@ECHO_N@,$ECHO_N,;t t

13489

s,@ECHO_T@,$ECHO_T,;t t

13490

s,@LIBS@,$LIBS,;t t

13491

s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t

13492

s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t

13493

s,@INSTALL_DATA@,$INSTALL_DATA,;t t

13494

s,@CYGPATH_W@,$CYGPATH_W,;t t

13495

s,@PACKAGE@,$PACKAGE,;t t

13496

s,@VERSION@,$VERSION,;t t

13497

s,@ACLOCAL@,$ACLOCAL,;t t

13498

s,@AUTOCONF@,$AUTOCONF,;t t

13499

s,@AUTOMAKE@,$AUTOMAKE,;t t

13500

s,@AUTOHEADER@,$AUTOHEADER,;t t

13501

s,@MAKEINFO@,$MAKEINFO,;t t

13502

s,@AMTAR@,$AMTAR,;t t

13503

s,@install_sh@,$install_sh,;t t

13504

s,@STRIP@,$STRIP,;t t

13505

s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t

13506

s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t

13507

s,@AWK@,$AWK,;t t

13508

s,@SET_MAKE@,$SET_MAKE,;t t

13509

s,@am__leading_dot@,$am__leading_dot,;t t

13510

s,@CC@,$CC,;t t

13511

s,@CFLAGS@,$CFLAGS,;t t

13512

s,@LDFLAGS@,$LDFLAGS,;t t

13513

s,@CPPFLAGS@,$CPPFLAGS,;t t

13514

s,@ac_ct_CC@,$ac_ct_CC,;t t

13515

s,@EXEEXT@,$EXEEXT,;t t

13516

s,@OBJEXT@,$OBJEXT,;t t

13517

s,@DEPDIR@,$DEPDIR,;t t

13518

s,@am__include@,$am__include,;t t

13519

s,@am__quote@,$am__quote,;t t

13520

s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t

13521

s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t

13522

s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t

13523

s,@CCDEPMODE@,$CCDEPMODE,;t t

13524

s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t

13525

s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t

13526

s,@RANLIB@,$RANLIB,;t t

13527

s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t

13528

s,@CPP@,$CPP,;t t

13529

s,@EGREP@,$EGREP,;t t

13530

s,@ALLOCA@,$ALLOCA,;t t

13531

s,@ALLOCA_H@,$ALLOCA_H,;t t

13532

s,@LIBOBJS@,$LIBOBJS,;t t

13533

s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t

13534

s,@MSGFMT@,$MSGFMT,;t t

13535

s,@GMSGFMT@,$GMSGFMT,;t t

13536

s,@XGETTEXT@,$XGETTEXT,;t t

13537

s,@MSGMERGE@,$MSGMERGE,;t t

13538

s,@build@,$build,;t t

13539

s,@build_cpu@,$build_cpu,;t t

13540

s,@build_vendor@,$build_vendor,;t t

13541

s,@build_os@,$build_os,;t t

13542

s,@host@,$host,;t t

13543

s,@host_cpu@,$host_cpu,;t t

13544

s,@host_vendor@,$host_vendor,;t t

13545

s,@host_os@,$host_os,;t t

13546

s,@USE_NLS@,$USE_NLS,;t t

13547

s,@LIBICONV@,$LIBICONV,;t t

13548

s,@LTLIBICONV@,$LTLIBICONV,;t t

13549

s,@INTLLIBS@,$INTLLIBS,;t t

13550

s,@LIBINTL@,$LIBINTL,;t t

13551

s,@LTLIBINTL@,$LTLIBINTL,;t t

13552

s,@POSUB@,$POSUB,;t t

13553

s,@LTLIBOBJS@,$LTLIBOBJS,;t t

13554

CEOF

13555

13556

_ACEOF

13557

13558

cat >>$CONFIG_STATUS <<\_ACEOF

13559

# Split the substitutions into bite-sized pieces for seds with

13560

# small command number limits, like on Digital OSF/1 and HP-UX.

13561

ac_max_sed_lines=48

13562

ac_sed_frag=1 # Number of current file.

13563

ac_beg=1 # First line for current file.

13564

ac_end=$ac_max_sed_lines # Line after last line for current file.

13565

ac_more_lines=:

13566

ac_sed_cmds=

13567

while $ac_more_lines; do

13568

if test $ac_beg -gt 1; then

13569

sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

13570

else

13571

sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

13572

13573

if test ! -s $tmp/subs.frag; then

13574

ac_more_lines=false

13575

else

13576

# The purpose of the label and of the branching condition is to

13577

# speed up the sed processing (if there are no `@' at all, there

13578

# is no need to browse any of the substitutions).

13579

# These are the two extra sed commands mentioned above.

13580

(echo ':t

13581

/@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed

13582

if test -z "$ac_sed_cmds"; then

13583

ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"

13584

else

13585

ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"

13586

13587

ac_sed_frag=`expr $ac_sed_frag + 1`

13588

ac_beg=$ac_end

13589

ac_end=`expr $ac_end + $ac_max_sed_lines`

13590

13591

done

13592

if test -z "$ac_sed_cmds"; then

13593

ac_sed_cmds=cat

13594

13595

fi # test -n "$CONFIG_FILES"

13596

13597

_ACEOF

13598

cat >>$CONFIG_STATUS <<\_ACEOF

13599

for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue

13600

# Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

13601

case $ac_file in

13602

- | *:- | *:-:* ) # input from stdin

13603

cat >$tmp/stdin

13604

ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

13605

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

13606

*:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

13607

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

13608

* ) ac_file_in=$ac_file.in ;;

13609

esac

13610

13611

# Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.

13612

ac_dir=`(dirname "$ac_file") 2>/dev/null ||

13613

$as_expr X"$ac_file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

13614

X"$ac_file" : 'X$//$[^/]' \| \

13615

X"$ac_file" : 'X$//$$' \| \

13616

X"$ac_file" : 'X$/$' \| \

13617

. : '$.$' 2>/dev/null ||

13618

echo X"$ac_file" |

13619

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

13620

/^X$\/\/$[^/].*/{ s//\1/; q; }

13621

/^X$\/\/$$/{ s//\1/; q; }

13622

/^X$\/$.*/{ s//\1/; q; }

13623

s/.*/./; q'`

13624

{ if $as_mkdir_p; then

13625

mkdir -p "$ac_dir"

13626

else

13627

as_dir="$ac_dir"

13628

as_dirs=

13629

while test ! -d "$as_dir"; do

13630

as_dirs="$as_dir $as_dirs"

13631

as_dir=`(dirname "$as_dir") 2>/dev/null ||

13632

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

13633

X"$as_dir" : 'X$//$[^/]' \| \

13634

X"$as_dir" : 'X$//$$' \| \

13635

X"$as_dir" : 'X$/$' \| \

13636

. : '$.$' 2>/dev/null ||

13637

echo X"$as_dir" |

13638

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

13639

/^X$\/\/$[^/].*/{ s//\1/; q; }

13640

/^X$\/\/$$/{ s//\1/; q; }

13641

/^X$\/$.*/{ s//\1/; q; }

13642

s/.*/./; q'`

13643

done

13644

test ! -n "$as_dirs" || mkdir $as_dirs

13645

fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

13646

echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

13647

{ (exit 1); exit 1; }; }; }

13648

13649

ac_builddir=.

13650

13651

if test "$ac_dir" != .; then

13652

ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

13653

# A "../" for each directory in $ac_dir_suffix.

13654

ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

13655

else

13656

ac_dir_suffix= ac_top_builddir=

13657

13658

13659

case $srcdir in

13660

.) # No --srcdir option. We are building in place.

13661

ac_srcdir=.

13662

if test -z "$ac_top_builddir"; then

13663

ac_top_srcdir=.

13664

else

13665

ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

13666

fi ;;

13667

[\\/]* | ?:[\\/]* ) # Absolute path.

13668

ac_srcdir=$srcdir$ac_dir_suffix;

13669

ac_top_srcdir=$srcdir ;;

13670

*) # Relative path.

13671

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

13672

ac_top_srcdir=$ac_top_builddir$srcdir ;;

13673

esac

13674

# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be

13675

# absolute.

13676

ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`

13677

ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`

13678

ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`

13679

ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`

13680

13681

13682

case $INSTALL in

13683

[\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;

13684

*) ac_INSTALL=$ac_top_builddir$INSTALL ;;

13685

esac

13686

13687

if test x"$ac_file" != x-; then

13688

{ echo "$as_me:$LINENO: creating $ac_file" >&5

13689

echo "$as_me: creating $ac_file" >&6;}

13690

rm -f "$ac_file"

13691

13692

# Let's still pretend it is `configure' which instantiates (i.e., don't

13693

# use $as_me), people would be surprised to read:

13694

# /* config.h. Generated by config.status. */

13695

if test x"$ac_file" = x-; then

13696

configure_input=

13697

else

13698

configure_input="$ac_file. "

13699

13700

configure_input=$configure_input"Generated from `echo $ac_file_in |

13701

sed 's,.*/,,'` by configure."

13702

13703

# First look for the input files in the build tree, otherwise in the

13704

# src tree.

13705

ac_file_inputs=`IFS=:

13706

for f in $ac_file_in; do

13707

case $f in

13708

-) echo $tmp/stdin ;;

13709

[\\/$]*)

13710

# Absolute (can't be DOS-style, as IFS=:)

13711

test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

13712

echo "$as_me: error: cannot find input file: $f" >&2;}

13713

{ (exit 1); exit 1; }; }

13714

echo $f;;

13715

*) # Relative

13716

if test -f "$f"; then

13717

# Build tree

13718

echo $f

13719

elif test -f "$srcdir/$f"; then

13720

# Source tree

13721

echo $srcdir/$f

13722

else

13723

# /dev/null tree

13724

{ { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

13725

echo "$as_me: error: cannot find input file: $f" >&2;}

13726

{ (exit 1); exit 1; }; }

13727

fi;;

13728

esac

13729

done` || { (exit 1); exit 1; }

13730

_ACEOF

13731

cat >>$CONFIG_STATUS <<_ACEOF

13732

sed "$ac_vpsub

13733

$extrasub

13734

_ACEOF

13735

cat >>$CONFIG_STATUS <<\_ACEOF

13736

13737

/@[a-zA-Z_][a-zA-Z_0-9]*@/!b

13738

s,@configure_input@,$configure_input,;t t

13739

s,@srcdir@,$ac_srcdir,;t t

13740

s,@abs_srcdir@,$ac_abs_srcdir,;t t

13741

s,@top_srcdir@,$ac_top_srcdir,;t t

13742

s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t

13743

s,@builddir@,$ac_builddir,;t t

13744

s,@abs_builddir@,$ac_abs_builddir,;t t

13745

s,@top_builddir@,$ac_top_builddir,;t t

13746

s,@abs_top_builddir@,$ac_abs_top_builddir,;t t

13747

s,@INSTALL@,$ac_INSTALL,;t t

13748

" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out

13749

rm -f $tmp/stdin

13750

if test x"$ac_file" != x-; then

13751

mv $tmp/out $ac_file

13752

else

13753

cat $tmp/out

13754

rm -f $tmp/out

13755

13756

13757

done

13758

_ACEOF

13759

cat >>$CONFIG_STATUS <<\_ACEOF

13760

13761

13762

# CONFIG_HEADER section.

13763

13764

13765

# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where

13766

# NAME is the cpp macro being defined and VALUE is the value it is being given.

13767

13768

# ac_d sets the value in "#define NAME VALUE" lines.

13769

ac_dA='s,^$[ ]*$#$[ ]*define[ ][ ]*$'

13770

ac_dB='[ ].*$,\1#\2'

13771

ac_dC=' '

13772

ac_dD=',;t'

13773

# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".

13774

ac_uA='s,^$[ ]*$#$[ ]*$undef$[ ][ ]*$'

13775

ac_uB='$,\1#\2define\3'

13776

ac_uC=' '

13777

ac_uD=',;t'

13778

13779

for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue

13780

# Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

13781

case $ac_file in

13782

- | *:- | *:-:* ) # input from stdin

13783

cat >$tmp/stdin

13784

ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

13785

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

13786

*:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

13787

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

13788

* ) ac_file_in=$ac_file.in ;;

13789

esac

13790

13791

test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5

13792

echo "$as_me: creating $ac_file" >&6;}

13793

13794

# First look for the input files in the build tree, otherwise in the

13795

# src tree.

13796

ac_file_inputs=`IFS=:

13797

for f in $ac_file_in; do

13798

case $f in

13799

-) echo $tmp/stdin ;;

13800

[\\/$]*)

13801

# Absolute (can't be DOS-style, as IFS=:)

13802

test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

13803

echo "$as_me: error: cannot find input file: $f" >&2;}

13804

{ (exit 1); exit 1; }; }

13805

echo $f;;

13806

*) # Relative

13807

if test -f "$f"; then

13808

# Build tree

13809

echo $f

13810

elif test -f "$srcdir/$f"; then

13811

# Source tree

13812

echo $srcdir/$f

13813

else

13814

# /dev/null tree

13815

{ { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

13816

echo "$as_me: error: cannot find input file: $f" >&2;}

13817

{ (exit 1); exit 1; }; }

13818

fi;;

13819

esac

13820

done` || { (exit 1); exit 1; }

13821

# Remove the trailing spaces.

13822

sed 's/[ ]*$//' $ac_file_inputs >$tmp/in

13823

13824

_ACEOF

13825

13826

# Transform confdefs.h into two sed scripts, `conftest.defines' and

13827

# `conftest.undefs', that substitutes the proper values into

13828

# config.h.in to produce config.h. The first handles `#define'

13829

# templates, and the second `#undef' templates.

13830

# And first: Protect against being on the right side of a sed subst in

13831

# config.status. Protect against being in an unquoted here document

13832

# in config.status.

13833

rm -f conftest.defines conftest.undefs

13834

# Using a here document instead of a string reduces the quoting nightmare.

13835

# Putting comments in sed scripts is not portable.

13836

13837

# `end' is used to avoid that the second main sed command (meant for

13838

# 0-ary CPP macros) applies to n-ary macro definitions.

13839

# See the Autoconf documentation for `clear'.

13840

cat >confdef2sed.sed <<\_ACEOF

13841

s/[\\&,]/\\&/g

13842

s,[\\$`],\\&,g

13843

t clear

13844

: clear

13845

s,^[ ]*#[ ]*define[ ][ ]*$[^ (][^ (]*$$([^)]*)$[ ]*$.*$$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp

13846

t end

13847

s,^[ ]*#[ ]*define[ ][ ]*$[^ ][^ ]*$[ ]*$.*$$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp

13848

: end

13849

_ACEOF

13850

# If some macros were called several times there might be several times

13851

# the same #defines, which is useless. Nevertheless, we may not want to

13852

# sort them, since we want the *last* AC-DEFINE to be honored.

13853

uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines

13854

sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs

13855

rm -f confdef2sed.sed

13856

13857

# This sed command replaces #undef with comments. This is necessary, for

13858

# example, in the case of _POSIX_SOURCE, which is predefined and required

13859

# on some systems where configure will not decide to define it.

13860

cat >>conftest.undefs <<\_ACEOF

13861

s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,

13862

_ACEOF

13863

13864

# Break up conftest.defines because some shells have a limit on the size

13865

# of here documents, and old seds have small limits too (100 cmds).

13866

echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS

13867

echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS

13868

echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS

13869

echo ' :' >>$CONFIG_STATUS

13870

rm -f conftest.tail

13871

while grep . conftest.defines >/dev/null

13872

13873

# Write a limited-size here document to $tmp/defines.sed.

13874

echo ' cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS

13875

# Speed up: don't consider the non `#define' lines.

13876

echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS

13877

# Work around the forget-to-reset-the-flag bug.

13878

echo 't clr' >>$CONFIG_STATUS

13879

echo ': clr' >>$CONFIG_STATUS

13880

sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS

13881

echo 'CEOF

13882

sed -f $tmp/defines.sed $tmp/in >$tmp/out

13883

rm -f $tmp/in

13884

mv $tmp/out $tmp/in

13885

' >>$CONFIG_STATUS

13886

sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail

13887

rm -f conftest.defines

13888

mv conftest.tail conftest.defines

13889

done

13890

rm -f conftest.defines

13891

echo ' fi # grep' >>$CONFIG_STATUS

13892

echo >>$CONFIG_STATUS

13893

13894

# Break up conftest.undefs because some shells have a limit on the size

13895

# of here documents, and old seds have small limits too (100 cmds).

13896

echo ' # Handle all the #undef templates' >>$CONFIG_STATUS

13897

rm -f conftest.tail

13898

while grep . conftest.undefs >/dev/null

13899

13900

# Write a limited-size here document to $tmp/undefs.sed.

13901

echo ' cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS

13902

# Speed up: don't consider the non `#undef'

13903

echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS

13904

# Work around the forget-to-reset-the-flag bug.

13905

echo 't clr' >>$CONFIG_STATUS

13906

echo ': clr' >>$CONFIG_STATUS

13907

sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS

13908

echo 'CEOF

13909

sed -f $tmp/undefs.sed $tmp/in >$tmp/out

13910

rm -f $tmp/in

13911

mv $tmp/out $tmp/in

13912

' >>$CONFIG_STATUS

13913

sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail

13914

rm -f conftest.undefs

13915

mv conftest.tail conftest.undefs

13916

done

13917

rm -f conftest.undefs

13918

13919

cat >>$CONFIG_STATUS <<\_ACEOF

13920

# Let's still pretend it is `configure' which instantiates (i.e., don't

13921

# use $as_me), people would be surprised to read:

13922

# /* config.h. Generated by config.status. */

13923

if test x"$ac_file" = x-; then

13924

echo "/* Generated by configure. */" >$tmp/config.h

13925

else

13926

echo "/* $ac_file. Generated by configure. */" >$tmp/config.h

13927

13928

cat $tmp/in >>$tmp/config.h

13929

rm -f $tmp/in

13930

if test x"$ac_file" != x-; then

13931

if diff $ac_file $tmp/config.h >/dev/null 2>&1; then

13932

{ echo "$as_me:$LINENO: $ac_file is unchanged" >&5

13933

echo "$as_me: $ac_file is unchanged" >&6;}

13934

else

13935

ac_dir=`(dirname "$ac_file") 2>/dev/null ||

13936

$as_expr X"$ac_file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

13937

X"$ac_file" : 'X$//$[^/]' \| \

13938

X"$ac_file" : 'X$//$$' \| \

13939

X"$ac_file" : 'X$/$' \| \

13940

. : '$.$' 2>/dev/null ||

13941

echo X"$ac_file" |

13942

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

13943

/^X$\/\/$[^/].*/{ s//\1/; q; }

13944

/^X$\/\/$$/{ s//\1/; q; }

13945

/^X$\/$.*/{ s//\1/; q; }

13946

s/.*/./; q'`

13947

{ if $as_mkdir_p; then

13948

mkdir -p "$ac_dir"

13949

else

13950

as_dir="$ac_dir"

13951

as_dirs=

13952

while test ! -d "$as_dir"; do

13953

as_dirs="$as_dir $as_dirs"

13954

as_dir=`(dirname "$as_dir") 2>/dev/null ||

13955

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

13956

X"$as_dir" : 'X$//$[^/]' \| \

13957

X"$as_dir" : 'X$//$$' \| \

13958

X"$as_dir" : 'X$/$' \| \

13959

. : '$.$' 2>/dev/null ||

13960

echo X"$as_dir" |

13961

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

13962

/^X$\/\/$[^/].*/{ s//\1/; q; }

13963

/^X$\/\/$$/{ s//\1/; q; }

13964

/^X$\/$.*/{ s//\1/; q; }

13965

s/.*/./; q'`

13966

done

13967

test ! -n "$as_dirs" || mkdir $as_dirs

13968

fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

13969

echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

13970

{ (exit 1); exit 1; }; }; }

13971

13972

rm -f $ac_file

13973

mv $tmp/config.h $ac_file

13974

13975

else

13976

cat $tmp/config.h

13977

rm -f $tmp/config.h

13978

13979

# Compute $ac_file's index in $config_headers.

13980

_am_stamp_count=1

13981

for _am_header in $config_headers :; do

13982

case $_am_header in

13983

$ac_file | $ac_file:* )

13984

break ;;

13985

* )

13986

_am_stamp_count=`expr $_am_stamp_count + 1` ;;

13987

esac

13988

done

13989

echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||

13990

$as_expr X$ac_file : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

13991

X$ac_file : 'X$//$[^/]' \| \

13992

X$ac_file : 'X$//$$' \| \

13993

X$ac_file : 'X$/$' \| \

13994

. : '$.$' 2>/dev/null ||

13995

echo X$ac_file |

13996

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

13997

/^X$\/\/$[^/].*/{ s//\1/; q; }

13998

/^X$\/\/$$/{ s//\1/; q; }

13999

/^X$\/$.*/{ s//\1/; q; }

14000

s/.*/./; q'`/stamp-h$_am_stamp_count

14001

done

14002

_ACEOF

14003

cat >>$CONFIG_STATUS <<\_ACEOF

14004

14005

14006

# CONFIG_COMMANDS section.

14007

14008

for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue

14009

ac_dest=`echo "$ac_file" | sed 's,:.*,,'`

14010

ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`

14011

ac_dir=`(dirname "$ac_dest") 2>/dev/null ||

14012

$as_expr X"$ac_dest" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

14013

X"$ac_dest" : 'X$//$[^/]' \| \

14014

X"$ac_dest" : 'X$//$$' \| \

14015

X"$ac_dest" : 'X$/$' \| \

14016

. : '$.$' 2>/dev/null ||

14017

echo X"$ac_dest" |

14018

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

14019

/^X$\/\/$[^/].*/{ s//\1/; q; }

14020

/^X$\/\/$$/{ s//\1/; q; }

14021

/^X$\/$.*/{ s//\1/; q; }

14022

s/.*/./; q'`

14023

ac_builddir=.

14024

14025

if test "$ac_dir" != .; then

14026

ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

14027

# A "../" for each directory in $ac_dir_suffix.

14028

ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

14029

else

14030

ac_dir_suffix= ac_top_builddir=

14031

14032

14033

case $srcdir in

14034

.) # No --srcdir option. We are building in place.

14035

ac_srcdir=.

14036

if test -z "$ac_top_builddir"; then

14037

ac_top_srcdir=.

14038

else

14039

ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

14040

fi ;;

14041

[\\/]* | ?:[\\/]* ) # Absolute path.

14042

ac_srcdir=$srcdir$ac_dir_suffix;

14043

ac_top_srcdir=$srcdir ;;

14044

*) # Relative path.

14045

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

14046

ac_top_srcdir=$ac_top_builddir$srcdir ;;

14047

esac

14048

# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be

14049

# absolute.

14050

ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`

14051

ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`

14052

ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`

14053

ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`

14054

14055

14056

{ echo "$as_me:$LINENO: executing $ac_dest commands" >&5

14057

echo "$as_me: executing $ac_dest commands" >&6;}

14058

case $ac_dest in

14059

depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do

14060

# Strip MF so we end up with the name of the file.

14061

mf=`echo "$mf" | sed -e 's/:.*$//'`

14062

# Check whether this is an Automake generated Makefile or not.

14063

# We used to match only the files named `Makefile.in', but

14064

# some people rename them; so instead we look at the file content.

14065

# Grep'ing the first line is not enough: some people post-process

14066

# each Makefile.in and add a new line on top of each file to say so.

14067

# So let's grep whole file.

14068

if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then

14069

dirpart=`(dirname "$mf") 2>/dev/null ||

14070

$as_expr X"$mf" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

14071

X"$mf" : 'X$//$[^/]' \| \

14072

X"$mf" : 'X$//$$' \| \

14073

X"$mf" : 'X$/$' \| \

14074

. : '$.$' 2>/dev/null ||

14075

echo X"$mf" |

14076

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

14077

/^X$\/\/$[^/].*/{ s//\1/; q; }

14078

/^X$\/\/$$/{ s//\1/; q; }

14079

/^X$\/$.*/{ s//\1/; q; }

14080

s/.*/./; q'`

14081

else

14082

continue

14083

14084

grep '^DEP_FILES *= *[^ #]' < "$mf" > /dev/null || continue

14085

# Extract the definition of DEP_FILES from the Makefile without

14086

# running `make'.

14087

DEPDIR=`sed -n -e '/^DEPDIR = / s///p' < "$mf"`

14088

test -z "$DEPDIR" && continue

14089

# When using ansi2knr, U may be empty or an underscore; expand it

14090

U=`sed -n -e '/^U = / s///p' < "$mf"`

14091

test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR"

14092

# We invoke sed twice because it is the simplest approach to

14093

# changing $(DEPDIR) to its actual value in the expansion.

14094

for file in `sed -n -e '

14095

/^DEP_FILES = .*\\\\$/ {

14096

s/^DEP_FILES = //

14097

:loop

14098

s/\\\\$//

14099

14100

14101

/\\\\$/ b loop

14102

14103

}

14104

/^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \

14105

sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

14106

# Make sure the directory exists.

14107

test -f "$dirpart/$file" && continue

14108

fdir=`(dirname "$file") 2>/dev/null ||

14109

$as_expr X"$file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

14110

X"$file" : 'X$//$[^/]' \| \

14111

X"$file" : 'X$//$$' \| \

14112

X"$file" : 'X$/$' \| \

14113

. : '$.$' 2>/dev/null ||

14114

echo X"$file" |

14115

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

14116

/^X$\/\/$[^/].*/{ s//\1/; q; }

14117

/^X$\/\/$$/{ s//\1/; q; }

14118

/^X$\/$.*/{ s//\1/; q; }

14119

s/.*/./; q'`

14120

{ if $as_mkdir_p; then

14121

mkdir -p $dirpart/$fdir

14122

else

14123

as_dir=$dirpart/$fdir

14124

as_dirs=

14125

while test ! -d "$as_dir"; do

14126

as_dirs="$as_dir $as_dirs"

14127

as_dir=`(dirname "$as_dir") 2>/dev/null ||

14128

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

14129

X"$as_dir" : 'X$//$[^/]' \| \

14130

X"$as_dir" : 'X$//$$' \| \

14131

X"$as_dir" : 'X$/$' \| \

14132

. : '$.$' 2>/dev/null ||

14133

echo X"$as_dir" |

14134

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

14135

/^X$\/\/$[^/].*/{ s//\1/; q; }

14136

/^X$\/\/$$/{ s//\1/; q; }

14137

/^X$\/$.*/{ s//\1/; q; }

14138

s/.*/./; q'`

14139

done

14140

test ! -n "$as_dirs" || mkdir $as_dirs

14141

fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5

14142

echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}

14143

{ (exit 1); exit 1; }; }; }

14144

14145

# echo "creating $dirpart/$file"

14146

echo '# dummy' > "$dirpart/$file"

14147

done

14148

done

14149

;;

14150

default-1 )

14151

for ac_file in $CONFIG_FILES; do

14152

# Support "outfile[:infile[:infile...]]"

14153

case "$ac_file" in

14154

*:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;

14155

esac

14156

# PO directories have a Makefile.in generated from Makefile.in.in.

14157

case "$ac_file" in */Makefile.in)

14158

# Adjust a relative srcdir.

14159

ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'`

14160

ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`"

14161

ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'`

14162

# In autoconf-2.13 it is called $ac_given_srcdir.

14163

# In autoconf-2.50 it is called $srcdir.

14164

test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir"

14165

case "$ac_given_srcdir" in

14166

.) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;;

14167

/*) top_srcdir="$ac_given_srcdir" ;;

14168

*) top_srcdir="$ac_dots$ac_given_srcdir" ;;

14169

esac

14170

if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then

14171

rm -f "$ac_dir/POTFILES"

14172

test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES"

14173

cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/$.*$ \\\\/\1/" > "$ac_dir/POTFILES"

14174

# ALL_LINGUAS, POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES depend

14175

# on $ac_dir but don't depend on user-specified configuration

14176

# parameters.

14177

if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then

14178

# The LINGUAS file contains the set of available languages.

14179

if test -n "$ALL_LINGUAS"; then

14180

test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete"

14181

14182

ALL_LINGUAS_=`sed -e "/^#/d" "$ac_given_srcdir/$ac_dir/LINGUAS"`

14183

# Hide the ALL_LINGUAS assigment from automake.

14184

eval 'ALL_LINGUAS''=$ALL_LINGUAS_'

14185

14186

case "$ac_given_srcdir" in

14187

.) srcdirpre= ;;

14188

*) srcdirpre='$(srcdir)/' ;;

14189

esac

14190

POFILES=

14191

GMOFILES=

14192

UPDATEPOFILES=

14193

DUMMYPOFILES=

14194

for lang in $ALL_LINGUAS; do

14195

POFILES="$POFILES $srcdirpre$lang.po"

14196

GMOFILES="$GMOFILES $srcdirpre$lang.gmo"

14197

UPDATEPOFILES="$UPDATEPOFILES $lang.po-update"

14198

DUMMYPOFILES="$DUMMYPOFILES $lang.nop"

14199

done

14200

# CATALOGS depends on both $ac_dir and the user's LINGUAS

14201

# environment variable.

14202

INST_LINGUAS=

14203

if test -n "$ALL_LINGUAS"; then

14204

for presentlang in $ALL_LINGUAS; do

14205

useit=no

14206

if test "%UNSET%" != "$LINGUAS"; then

14207

desiredlanguages="$LINGUAS"

14208

else

14209

desiredlanguages="$ALL_LINGUAS"

14210

14211

for desiredlang in $desiredlanguages; do

14212

# Use the presentlang catalog if desiredlang is

14213

# a. equal to presentlang, or

14214

# b. a variant of presentlang (because in this case,

14215

# presentlang can be used as a fallback for messages

14216

# which are not translated in the desiredlang catalog).

14217

case "$desiredlang" in

14218

"$presentlang"*) useit=yes;;

14219

esac

14220

done

14221

if test $useit = yes; then

14222

INST_LINGUAS="$INST_LINGUAS $presentlang"

14223

14224

done

14225

14226

CATALOGS=

14227

if test -n "$INST_LINGUAS"; then

14228

for lang in $INST_LINGUAS; do

14229

CATALOGS="$CATALOGS $lang.gmo"

14230

done

14231

14232

test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile"

14233

14234

for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do

14235

if test -f "$f"; then

14236

case "$f" in

14237

*.orig | *.bak | *~) ;;

14238

*) cat "$f" >> "$ac_dir/Makefile" ;;

14239

esac

14240

14241

done

14242

14243

;;

14244

esac

14245

done ;;

14246

esac

14247

done

14248

_ACEOF

14249

14250

cat >>$CONFIG_STATUS <<\_ACEOF

14251

14252

{ (exit 0); exit 0; }

14253

_ACEOF

14254

chmod +x $CONFIG_STATUS

14255

ac_clean_files=$ac_clean_files_save

14256

14257

14258

# configure is writing to config.log, and then calls config.status.

14259

# config.status does its own redirection, appending to config.log.

14260

# Unfortunately, on DOS this fails, as config.log is still kept open

14261

# by configure, so config.status won't be able to write to it; its

14262

# output is simply discarded. So we exec the FD to /dev/null,

14263

# effectively closing config.log, so it can be properly (re)opened and

14264

# appended to by config.status. When coming back to configure, we

14265

# need to make the FD available again.

14266

if test "$no_create" != yes; then

14267

ac_cs_success=:

14268

ac_config_status_args=

14269

test "$silent" = yes &&

14270

ac_config_status_args="$ac_config_status_args --quiet"

14271

exec 5>/dev/null

14272

$SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false

14273

exec 5>>config.log

14274

# Use ||, not &&, to avoid exiting from the if with $? = 1, which

14275

# would make configure fail if this is the last instruction.

14276

$ac_cs_success || { (exit 1); exit 1; }

14277

14278

Older »