From 9e6f5f1f2f68f8fc7f0b0f1f711c9fb2af6d0213 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 16:11:20 -0400 Subject: [PATCH 01/11] perf(os): add os_aio abstraction with synchronous backend (Stage 2) Introduce a thin, pluggable async-I/O layer (DB_AIO_CONTEXT) the buffer pool will use to prefetch pages and trickle dirty pages without blocking a foreground thread on a device write. This commit lands the interface and the behaviour-preserving synchronous backend: submit performs the I/O inline via __os_io and runs the completion immediately; reap is a no-op; available() is 0. Platform backends (Linux io_uring first) plug in through DB_AIO_BACKEND and override submit/reap/cancel; the synchronous path remains the universal fallback. Registered in dist/srcfiles.in and dist/Makefile.in. Validated: full library builds and links; an internal-API unit test round-trips a 512B page through submit(WRITE)+submit(READ)+reap with correct data and two completions. Not yet wired into mpool -- the io_uring backend and the trickle/prefetch integration (which carry write-path data-integrity requirements) are the next step on this branch. --- dist/Makefile.in | 4 +- dist/srcfiles.in | 1 + src/dbinc/os_aio.h | 78 +++++++++++++++++++++++++++ src/os/os_aio.c | 130 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 212 insertions(+), 1 deletion(-) create mode 100644 src/dbinc/os_aio.h create mode 100644 src/os/os_aio.c diff --git a/dist/Makefile.in b/dist/Makefile.in index 00648a182..6b2765239 100644 --- a/dist/Makefile.in +++ b/dist/Makefile.in @@ -281,7 +281,7 @@ DTRACE_OBJS= @ADDITIONAL_OBJS@ @REPLACEMENT_OBJS@ @CRYPTO_OBJS@ \ log_stat@o@ mkpath@o@ mp_alloc@o@ mp_backup@o@ mp_bh@o@ mp_fget@o@ \ mp_fmethod@o@ mp_fopen@o@ mp_fput@o@ mp_fset@o@ mp_method@o@ \ mp_mvcc@o@ mp_region@o@ mp_register@o@ mp_resize@o@ mp_stat@o@ \ - mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ \ + mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ \ os_alloc@o@ os_atomic@o@ os_clock@o@ os_cpu@o@ os_ctime@o@ os_config@o@ \ os_dir@o@ os_errno@o@ os_fid@o@ os_flock@o@ os_fsync@o@ \ os_getenv@o@ os_handle@o@ os_map@o@ os_method@o@ os_mkdir@o@ \ @@ -2239,6 +2239,8 @@ os_abort@o@: $(srcdir)/os/os_abort.c $(CC) $(CFLAGS) $? os_addrinfo@o@: $(srcdir)/os/os_addrinfo.c $(CC) $(CFLAGS) $? +os_aio@o@: $(srcdir)/os/os_aio.c + $(CC) $(CFLAGS) $? os_alloc@o@: $(srcdir)/os/os_alloc.c $(CC) $(CFLAGS) $? os_atomic@o@: $(srcdir)/os/os_atomic.c diff --git a/dist/srcfiles.in b/dist/srcfiles.in index 1e4d2c184..0dc6f9353 100644 --- a/dist/srcfiles.in +++ b/dist/srcfiles.in @@ -253,6 +253,7 @@ src/mutex/mut_win32.c ce_small src/os/os_abort.c android vx vxsmall src/os/os_abs.c android src/os/os_addrinfo.c vx +src/os/os_aio.c android vx vxsmall src/os/os_alloc.c android vx vxsmall src/os/os_clock.c android vx vxsmall src/os/os_config.c android diff --git a/src/dbinc/os_aio.h b/src/dbinc/os_aio.h new file mode 100644 index 000000000..806a7cef8 --- /dev/null +++ b/src/dbinc/os_aio.h @@ -0,0 +1,78 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Asynchronous I/O abstraction (Stage 2). + * + * A thin, pluggable async-I/O layer used by the buffer pool to (a) prefetch + * pages and (b) trickle dirty pages to disk in the background without blocking + * a foreground thread on a device write. The default backend is synchronous + * (submit performs the I/O inline and the completion runs immediately), so the + * abstraction is behaviour-preserving everywhere; platform backends + * (Linux io_uring, BSD/macOS kqueue+aio, Windows IOCP, POSIX aio) override it. + * + * Per-process: an AIO context is owned by the process that created it; in a + * multi-process environment a page marked in-transit by one process is reaped + * only by that process, and other processes fall back to the existing + * in-transit buffer wait (mtx_buf). + */ +#ifndef _DB_OS_AIO_H_ +#define _DB_OS_AIO_H_ + +#if defined(__cplusplus) +extern "C" { +#endif + +struct __db_aio_context; typedef struct __db_aio_context DB_AIO_CONTEXT; +struct __db_aio_op; typedef struct __db_aio_op DB_AIO_OP; + +/* + * Completion callback: invoked (in the reaping thread, or inline for the + * synchronous backend) when an op finishes. "ret" is 0 on success or an + * errno. "cookie" is the caller's opaque pointer (the buffer header). + */ +typedef void (*db_aio_done_fn) __P((ENV *, void *cookie, int ret)); + +/* One outstanding async I/O. */ +struct __db_aio_op { + int op; /* DB_IO_READ / DB_IO_WRITE. */ + DB_FH *fhp; /* Target file. */ + db_pgno_t pgno; /* Page number. */ + u_int32_t pagesize; /* Bytes. */ + void *buf; /* Data buffer (page-aligned). */ + void *cookie; /* Caller context (BH *). */ + db_aio_done_fn done; /* Completion callback. */ +}; + +/* + * Backend vtable. A backend implements submit/reap/cancel; the generic layer + * owns the context lifecycle and the synchronous fallback. + */ +typedef struct __db_aio_backend { + const char *name; + int (*submit) __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); + /* Reap up to max completions; -1 max means "all ready". */ + int (*reap) __P((ENV *, DB_AIO_CONTEXT *, int max, int wait)); + int (*cancel) __P((ENV *, DB_AIO_CONTEXT *)); + int (*destroy) __P((ENV *, DB_AIO_CONTEXT *)); +} DB_AIO_BACKEND; + +/* + * PUBLIC: int __os_aio_create __P((ENV *, u_int32_t, DB_AIO_CONTEXT **)); + * PUBLIC: int __os_aio_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); + * PUBLIC: int __os_aio_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); + * PUBLIC: int __os_aio_destroy __P((ENV *, DB_AIO_CONTEXT *)); + * PUBLIC: int __os_aio_available __P((ENV *)); + */ +int __os_aio_create __P((ENV *, u_int32_t, DB_AIO_CONTEXT **)); +int __os_aio_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +int __os_aio_reap __P((ENV *, DB_AIO_CONTEXT *, int /*max*/, int /*wait*/)); +int __os_aio_destroy __P((ENV *, DB_AIO_CONTEXT *)); +int __os_aio_available __P((ENV *)); /* 1 if a real async backend is active */ + +/* Queue depth requested at create time; backends may clamp. */ +#define DB_AIO_DEFAULT_DEPTH 64 + +#if defined(__cplusplus) +} +#endif +#endif /* !_DB_OS_AIO_H_ */ diff --git a/src/os/os_aio.c b/src/os/os_aio.c new file mode 100644 index 000000000..8ec940eac --- /dev/null +++ b/src/os/os_aio.c @@ -0,0 +1,130 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Asynchronous I/O abstraction -- generic layer + synchronous backend. + * + * The synchronous backend performs each submitted op inline and invokes its + * completion immediately; it is the behaviour-preserving default and the + * fallback when no platform async backend (io_uring/kqueue/IOCP/POSIX aio) is + * available or enabled. Platform backends plug in via DB_AIO_BACKEND. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +struct __db_aio_context { + const DB_AIO_BACKEND *backend; /* Active backend (NULL = synchronous). */ + void *priv; /* Backend-private state. */ + u_int32_t depth; /* Requested queue depth. */ + u_int32_t inflight; /* Ops submitted, not yet reaped. */ +}; + +/* + * __os_aio_create -- + * Create an AIO context. Selects a platform backend if one is available + * and enabled, else uses the synchronous fallback. + */ +int +__os_aio_create(env, depth, ctxp) + ENV *env; + u_int32_t depth; + DB_AIO_CONTEXT **ctxp; +{ + DB_AIO_CONTEXT *ctx; + int ret; + + *ctxp = NULL; + if ((ret = __os_calloc(env, 1, sizeof(DB_AIO_CONTEXT), &ctx)) != 0) + return (ret); + ctx->depth = depth == 0 ? DB_AIO_DEFAULT_DEPTH : depth; + ctx->backend = NULL; /* synchronous fallback */ + ctx->priv = NULL; + ctx->inflight = 0; + + /* + * A platform backend would be probed and installed here, e.g. + * (void)__os_aio_uring_init(env, ctx); + * leaving ctx->backend NULL (synchronous) on failure. Kept as the + * synchronous fallback until the io_uring backend lands. + */ + *ctxp = ctx; + return (0); +} + +/* + * __os_aio_submit -- + * Submit one op. The synchronous backend performs it now and runs the + * completion inline; a real backend queues it for later reaping. + */ +int +__os_aio_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + int ret; + size_t nio; + + if (ctx->backend != NULL) + return (ctx->backend->submit(env, ctx, aio)); + + /* Synchronous fallback: do the I/O now, complete inline. */ + nio = 0; + ret = __os_io(env, aio->op, aio->fhp, aio->pgno, + aio->pagesize, 0, aio->pagesize, (u_int8_t *)aio->buf, &nio); + if (aio->done != NULL) + aio->done(env, aio->cookie, ret); + return (ret); +} + +/* + * __os_aio_reap -- + * Reap up to "max" completions (max < 0 means all ready). For the + * synchronous backend there is never anything outstanding. + */ +int +__os_aio_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + COMPQUIET(env, NULL); + COMPQUIET(max, 0); + COMPQUIET(wait, 0); + if (ctx->backend != NULL) + return (ctx->backend->reap(env, ctx, max, wait)); + return (0); +} + +/* + * __os_aio_destroy -- + * Tear down an AIO context. + */ +int +__os_aio_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + int ret; + + ret = 0; + if (ctx == NULL) + return (0); + if (ctx->backend != NULL && ctx->backend->destroy != NULL) + ret = ctx->backend->destroy(env, ctx); + __os_free(env, ctx); + return (ret); +} + +/* + * __os_aio_available -- + * Return 1 if a real (non-synchronous) async backend is active. + */ +int +__os_aio_available(env) + ENV *env; +{ + COMPQUIET(env, NULL); + return (0); /* synchronous fallback only, for now */ +} From 06e243e6527286f4d7b262ba2a1647d77833d741 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 16:23:10 -0400 Subject: [PATCH 02/11] perf(os): add Linux io_uring backend for os_aio (reuse from libxtc) Add a real asynchronous backend for the Stage 2 os_aio layer on Linux, adapting the io_uring file-I/O mechanics from the XTC Project's libxtc (src/io/io_uring.c, ISC, with the author's permission): SQE acquisition with submit-and-retry on a full ring, io_uring_prep_read/write keyed by DB_AIO_OP, and a CQE drain that maps each completion back to its op and runs the callback. The readiness/poll/wakeup machinery from libxtc is dropped -- the buffer pool only issues file reads/writes. The context struct moves to dbinc/os_aio.h so the backend can attach its vtable + ring; __os_aio_create installs the backend under HAVE_IO_URING and otherwise keeps the synchronous fallback; __os_aio_ctx_available reports whether a context is truly async. Built only with HAVE_IO_URING (else an empty TU); registered in srcfiles.in and Makefile.in. Validated (sync path): local build clean. io_uring path build+round-trip on meh next (liburing built from source). --- dist/Makefile.in | 4 +- dist/srcfiles.in | 1 + src/dbinc/os_aio.h | 21 ++++ src/os/os_aio.c | 31 +++--- src/os/os_aio_uring.c | 223 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 267 insertions(+), 13 deletions(-) create mode 100644 src/os/os_aio_uring.c diff --git a/dist/Makefile.in b/dist/Makefile.in index 6b2765239..0f2b63d6d 100644 --- a/dist/Makefile.in +++ b/dist/Makefile.in @@ -281,7 +281,7 @@ DTRACE_OBJS= @ADDITIONAL_OBJS@ @REPLACEMENT_OBJS@ @CRYPTO_OBJS@ \ log_stat@o@ mkpath@o@ mp_alloc@o@ mp_backup@o@ mp_bh@o@ mp_fget@o@ \ mp_fmethod@o@ mp_fopen@o@ mp_fput@o@ mp_fset@o@ mp_method@o@ \ mp_mvcc@o@ mp_region@o@ mp_register@o@ mp_resize@o@ mp_stat@o@ \ - mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ \ + mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_uring@o@ \ os_alloc@o@ os_atomic@o@ os_clock@o@ os_cpu@o@ os_ctime@o@ os_config@o@ \ os_dir@o@ os_errno@o@ os_fid@o@ os_flock@o@ os_fsync@o@ \ os_getenv@o@ os_handle@o@ os_map@o@ os_method@o@ os_mkdir@o@ \ @@ -2241,6 +2241,8 @@ os_addrinfo@o@: $(srcdir)/os/os_addrinfo.c $(CC) $(CFLAGS) $? os_aio@o@: $(srcdir)/os/os_aio.c $(CC) $(CFLAGS) $? +os_aio_uring@o@: $(srcdir)/os/os_aio_uring.c + $(CC) $(CFLAGS) $? os_alloc@o@: $(srcdir)/os/os_alloc.c $(CC) $(CFLAGS) $? os_atomic@o@: $(srcdir)/os/os_atomic.c diff --git a/dist/srcfiles.in b/dist/srcfiles.in index 0dc6f9353..e69c87e71 100644 --- a/dist/srcfiles.in +++ b/dist/srcfiles.in @@ -254,6 +254,7 @@ src/os/os_abort.c android vx vxsmall src/os/os_abs.c android src/os/os_addrinfo.c vx src/os/os_aio.c android vx vxsmall +src/os/os_aio_uring.c android vx vxsmall src/os/os_alloc.c android vx vxsmall src/os/os_clock.c android vx vxsmall src/os/os_config.c android diff --git a/src/dbinc/os_aio.h b/src/dbinc/os_aio.h index 806a7cef8..0ffee2b91 100644 --- a/src/dbinc/os_aio.h +++ b/src/dbinc/os_aio.h @@ -56,6 +56,18 @@ typedef struct __db_aio_backend { int (*destroy) __P((ENV *, DB_AIO_CONTEXT *)); } DB_AIO_BACKEND; +/* + * AIO context. Owned by the process that created it. A NULL backend + * means the synchronous fallback (see os_aio.c); a platform backend + * installs its vtable and per-context state via priv. + */ +struct __db_aio_context { + const DB_AIO_BACKEND *backend; /* NULL = synchronous fallback. */ + void *priv; /* Backend-private state. */ + u_int32_t depth; /* Requested queue depth. */ + u_int32_t inflight; /* Ops submitted, not yet reaped. */ +}; + /* * PUBLIC: int __os_aio_create __P((ENV *, u_int32_t, DB_AIO_CONTEXT **)); * PUBLIC: int __os_aio_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); @@ -68,6 +80,15 @@ int __os_aio_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); int __os_aio_reap __P((ENV *, DB_AIO_CONTEXT *, int /*max*/, int /*wait*/)); int __os_aio_destroy __P((ENV *, DB_AIO_CONTEXT *)); int __os_aio_available __P((ENV *)); /* 1 if a real async backend is active */ +int __os_aio_ctx_available __P((DB_AIO_CONTEXT *)); /* per-context async? */ + +/* + * PUBLIC: int __os_aio_uring_init __P((ENV *, DB_AIO_CONTEXT *)); + * Install the Linux io_uring backend on a context (HAVE_IO_URING + * builds only). Returns 0 and sets ctx->backend on success, or a + * non-zero error leaving the context on the synchronous fallback. + */ +int __os_aio_uring_init __P((ENV *, DB_AIO_CONTEXT *)); /* Queue depth requested at create time; backends may clamp. */ #define DB_AIO_DEFAULT_DEPTH 64 diff --git a/src/os/os_aio.c b/src/os/os_aio.c index 8ec940eac..bfa7ceba3 100644 --- a/src/os/os_aio.c +++ b/src/os/os_aio.c @@ -13,13 +13,6 @@ #include "db_int.h" #include "dbinc/os_aio.h" -struct __db_aio_context { - const DB_AIO_BACKEND *backend; /* Active backend (NULL = synchronous). */ - void *priv; /* Backend-private state. */ - u_int32_t depth; /* Requested queue depth. */ - u_int32_t inflight; /* Ops submitted, not yet reaped. */ -}; - /* * __os_aio_create -- * Create an AIO context. Selects a platform backend if one is available @@ -43,11 +36,12 @@ __os_aio_create(env, depth, ctxp) ctx->inflight = 0; /* - * A platform backend would be probed and installed here, e.g. - * (void)__os_aio_uring_init(env, ctx); - * leaving ctx->backend NULL (synchronous) on failure. Kept as the - * synchronous fallback until the io_uring backend lands. + * Probe and install a platform backend; on failure the context + * stays on the synchronous fallback (backend == NULL). */ +#ifdef HAVE_IO_URING + (void)__os_aio_uring_init(env, ctx); +#endif *ctxp = ctx; return (0); } @@ -126,5 +120,18 @@ __os_aio_available(env) ENV *env; { COMPQUIET(env, NULL); - return (0); /* synchronous fallback only, for now */ + return (0); /* overridden per-context; see __os_aio_ctx_available */ +} + +/* + * __os_aio_ctx_available -- + * Return 1 if the given context has a real (async) backend. + * + * PUBLIC: int __os_aio_ctx_available __P((DB_AIO_CONTEXT *)); + */ +int +__os_aio_ctx_available(ctx) + DB_AIO_CONTEXT *ctx; +{ + return (ctx != NULL && ctx->backend != NULL); } diff --git a/src/os/os_aio_uring.c b/src/os/os_aio_uring.c new file mode 100644 index 000000000..2152bc2a2 --- /dev/null +++ b/src/os/os_aio_uring.c @@ -0,0 +1,223 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Linux io_uring backend for the os_aio abstraction. + * + * The submit/reap mechanics (io_uring_prep_read/write, SQE acquisition + * with a submit-and-retry on a full ring, and the CQE drain that maps + * each completion back to its op) are adapted from the XTC Project's + * libxtc (src/io/io_uring.c, ISC License) with the author's permission; + * the readiness/poll machinery there is dropped since the buffer pool + * only needs file reads/writes. + * + * Built only when configured with io_uring support (HAVE_IO_URING); + * otherwise this file is an empty translation unit and contexts use + * the synchronous fallback in os_aio.c. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +#ifdef HAVE_IO_URING + +#include + +typedef struct __aio_uring_state { + struct io_uring ring; +} AIO_URING_STATE; + +/* Per-op completion record; user_data points here until reaped. */ +typedef struct __aio_uring_op { + void *cookie; + db_aio_done_fn done; + u_int32_t len; /* expected transfer (read/write). */ + int op; /* DB_IO_READ / DB_IO_WRITE. */ +} AIO_URING_OP; + +static int __aio_uring_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +static int __aio_uring_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); +static int __aio_uring_destroy __P((ENV *, DB_AIO_CONTEXT *)); + +static const DB_AIO_BACKEND __aio_uring_backend = { + "io_uring", + __aio_uring_submit, + __aio_uring_reap, + NULL, /* cancel: unused */ + __aio_uring_destroy +}; + +/* + * __os_aio_uring_init -- + * Bring up an io_uring and attach the backend to the context. + */ +int +__os_aio_uring_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_URING_STATE *st; + int ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + if (io_uring_queue_init((unsigned)ctx->depth, &st->ring, 0) < 0) { + ret = __os_get_errno(); + __os_free(env, st); + return (ret); + } + ctx->priv = st; + ctx->backend = &__aio_uring_backend; + return (0); +} + +/* + * __aio_uring_get_sqe -- + * Get an SQE, flushing the ring once if it is momentarily full. + */ +static struct io_uring_sqe * +__aio_uring_get_sqe(st) + AIO_URING_STATE *st; +{ + struct io_uring_sqe *sqe; + + if ((sqe = io_uring_get_sqe(&st->ring)) == NULL) { + (void)io_uring_submit(&st->ring); + sqe = io_uring_get_sqe(&st->ring); + } + return (sqe); +} + +static int +__aio_uring_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + AIO_URING_STATE *st; + AIO_URING_OP *rec; + struct io_uring_sqe *sqe; + off_t off; + int ret; + + st = ctx->priv; + if ((sqe = __aio_uring_get_sqe(st)) == NULL) + return (EAGAIN); + + off = (off_t)aio->pgno * aio->pagesize; + switch (aio->op) { + case DB_IO_READ: + io_uring_prep_read(sqe, aio->fhp->fd, + aio->buf, aio->pagesize, (unsigned long long)off); + break; + case DB_IO_WRITE: + io_uring_prep_write(sqe, aio->fhp->fd, + aio->buf, aio->pagesize, (unsigned long long)off); + break; + default: + return (EINVAL); + } + + if ((ret = __os_calloc(env, 1, sizeof(*rec), &rec)) != 0) + return (ret); + rec->cookie = aio->cookie; + rec->done = aio->done; + rec->len = aio->pagesize; + rec->op = aio->op; + io_uring_sqe_set_data(sqe, rec); + + (void)io_uring_submit(&st->ring); + ctx->inflight++; + return (0); +} + +/* + * __aio_uring_reap -- + * Drain up to "max" completions (max < 0 means all currently ready), + * invoking each op's completion callback. If "wait" is set and ops + * are outstanding, block for at least one completion first. + */ +static int +__aio_uring_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + AIO_URING_STATE *st; + AIO_URING_OP *rec; + struct io_uring_cqe *cqe; + int got, ret; + + st = ctx->priv; + got = 0; + + if (wait && ctx->inflight != 0) { + if (io_uring_wait_cqe(&st->ring, &cqe) < 0) + return (got); + } else if (io_uring_peek_cqe(&st->ring, &cqe) != 0) + return (got); + + for (;;) { + rec = io_uring_cqe_get_data(cqe); + if (rec != NULL) { + /* + * cqe->res is the byte count (>= 0) or a negative + * errno; a short transfer is treated as an I/O error. + */ + if (cqe->res < 0) + ret = -cqe->res; + else + ret = ((u_int32_t)cqe->res == rec->len) ? + 0 : EIO; + if (rec->done != NULL) + rec->done(env, rec->cookie, ret); + __os_free(env, rec); + if (ctx->inflight != 0) + ctx->inflight--; + got++; + } + io_uring_cqe_seen(&st->ring, cqe); + + if (max >= 0 && got >= max) + break; + if (io_uring_peek_cqe(&st->ring, &cqe) != 0) + break; + } + return (got); +} + +static int +__aio_uring_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_URING_STATE *st; + + if ((st = ctx->priv) != NULL) { + /* Drain any stragglers so their records are freed. */ + (void)__aio_uring_reap(env, ctx, -1, 0); + io_uring_queue_exit(&st->ring); + __os_free(env, st); + ctx->priv = NULL; + } + return (0); +} + +#else /* !HAVE_IO_URING */ + +/* + * __os_aio_uring_init -- + * io_uring not configured; leave the context on the synchronous + * fallback. + */ +int +__os_aio_uring_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + COMPQUIET(env, NULL); + COMPQUIET(ctx, NULL); + return (DB_OPNOTSUP); +} + +#endif /* HAVE_IO_URING */ From 9de3e4f467b5817ed0f1d9149d273d4dd87b280c Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 16:38:35 -0400 Subject: [PATCH 03/11] fix(os): don't clobber reap max/wait via COMPQUIET before dispatch __os_aio_reap ran COMPQUIET(max,0)/COMPQUIET(wait,0) -- which assign the variables, not just silence warnings -- before forwarding to the backend, so every async reap saw max=0,wait=0 and never blocked or drained. Dispatch to the backend first; COMPQUIET only on the synchronous fall-through. --- src/os/os_aio.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/os/os_aio.c b/src/os/os_aio.c index bfa7ceba3..93d2e00f4 100644 --- a/src/os/os_aio.c +++ b/src/os/os_aio.c @@ -83,11 +83,13 @@ __os_aio_reap(env, ctx, max, wait) DB_AIO_CONTEXT *ctx; int max, wait; { + if (ctx->backend != NULL) + return (ctx->backend->reap(env, ctx, max, wait)); + + /* Synchronous fallback: nothing is ever outstanding. */ COMPQUIET(env, NULL); COMPQUIET(max, 0); COMPQUIET(wait, 0); - if (ctx->backend != NULL) - return (ctx->backend->reap(env, ctx, max, wait)); return (0); } From 60f88df066456796ecdcd3b548765190677d3d05 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 17:16:56 -0400 Subject: [PATCH 04/11] perf(os): add portable thread-pool offload AIO backend + unify selection Add the cross-platform async path for every system without a native file completion engine (everything but Linux io_uring / Windows IOCP): a fixed worker pool drains a submission FIFO, runs each op via the normal __os_io, and posts results to a completion FIFO that __os_aio_reap drains (blocking on a condvar when asked to wait). The pool structure is adapted from libxtc (src/ptc/blocking.c + aio.c, ISC) with a completion queue replacing its fiber-park wakeup; per-op I/O reuses BDB's portable __os_io so no platform read/write branches are needed. __os_aio_create now selects in preference order: io_uring (HAVE_IO_URING) > thread-pool (HAVE_AIO_THREADPOOL) > synchronous fallback. POSIX uses pthreads; a Win32 path lands behind the same surface. Registered in srcfiles.in and Makefile.in. Validated: on macOS (no io_uring) the pool is the active backend and the submit/reap round-trip completes with correct data and callbacks. --- dist/Makefile.in | 4 +- dist/srcfiles.in | 1 + src/dbinc/os_aio.h | 7 ++ src/os/os_aio.c | 14 ++- src/os/os_aio_pool.c | 288 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 310 insertions(+), 4 deletions(-) create mode 100644 src/os/os_aio_pool.c diff --git a/dist/Makefile.in b/dist/Makefile.in index 0f2b63d6d..6836b9ae5 100644 --- a/dist/Makefile.in +++ b/dist/Makefile.in @@ -281,7 +281,7 @@ DTRACE_OBJS= @ADDITIONAL_OBJS@ @REPLACEMENT_OBJS@ @CRYPTO_OBJS@ \ log_stat@o@ mkpath@o@ mp_alloc@o@ mp_backup@o@ mp_bh@o@ mp_fget@o@ \ mp_fmethod@o@ mp_fopen@o@ mp_fput@o@ mp_fset@o@ mp_method@o@ \ mp_mvcc@o@ mp_region@o@ mp_register@o@ mp_resize@o@ mp_stat@o@ \ - mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_uring@o@ \ + mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_pool@o@ os_aio_uring@o@ \ os_alloc@o@ os_atomic@o@ os_clock@o@ os_cpu@o@ os_ctime@o@ os_config@o@ \ os_dir@o@ os_errno@o@ os_fid@o@ os_flock@o@ os_fsync@o@ \ os_getenv@o@ os_handle@o@ os_map@o@ os_method@o@ os_mkdir@o@ \ @@ -2243,6 +2243,8 @@ os_aio@o@: $(srcdir)/os/os_aio.c $(CC) $(CFLAGS) $? os_aio_uring@o@: $(srcdir)/os/os_aio_uring.c $(CC) $(CFLAGS) $? +os_aio_pool@o@: $(srcdir)/os/os_aio_pool.c + $(CC) $(CFLAGS) $? os_alloc@o@: $(srcdir)/os/os_alloc.c $(CC) $(CFLAGS) $? os_atomic@o@: $(srcdir)/os/os_atomic.c diff --git a/dist/srcfiles.in b/dist/srcfiles.in index e69c87e71..7acf4053a 100644 --- a/dist/srcfiles.in +++ b/dist/srcfiles.in @@ -255,6 +255,7 @@ src/os/os_abs.c android src/os/os_addrinfo.c vx src/os/os_aio.c android vx vxsmall src/os/os_aio_uring.c android vx vxsmall +src/os/os_aio_pool.c android vx vxsmall src/os/os_alloc.c android vx vxsmall src/os/os_clock.c android vx vxsmall src/os/os_config.c android diff --git a/src/dbinc/os_aio.h b/src/dbinc/os_aio.h index 0ffee2b91..83ff2c84d 100644 --- a/src/dbinc/os_aio.h +++ b/src/dbinc/os_aio.h @@ -90,6 +90,13 @@ int __os_aio_ctx_available __P((DB_AIO_CONTEXT *)); /* per-context async? */ */ int __os_aio_uring_init __P((ENV *, DB_AIO_CONTEXT *)); +/* + * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); + * Install the portable thread-pool offload backend (HAVE_AIO_THREADPOOL + * builds only). Returns 0 and sets ctx->backend on success. + */ +int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); + /* Queue depth requested at create time; backends may clamp. */ #define DB_AIO_DEFAULT_DEPTH 64 diff --git a/src/os/os_aio.c b/src/os/os_aio.c index 93d2e00f4..89517db18 100644 --- a/src/os/os_aio.c +++ b/src/os/os_aio.c @@ -36,11 +36,19 @@ __os_aio_create(env, depth, ctxp) ctx->inflight = 0; /* - * Probe and install a platform backend; on failure the context - * stays on the synchronous fallback (backend == NULL). + * Probe and install a platform backend in preference order; on + * failure the context stays on the synchronous fallback + * (backend == NULL). io_uring (Linux) and IOCP (Windows) are + * native file-completion engines; the thread-pool offload is the + * portable async path everywhere else. */ #ifdef HAVE_IO_URING - (void)__os_aio_uring_init(env, ctx); + if (ctx->backend == NULL) + (void)__os_aio_uring_init(env, ctx); +#endif +#ifdef HAVE_AIO_THREADPOOL + if (ctx->backend == NULL) + (void)__os_aio_pool_init(env, ctx); #endif *ctxp = ctx; return (0); diff --git a/src/os/os_aio_pool.c b/src/os/os_aio_pool.c new file mode 100644 index 000000000..33c996b93 --- /dev/null +++ b/src/os/os_aio_pool.c @@ -0,0 +1,288 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Thread-pool offload backend for the os_aio abstraction. + * + * The portable async path for every platform that lacks a native file + * completion engine (i.e. everything but Linux io_uring and Windows + * IOCP): a small fixed pool of worker threads drains a submission FIFO, + * performs each op with the normal synchronous __os_io, and posts the + * result to a completion FIFO that __os_aio_reap drains. Regular files + * are not pollable, so this offload is exactly how libxtc (src/ptc/ + * blocking.c + aio.c, ISC) does file AIO off io_uring/IOCP; the pool + * structure (worker loop, start-on-first-use, shutdown-join) is adapted + * from it, with a completion queue + condvar replacing libxtc's + * fiber-park wakeup. + * + * Built when configured with HAVE_AIO_THREADPOOL. POSIX uses pthreads; + * a Win32 path (CreateThread/CONDITION_VARIABLE) lands behind the same + * surface. Otherwise this is an empty translation unit and contexts + * fall back to the synchronous path in os_aio.c. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +#ifdef HAVE_AIO_THREADPOOL + +#include + +#define AIO_POOL_THREADS 4 + +typedef struct __aio_pool_item { + DB_AIO_OP op; /* caller's op, copied. */ + int result; /* 0 or errno. */ + struct __aio_pool_item *next; +} AIO_POOL_ITEM; + +typedef struct __aio_pool_state { + ENV *env; + pthread_mutex_t lock; + pthread_cond_t work_cv; /* workers wait for submissions. */ + pthread_cond_t done_cv; /* reap waits for completions. */ + AIO_POOL_ITEM *sub_head, *sub_tail; /* submission FIFO. */ + AIO_POOL_ITEM *cmp_head, *cmp_tail; /* completion FIFO. */ + pthread_t threads[AIO_POOL_THREADS]; + int nthreads; + int stopping; +} AIO_POOL_STATE; + +static int __aio_pool_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +static int __aio_pool_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); +static int __aio_pool_destroy __P((ENV *, DB_AIO_CONTEXT *)); + +static const DB_AIO_BACKEND __aio_pool_backend = { + "threadpool", + __aio_pool_submit, + __aio_pool_reap, + NULL, + __aio_pool_destroy +}; + +/* FIFO helpers (caller holds st->lock). */ +static void +__aio_q_push(head, tail, it) + AIO_POOL_ITEM **head, **tail, *it; +{ + it->next = NULL; + if (*tail != NULL) + (*tail)->next = it; + else + *head = it; + *tail = it; +} + +static AIO_POOL_ITEM * +__aio_q_pop(head, tail) + AIO_POOL_ITEM **head, **tail; +{ + AIO_POOL_ITEM *it; + + if ((it = *head) == NULL) + return (NULL); + if ((*head = it->next) == NULL) + *tail = NULL; + it->next = NULL; + return (it); +} + +static void * +__aio_pool_worker(arg) + void *arg; +{ + AIO_POOL_STATE *st; + AIO_POOL_ITEM *it; + size_t nio; + int ret; + + st = arg; + for (;;) { + (void)pthread_mutex_lock(&st->lock); + while (st->sub_head == NULL && !st->stopping) + (void)pthread_cond_wait(&st->work_cv, &st->lock); + if (st->stopping && st->sub_head == NULL) { + (void)pthread_mutex_unlock(&st->lock); + return (NULL); + } + it = __aio_q_pop(&st->sub_head, &st->sub_tail); + (void)pthread_mutex_unlock(&st->lock); + + /* Run the op synchronously on this worker thread. */ + nio = 0; + ret = __os_io(st->env, it->op.op, it->op.fhp, it->op.pgno, + it->op.pagesize, 0, it->op.pagesize, + (u_int8_t *)it->op.buf, &nio); + it->result = ret; + + (void)pthread_mutex_lock(&st->lock); + __aio_q_push(&st->cmp_head, &st->cmp_tail, it); + (void)pthread_cond_signal(&st->done_cv); + (void)pthread_mutex_unlock(&st->lock); + } +} + +/* + * __os_aio_pool_init -- + * Bring up the worker pool and attach the backend to the context. + * + * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_pool_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_POOL_STATE *st; + int i, ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + st->env = env; + if (pthread_mutex_init(&st->lock, NULL) != 0) + goto err0; + if (pthread_cond_init(&st->work_cv, NULL) != 0) + goto err1; + if (pthread_cond_init(&st->done_cv, NULL) != 0) + goto err2; + + for (i = 0; i < AIO_POOL_THREADS; i++) { + if (pthread_create(&st->threads[i], NULL, + __aio_pool_worker, st) != 0) + break; + st->nthreads++; + } + if (st->nthreads == 0) + goto err3; + + ctx->priv = st; + ctx->backend = &__aio_pool_backend; + return (0); + +err3: (void)pthread_cond_destroy(&st->done_cv); +err2: (void)pthread_cond_destroy(&st->work_cv); +err1: (void)pthread_mutex_destroy(&st->lock); +err0: __os_free(env, st); + return (ret == 0 ? DB_OPNOTSUP : ret); +} + +static int +__aio_pool_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + AIO_POOL_STATE *st; + AIO_POOL_ITEM *it; + int ret; + + st = ctx->priv; + if ((ret = __os_calloc(env, 1, sizeof(*it), &it)) != 0) + return (ret); + it->op = *aio; /* copy: caller's op may be transient. */ + it->result = 0; + + (void)pthread_mutex_lock(&st->lock); + __aio_q_push(&st->sub_head, &st->sub_tail, it); + ctx->inflight++; + (void)pthread_cond_signal(&st->work_cv); + (void)pthread_mutex_unlock(&st->lock); + return (0); +} + +/* + * __aio_pool_reap -- + * Drain completions, invoking each op's callback. With wait set and + * ops outstanding, block until at least one completes. Callbacks run + * without the lock held. + */ +static int +__aio_pool_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + AIO_POOL_STATE *st; + AIO_POOL_ITEM *it; + int got; + + st = ctx->priv; + got = 0; + + (void)pthread_mutex_lock(&st->lock); + if (wait) + while (st->cmp_head == NULL && ctx->inflight != 0) + (void)pthread_cond_wait(&st->done_cv, &st->lock); + + for (;;) { + if (max >= 0 && got >= max) + break; + if ((it = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) == NULL) + break; + if (ctx->inflight != 0) + ctx->inflight--; + (void)pthread_mutex_unlock(&st->lock); + + if (it->op.done != NULL) + it->op.done(env, it->op.cookie, it->result); + __os_free(env, it); + got++; + + (void)pthread_mutex_lock(&st->lock); + } + (void)pthread_mutex_unlock(&st->lock); + return (got); +} + +static int +__aio_pool_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_POOL_STATE *st; + AIO_POOL_ITEM *it; + int i; + + if ((st = ctx->priv) == NULL) + return (0); + + (void)pthread_mutex_lock(&st->lock); + st->stopping = 1; + (void)pthread_cond_broadcast(&st->work_cv); + (void)pthread_mutex_unlock(&st->lock); + for (i = 0; i < st->nthreads; i++) + (void)pthread_join(st->threads[i], NULL); + + /* Discard any uncollected completions (and pending submissions). */ + while ((it = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) != NULL) + __os_free(env, it); + while ((it = __aio_q_pop(&st->sub_head, &st->sub_tail)) != NULL) + __os_free(env, it); + + (void)pthread_cond_destroy(&st->done_cv); + (void)pthread_cond_destroy(&st->work_cv); + (void)pthread_mutex_destroy(&st->lock); + __os_free(env, st); + ctx->priv = NULL; + return (0); +} + +#else /* !HAVE_AIO_THREADPOOL */ + +/* + * __os_aio_pool_init -- + * Thread-pool offload not configured. + * + * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_pool_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + COMPQUIET(env, NULL); + COMPQUIET(ctx, NULL); + return (DB_OPNOTSUP); +} + +#endif /* HAVE_AIO_THREADPOOL */ From b4a98b55cf199048c5b085617ebb3e2de5706d35 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 17:20:15 -0400 Subject: [PATCH 05/11] perf(os): add Windows IOCP native file-AIO backend (reuse from libxtc) Adapt libxtc's IOCP file AIO (src/io/io_iocp.c, ISC): overlapped ReadFile/WriteFile on a file HANDLE associated with a completion port, reaped in batch via GetQueuedCompletionStatusEx -- no worker thread. The socket AFD-poll machinery is dropped; only file I/O is needed. __os_aio_create selection is now io_uring > IOCP > thread-pool > sync. Guarded by HAVE_IOCP (off in every build produced here, so it is an empty TU on POSIX and cannot affect those builds). NOTE: faithful adaptation but NOT yet compiled/validated on Windows; the thread-pool backend remains the validated Windows async path until a Windows build confirms it. Registered in srcfiles.in and Makefile.in. --- dist/Makefile.in | 4 +- dist/srcfiles.in | 1 + src/dbinc/os_aio.h | 7 ++ src/os/os_aio.c | 4 + src/os/os_aio_iocp.c | 238 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 253 insertions(+), 1 deletion(-) create mode 100644 src/os/os_aio_iocp.c diff --git a/dist/Makefile.in b/dist/Makefile.in index 6836b9ae5..eda19a9a8 100644 --- a/dist/Makefile.in +++ b/dist/Makefile.in @@ -281,7 +281,7 @@ DTRACE_OBJS= @ADDITIONAL_OBJS@ @REPLACEMENT_OBJS@ @CRYPTO_OBJS@ \ log_stat@o@ mkpath@o@ mp_alloc@o@ mp_backup@o@ mp_bh@o@ mp_fget@o@ \ mp_fmethod@o@ mp_fopen@o@ mp_fput@o@ mp_fset@o@ mp_method@o@ \ mp_mvcc@o@ mp_region@o@ mp_register@o@ mp_resize@o@ mp_stat@o@ \ - mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_pool@o@ os_aio_uring@o@ \ + mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_iocp@o@ os_aio_pool@o@ os_aio_uring@o@ \ os_alloc@o@ os_atomic@o@ os_clock@o@ os_cpu@o@ os_ctime@o@ os_config@o@ \ os_dir@o@ os_errno@o@ os_fid@o@ os_flock@o@ os_fsync@o@ \ os_getenv@o@ os_handle@o@ os_map@o@ os_method@o@ os_mkdir@o@ \ @@ -2245,6 +2245,8 @@ os_aio_uring@o@: $(srcdir)/os/os_aio_uring.c $(CC) $(CFLAGS) $? os_aio_pool@o@: $(srcdir)/os/os_aio_pool.c $(CC) $(CFLAGS) $? +os_aio_iocp@o@: $(srcdir)/os/os_aio_iocp.c + $(CC) $(CFLAGS) $? os_alloc@o@: $(srcdir)/os/os_alloc.c $(CC) $(CFLAGS) $? os_atomic@o@: $(srcdir)/os/os_atomic.c diff --git a/dist/srcfiles.in b/dist/srcfiles.in index 7acf4053a..05db59607 100644 --- a/dist/srcfiles.in +++ b/dist/srcfiles.in @@ -256,6 +256,7 @@ src/os/os_addrinfo.c vx src/os/os_aio.c android vx vxsmall src/os/os_aio_uring.c android vx vxsmall src/os/os_aio_pool.c android vx vxsmall +src/os/os_aio_iocp.c android vx vxsmall src/os/os_alloc.c android vx vxsmall src/os/os_clock.c android vx vxsmall src/os/os_config.c android diff --git a/src/dbinc/os_aio.h b/src/dbinc/os_aio.h index 83ff2c84d..09c51f92f 100644 --- a/src/dbinc/os_aio.h +++ b/src/dbinc/os_aio.h @@ -97,6 +97,13 @@ int __os_aio_uring_init __P((ENV *, DB_AIO_CONTEXT *)); */ int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); +/* + * PUBLIC: int __os_aio_iocp_init __P((ENV *, DB_AIO_CONTEXT *)); + * Install the Windows IOCP native file-AIO backend (HAVE_IOCP builds + * only). Returns 0 and sets ctx->backend on success. + */ +int __os_aio_iocp_init __P((ENV *, DB_AIO_CONTEXT *)); + /* Queue depth requested at create time; backends may clamp. */ #define DB_AIO_DEFAULT_DEPTH 64 diff --git a/src/os/os_aio.c b/src/os/os_aio.c index 89517db18..779249e6d 100644 --- a/src/os/os_aio.c +++ b/src/os/os_aio.c @@ -46,6 +46,10 @@ __os_aio_create(env, depth, ctxp) if (ctx->backend == NULL) (void)__os_aio_uring_init(env, ctx); #endif +#ifdef HAVE_IOCP + if (ctx->backend == NULL) + (void)__os_aio_iocp_init(env, ctx); +#endif #ifdef HAVE_AIO_THREADPOOL if (ctx->backend == NULL) (void)__os_aio_pool_init(env, ctx); diff --git a/src/os/os_aio_iocp.c b/src/os/os_aio_iocp.c new file mode 100644 index 000000000..e59f17a51 --- /dev/null +++ b/src/os/os_aio_iocp.c @@ -0,0 +1,238 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Windows IOCP native file-AIO backend for the os_aio abstraction. + * + * Adapted from the XTC Project's libxtc (src/io/io_iocp.c, ISC, with + * the author's permission): a pread/pwrite is an overlapped + * ReadFile/WriteFile on a file HANDLE associated with a completion + * port, and completions are dequeued in batch by + * GetQueuedCompletionStatusEx -- no worker thread, no event handle. + * The socket AFD-poll machinery in libxtc is dropped; only file I/O + * is needed. + * + * Built only when configured with HAVE_IOCP (a Windows build). NOTE: + * this backend is a faithful adaptation but has NOT yet been compiled + * or validated on a Windows host; the portable thread-pool backend + * (os_aio_pool.c) is the validated Windows async path until then. + * Otherwise this is an empty translation unit. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +#ifdef HAVE_IOCP + +#include +#include + +typedef struct __aio_iocp_pend { + OVERLAPPED *ov; /* kernel-owned while pending. */ + HANDLE fh; /* file handle (for GetOverlappedResult). */ + void *cookie; + db_aio_done_fn done; + u_int32_t len; /* expected transfer. */ +} AIO_IOCP_PEND; + +typedef struct __aio_iocp_state { + HANDLE iocp; /* the completion port. */ + AIO_IOCP_PEND *pend; /* in-flight ops. */ + int n, cap; +} AIO_IOCP_STATE; + +static int __aio_iocp_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +static int __aio_iocp_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); +static int __aio_iocp_destroy __P((ENV *, DB_AIO_CONTEXT *)); + +static const DB_AIO_BACKEND __aio_iocp_backend = { + "iocp", + __aio_iocp_submit, + __aio_iocp_reap, + NULL, + __aio_iocp_destroy +}; + +/* + * __os_aio_iocp_init -- + * Create a completion port and attach the backend. + * + * PUBLIC: int __os_aio_iocp_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_iocp_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_IOCP_STATE *st; + int ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + st->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); + if (st->iocp == NULL) { + __os_free(env, st); + return (__os_get_errno()); + } + ctx->priv = st; + ctx->backend = &__aio_iocp_backend; + return (0); +} + +static int +__aio_iocp_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + AIO_IOCP_STATE *st; + OVERLAPPED *ov; + HANDLE fh; + BOOL ok; + DWORD err; + __uint64_t off; + int ret; + + st = ctx->priv; + if (aio->op != DB_IO_READ && aio->op != DB_IO_WRITE) + return (EINVAL); + fh = aio->fhp->handle; + if (fh == INVALID_HANDLE_VALUE) + return (EINVAL); + + /* Associate the file with the port once; ignore "already done". */ + if (CreateIoCompletionPort(fh, st->iocp, 0, 0) == NULL) { + err = GetLastError(); + if (err != ERROR_INVALID_PARAMETER) + return (EAGAIN); + } + + if ((ret = __os_calloc(env, 1, sizeof(*ov), &ov)) != 0) + return (ret); + off = (__uint64_t)aio->pgno * aio->pagesize; + ov->Offset = (DWORD)(off & 0xFFFFFFFFu); + ov->OffsetHigh = (DWORD)(off >> 32); + + if (aio->op == DB_IO_READ) + ok = ReadFile(fh, aio->buf, (DWORD)aio->pagesize, NULL, ov); + else + ok = WriteFile(fh, aio->buf, (DWORD)aio->pagesize, NULL, ov); + if (!ok && (err = GetLastError()) != ERROR_IO_PENDING) { + __os_free(env, ov); + return (EAGAIN); + } + + if (st->n >= st->cap) { + int nc = st->cap == 0 ? 16 : st->cap * 2; + void *p = NULL; + if ((ret = __os_realloc(env, + sizeof(*st->pend) * (size_t)nc, &p)) != 0) { + (void)CancelIoEx(fh, ov); + __os_free(env, ov); + return (ret); + } + st->pend = p; + st->cap = nc; + } + st->pend[st->n].ov = ov; + st->pend[st->n].fh = fh; + st->pend[st->n].cookie = aio->cookie; + st->pend[st->n].done = aio->done; + st->pend[st->n].len = aio->pagesize; + st->n++; + ctx->inflight++; + return (0); +} + +static int +__aio_iocp_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + AIO_IOCP_STATE *st; + OVERLAPPED_ENTRY batch[64]; + ULONG n_done, j; + DWORD tmo, nbytes; + int got, i, bmax, ret; + + st = ctx->priv; + got = 0; + tmo = wait ? INFINITE : 0; + bmax = (int)(sizeof(batch) / sizeof(batch[0])); + if (max >= 0 && max < bmax) + bmax = max; + + if (!GetQueuedCompletionStatusEx(st->iocp, batch, + (ULONG)bmax, &n_done, tmo, FALSE)) + return (got); /* WAIT_TIMEOUT or error. */ + + for (j = 0; j < n_done; j++) { + OVERLAPPED *ov = batch[j].lpOverlapped; + for (i = 0; i < st->n; i++) + if (st->pend[i].ov == ov) + break; + if (i == st->n) + continue; /* unknown completion. */ + + nbytes = 0; + if (GetOverlappedResult(st->pend[i].fh, ov, &nbytes, FALSE)) + ret = (nbytes == st->pend[i].len) ? 0 : EIO; + else + ret = EIO; + if (st->pend[i].done != NULL) + st->pend[i].done(env, st->pend[i].cookie, ret); + __os_free(env, ov); + + st->n--; + if (i != st->n) + st->pend[i] = st->pend[st->n]; + if (ctx->inflight != 0) + ctx->inflight--; + got++; + } + return (got); +} + +static int +__aio_iocp_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_IOCP_STATE *st; + int i; + + if ((st = ctx->priv) == NULL) + return (0); + for (i = 0; i < st->n; i++) { + (void)CancelIoEx(st->pend[i].fh, st->pend[i].ov); + __os_free(env, st->pend[i].ov); + } + if (st->pend != NULL) + __os_free(env, st->pend); + if (st->iocp != NULL) + (void)CloseHandle(st->iocp); + __os_free(env, st); + ctx->priv = NULL; + return (0); +} + +#else /* !HAVE_IOCP */ + +/* + * __os_aio_iocp_init -- + * IOCP not configured (non-Windows or thread-pool preferred). + * + * PUBLIC: int __os_aio_iocp_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_iocp_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + COMPQUIET(env, NULL); + COMPQUIET(ctx, NULL); + return (DB_OPNOTSUP); +} + +#endif /* HAVE_IOCP */ From 0d45b536aa4a7558bce983c77d4c4af016d3630f Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Thu, 18 Jun 2026 17:22:41 -0400 Subject: [PATCH 06/11] build: autodetect liburing + pthreads for os_aio backends configure.ac now probes liburing.h + io_uring_queue_init (defining HAVE_IO_URING and adding -luring to LIBSO_LIBS so the shared library and utilities link) and pthread.h (defining HAVE_AIO_THREADPOOL for the portable offload). Both optional; absent either, os_aio is synchronous. config.hin carries the new template entries. NOTE: the generated dist/configure must be regenerated with dist/s_config on a host with autoconf for this to take effect; the committed configure is unchanged here (no autoconf available in this environment). --- dist/config.hin | 6 ++++++ dist/configure.ac | 14 ++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/dist/config.hin b/dist/config.hin index 0dc55d7ff..a8db7b08d 100644 --- a/dist/config.hin +++ b/dist/config.hin @@ -287,6 +287,12 @@ #undef HAVE_MUTEX_PPC_GCC_ASSEMBLY /* Define to 1 to use POSIX 1003.1 pthread_XXX mutexes. */ +/* Define to 1 to use the thread-pool AIO offload backend. */ +#undef HAVE_AIO_THREADPOOL + +/* Define to 1 to use the Linux io_uring AIO backend. */ +#undef HAVE_IO_URING + #undef HAVE_MUTEX_PTHREADS /* Define to 1 to use Reliant UNIX initspin mutexes. */ diff --git a/dist/configure.ac b/dist/configure.ac index 37a64c7bc..92e5ce9e4 100644 --- a/dist/configure.ac +++ b/dist/configure.ac @@ -175,6 +175,20 @@ fi # Respect the environment LIBS settings LIBSO_LIBS="$LIBS" +# Asynchronous I/O backends for the buffer pool (os_aio). The Linux +# io_uring backend is used when liburing is available; the portable +# thread-pool offload is used everywhere pthreads exist. Both are +# optional -- without either, os_aio falls back to synchronous I/O. +AC_CHECK_HEADER(liburing.h, [ + AC_CHECK_LIB(uring, io_uring_queue_init, [ + AC_DEFINE(HAVE_IO_URING, + 1, [Define to 1 to use the Linux io_uring AIO backend.]) + LIBSO_LIBS="$LIBSO_LIBS -luring" + LIBS="$LIBS -luring"])]) +AC_CHECK_HEADER(pthread.h, [ + AC_DEFINE(HAVE_AIO_THREADPOOL, + 1, [Define to 1 to use the thread-pool AIO offload backend.])]) + # This is where we handle stuff that autoconf can't handle: compiler, # preprocessor and load flags, libraries that the standard tests don't # look for. From 09ece3c895aa456602892d56a75769f66d240c67 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Fri, 19 Jun 2026 07:19:42 -0400 Subject: [PATCH 07/11] refactor(mpool): factor __memp_pgwrite into prep/finish; add per-proc AIO ctx Split the page-write into __memp_pgwrite_prep (WAL flush, write-ahead verify, backup coordination, pgout) and __memp_pgwrite_finish (writer-count release, stats, page-image free, BH_DIRTY/BH_TRASH clear under the hash latch). __memp_pgwrite is now a thin wrapper (prep + __os_io + finish) with identical behavior, so the same logic can drive an asynchronous write. Also adds a best-effort per-process DB_MPOOL->aio_ctx (created at mpool open, destroyed at refresh) for upcoming async writeback. Behavior-preserving (one harmless change: the backup writer count is now balanced on the pgout-failure path, which previously leaked it). Validated: test001 btree+hash, recd001 recovery. --- src/dbinc/mp.h | 7 ++ src/mp/mp_bh.c | 252 +++++++++++++++++++++++++-------------------- src/mp/mp_region.c | 13 +++ src/mp/mp_sync.c | 1 + 4 files changed, 162 insertions(+), 111 deletions(-) diff --git a/src/dbinc/mp.h b/src/dbinc/mp.h index bef9e824b..4ccd77866 100644 --- a/src/dbinc/mp.h +++ b/src/dbinc/mp.h @@ -75,6 +75,13 @@ struct __db_mpool { */ ENV *env; /* Enclosing environment. */ REGINFO *reginfo; /* Underlying cache regions. */ + + /* + * Per-process asynchronous-I/O context for buffer-pool writeback + * (checkpoint/sync). NULL if no async backend is available, in which + * case writeback is synchronous. Owned by this process. + */ + struct __db_aio_context *aio_ctx; }; /* diff --git a/src/mp/mp_bh.c b/src/mp/mp_bh.c index 93746fec4..3b08d3efd 100644 --- a/src/mp/mp_bh.c +++ b/src/mp/mp_bh.c @@ -11,6 +11,7 @@ #include "db_int.h" #include "dbinc/db_page.h" /* Required for diagnostic code. */ #include "dbinc/mp.h" +#include "dbinc/os_aio.h" #include "dbinc/log.h" #include "dbinc/txn.h" @@ -300,87 +301,74 @@ err: return (ret); } /* - * __memp_pgwrite -- - * Write a page to a file. + * MEMP_PGW -- + * State carried across the prep / I/O / finish phases of a page write, + * so the write can be issued synchronously (__memp_pgwrite) or + * asynchronously (the checkpoint/sync path), sharing one copy of the + * WAL-ordering, pgout, and bookkeeping logic. + */ +typedef struct __memp_pgw { + ENV *env; + DB_MPOOLFILE *dbmfp; + DB_MPOOL_HASH *hp; + BH *bhp; + MPOOLFILE *mfp; + void *buf; /* page image to write (bhp->buf or copy) */ + int writers_inced; /* mfp->writers was incremented */ +} MEMP_PGW; + +/* + * __memp_pgwrite_prep -- + * Everything before the page write: WAL flush, write-ahead verification, + * backup coordination, and pgout. On return *do_iop is set if there is a + * page image (c->buf) to write; otherwise the caller skips the I/O and + * calls __memp_pgwrite_finish directly. Returns 0 or an errno. */ static int -__memp_pgwrite(env, dbmfp, hp, bhp) +__memp_pgwrite_prep(env, dbmfp, hp, bhp, c, do_iop) ENV *env; DB_MPOOLFILE *dbmfp; DB_MPOOL_HASH *hp; BH *bhp; + MEMP_PGW *c; + int *do_iop; { DB_LSN lsn; - MPOOLFILE *mfp; - size_t nw; int ret; - void * buf; - /* - * Since writing does not require exclusive access, another thread - * could have already written this buffer. - */ + memset(c, 0, sizeof(*c)); + c->env = env; + c->dbmfp = dbmfp; + c->hp = hp; + c->bhp = bhp; + *do_iop = 0; + + /* Another thread could have already written this buffer. */ if (!F_ISSET(bhp, BH_DIRTY)) return (0); - mfp = dbmfp == NULL ? NULL : dbmfp->mfp; + c->mfp = dbmfp == NULL ? NULL : dbmfp->mfp; ret = 0; - buf = NULL; /* We should never be called with a frozen or trashed buffer. */ DB_ASSERT(env, !F_ISSET(bhp, BH_FROZEN | BH_TRASH)); - /* - * It's possible that the underlying file doesn't exist, either - * because of an outright removal or because it was a temporary - * file that's been closed. - * - * !!! - * Once we pass this point, we know that dbmfp and mfp aren't NULL, - * and that we have a valid file reference. - */ - if (mfp == NULL || mfp->deadfile) - goto file_dead; + /* The underlying file may not exist; finish discards the dirty page. */ + if (c->mfp == NULL || c->mfp->deadfile) + return (0); - /* - * If the page is in a file for which we have LSN information, we have - * to ensure the appropriate log records are on disk. - */ - if (LOGGING_ON(env) && mfp->lsn_off != DB_LSN_OFF_NOTSET && + /* Ensure the page's log records are on disk (WAL). */ + if (LOGGING_ON(env) && c->mfp->lsn_off != DB_LSN_OFF_NOTSET && !IS_CLIENT_PGRECOVER(env)) { - memcpy(&lsn, bhp->buf + mfp->lsn_off, sizeof(DB_LSN)); + memcpy(&lsn, bhp->buf + c->mfp->lsn_off, sizeof(DB_LSN)); if (!IS_NOT_LOGGED_LSN(lsn) && (ret = __log_flush(env, &lsn)) != 0) - goto err; + return (ret); } #ifdef DIAGNOSTIC - /* - * Verify write-ahead logging semantics. - * - * !!! - * Two special cases. There is a single field on the meta-data page, - * the last-page-number-in-the-file field, for which we do not log - * changes. If the page was originally created in a database that - * didn't have logging turned on, we can see a page marked dirty but - * for which no corresponding log record has been written. However, - * the only way that a page can be created for which there isn't a - * previous log record and valid LSN is when the page was created - * without logging turned on, and so we check for that special-case - * LSN value. - * - * Second, when a client is reading database pages from a master - * during an internal backup, we may get pages modified after - * the current end-of-log. - */ if (LOGGING_ON(env) && !IS_NOT_LOGGED_LSN(LSN(bhp->buf)) && !IS_CLIENT_PGRECOVER(env)) { - /* - * There is a potential race here. If we are in the midst of - * switching log files, it's possible we could test against the - * old file and the new offset in the log region's LSN. If we - * fail the first test, acquire the log mutex and check again. - */ DB_LOG *dblp; LOG *lp; @@ -397,79 +385,92 @@ __memp_pgwrite(env, dbmfp, hp, bhp) #endif #ifndef HAVE_ATOMICFILEREAD - if (mfp->backup_in_progress != 0) { - MUTEX_READLOCK(env, mfp->mtx_write); - if (bhp->pgno >= mfp->low_pgno && bhp->pgno <= mfp->high_pgno) { - MUTEX_UNLOCK(env, mfp->mtx_write); - ret = EAGAIN; - goto err; + if (c->mfp->backup_in_progress != 0) { + MUTEX_READLOCK(env, c->mfp->mtx_write); + if (bhp->pgno >= c->mfp->low_pgno && + bhp->pgno <= c->mfp->high_pgno) { + MUTEX_UNLOCK(env, c->mfp->mtx_write); + return (EAGAIN); } - atomic_inc(env, &mfp->writers); - MUTEX_UNLOCK(env, mfp->mtx_write); - } else - atomic_inc(env, &mfp->writers); + atomic_inc(env, &c->mfp->writers); + c->writers_inced = 1; + MUTEX_UNLOCK(env, c->mfp->mtx_write); + } else { + atomic_inc(env, &c->mfp->writers); + c->writers_inced = 1; + } #endif /* - * Call any pgout function. If we have the page exclusive then - * we are going to reuse it otherwise make a copy of the page so - * that others can continue looking at the page while we write it. + * Call any pgout function. With the page exclusive we reuse it; + * otherwise copy it so others can read it while we write. */ - buf = bhp->buf; - if (mfp->ftype != 0) { + c->buf = bhp->buf; + if (c->mfp->ftype != 0) { if (F_ISSET(bhp, BH_EXCLUSIVE)) F_SET(bhp, BH_TRASH); else { - if ((ret = __os_malloc(env, mfp->pagesize, &buf)) != 0) - goto err; - memcpy(buf, bhp->buf, mfp->pagesize); + if ((ret = + __os_malloc(env, c->mfp->pagesize, &c->buf)) != 0) { + c->buf = NULL; + return (ret); + } + memcpy(c->buf, bhp->buf, c->mfp->pagesize); } - if ((ret = __memp_pg(dbmfp, bhp->pgno, buf, 0)) != 0) - goto err; + if ((ret = __memp_pg(dbmfp, bhp->pgno, c->buf, 0)) != 0) + return (ret); } - PERFMON3(env, mpool, write, __memp_fn(dbmfp), bhp->pgno, bhp); - /* Write the page. */ - if ((ret = __os_io(env, DB_IO_WRITE, dbmfp->fhp, bhp->pgno, - mfp->pagesize, 0, mfp->pagesize, buf, &nw)) != 0) { -#ifndef HAVE_ATOMICFILEREAD - atomic_dec(env, &mfp->writers); -#endif - __db_errx(env, DB_STR_A("3015", - "%s: write failed for page %lu", "%s %lu"), - __memp_fn(dbmfp), (u_long)bhp->pgno); - goto err; - } + *do_iop = 1; + return (0); +} + +/* + * __memp_pgwrite_finish -- + * Everything after the page write: release the backup-writer count and + * page-image copy, update statistics on a successful write, and clear + * BH_DIRTY/BH_TRASH under the hash-bucket latch. "did_io" is set if a + * write was actually issued; "io_ret" is its result (0 on success). + */ +static int +__memp_pgwrite_finish(c, did_io, io_ret) + MEMP_PGW *c; + int did_io; + int io_ret; +{ + ENV *env; + BH *bhp; + DB_MPOOL_HASH *hp; + int ret; + + env = c->env; + bhp = c->bhp; + hp = c->hp; + ret = io_ret; + #ifndef HAVE_ATOMICFILEREAD - atomic_dec(env, &mfp->writers); + if (c->writers_inced) + atomic_dec(env, &c->mfp->writers); #endif - STAT_INC_VERB(env, mpool, page_out, - mfp->stat.st_page_out, __memp_fn(dbmfp), bhp->pgno); - if (bhp->pgno > mfp->last_flushed_pgno) { - MUTEX_LOCK(env, mfp->mutex); - if (bhp->pgno > mfp->last_flushed_pgno) - mfp->last_flushed_pgno = bhp->pgno; - MUTEX_UNLOCK(env, mfp->mutex); + + if (did_io && ret == 0 && c->mfp != NULL) { + STAT_INC_VERB(env, mpool, page_out, + c->mfp->stat.st_page_out, __memp_fn(c->dbmfp), bhp->pgno); + if (bhp->pgno > c->mfp->last_flushed_pgno) { + MUTEX_LOCK(env, c->mfp->mutex); + if (bhp->pgno > c->mfp->last_flushed_pgno) + c->mfp->last_flushed_pgno = bhp->pgno; + MUTEX_UNLOCK(env, c->mfp->mutex); + } } -err: -file_dead: - if (buf != NULL && buf != bhp->buf) - __os_free(env, buf); - /* - * !!! - * Once we pass this point, dbmfp and mfp may be NULL, we may not have - * a valid file reference. - */ + if (c->buf != NULL && c->buf != bhp->buf) + __os_free(env, c->buf); /* - * Update the hash bucket statistics, reset the flags. If we were - * successful, the page is no longer dirty. Someone else may have - * also written the page so we need to latch the hash bucket here - * to get the accounting correct. Since we have the buffer - * shared it cannot be marked dirty again till we release it. - * This is the only place we update the flags field only holding - * a shared latch. + * Update the hash bucket statistics, reset the flags. On success the + * page is no longer dirty. We latch the hash bucket because this is + * the only place the flags are updated holding only a shared latch. */ if (F_ISSET(bhp, BH_DIRTY | BH_TRASH)) { MUTEX_LOCK(env, hp->mtx_hash); @@ -483,7 +484,7 @@ __memp_pgwrite(env, dbmfp, hp, bhp) /* put the page back if necessary. */ if ((ret != 0 || BH_REFCOUNT(bhp) > 1) && F_ISSET(bhp, BH_TRASH)) { - ret = __memp_pg(dbmfp, bhp->pgno, bhp->buf, 1); + ret = __memp_pg(c->dbmfp, bhp->pgno, bhp->buf, 1); F_CLR(bhp, BH_TRASH); } MUTEX_UNLOCK(env, hp->mtx_hash); @@ -492,6 +493,35 @@ __memp_pgwrite(env, dbmfp, hp, bhp) return (ret); } +/* + * __memp_pgwrite -- + * Write a page to a file. + */ +static int +__memp_pgwrite(env, dbmfp, hp, bhp) + ENV *env; + DB_MPOOLFILE *dbmfp; + DB_MPOOL_HASH *hp; + BH *bhp; +{ + MEMP_PGW c; + size_t nw; + int did_io, do_io, ret; + + ret = __memp_pgwrite_prep(env, dbmfp, hp, bhp, &c, &do_io); + did_io = 0; + if (ret == 0 && do_io) { + PERFMON3(env, mpool, write, __memp_fn(dbmfp), bhp->pgno, bhp); + did_io = 1; + if ((ret = __os_io(env, DB_IO_WRITE, dbmfp->fhp, bhp->pgno, + c.mfp->pagesize, 0, c.mfp->pagesize, c.buf, &nw)) != 0) + __db_errx(env, DB_STR_A("3015", + "%s: write failed for page %lu", "%s %lu"), + __memp_fn(dbmfp), (u_long)bhp->pgno); + } + return (__memp_pgwrite_finish(&c, did_io, ret)); +} + /* * __memp_pg -- * Call the pgin/pgout routine. diff --git a/src/mp/mp_region.c b/src/mp/mp_region.c index 495203054..dfafa48b3 100644 --- a/src/mp/mp_region.c +++ b/src/mp/mp_region.c @@ -10,6 +10,7 @@ #include "db_int.h" #include "dbinc/mp.h" +#include "dbinc/os_aio.h" static int __memp_init_config __P((ENV *, MPOOL *)); static void __memp_region_size __P((ENV *, roff_t *, u_int32_t *)); @@ -170,6 +171,12 @@ __memp_open(env, create_ok) if ((ret = __memp_init_config(env, mp)) != 0) return (ret); + /* + * Best-effort per-process AIO context for asynchronous buffer-pool + * writeback. Failure is non-fatal: writeback stays synchronous. + */ + (void)__os_aio_create(env, 0, &dbmp->aio_ctx); + return (0); err: env->mp_handle = NULL; @@ -515,6 +522,12 @@ __memp_env_refresh(env) ret = 0; dbmp = env->mp_handle; mp = dbmp->reginfo[0].primary; + + /* Tear down the per-process async-I/O writeback context, if any. */ + if (dbmp->aio_ctx != NULL) { + (void)__os_aio_destroy(env, dbmp->aio_ctx); + dbmp->aio_ctx = NULL; + } nreg = mp->nreg; hp = R_ADDR(&dbmp->reginfo[0], mp->htab); diff --git a/src/mp/mp_sync.c b/src/mp/mp_sync.c index 87497a023..c6d22993e 100644 --- a/src/mp/mp_sync.c +++ b/src/mp/mp_sync.c @@ -11,6 +11,7 @@ #include "db_int.h" #include "dbinc/log.h" #include "dbinc/mp.h" +#include "dbinc/os_aio.h" #include "dbinc/db_page.h" #include "dbinc/hash.h" From 6da3cb8f00ff5c2976ecc22bb84ebb82f5d787bd Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Fri, 19 Jun 2026 07:54:48 -0400 Subject: [PATCH 08/11] perf(mpool): async checkpoint writeback via os_aio (Stage 2 #5) Wire the per-process AIO context into the checkpoint/sync loop (__memp_sync_int). When an async backend is available, each dirty buffer is written with __memp_bhwrite_async: WAL flush + pgout in prep, the page write submitted via os_aio while the buffer pin (ref + shared mtx_buf) and a file-handle reference are held, and a bounded in-flight window (MEMP_AIO_WINDOW=16) is reaped (BH_DIRTY clear + reference release) at the window boundary, at done, and before an interrupt. The required fsync runs only after the window is drained, preserving checkpoint durability; WAL ordering is unchanged (log flushed in prep before submit). Crash consistency is identical to the synchronous path -- the log remains the source of truth and a page is marked clean only after its write completes. Gated on dbmp->aio_ctx availability: builds without an async backend (and all non-fast-path files: dead/temporary/extent/unopened/read-only) use the unchanged synchronous __memp_bhwrite. The eviction path (__memp_bhwrite -> __memp_pgwrite) is untouched. Validated with the threadpool backend active (aio_ctx available=1): recd001/002/005/015 recovery, txn001, test001 btree+hash, test003, test010. --- src/dbinc/mp.h | 30 +++++++ src/dbinc_auto/mp_ext.h | 2 + src/mp/mp_bh.c | 194 ++++++++++++++++++++++++++++++++++++---- src/mp/mp_sync.c | 51 +++++++++-- 4 files changed, 254 insertions(+), 23 deletions(-) diff --git a/src/dbinc/mp.h b/src/dbinc/mp.h index 4ccd77866..8113e383c 100644 --- a/src/dbinc/mp.h +++ b/src/dbinc/mp.h @@ -730,5 +730,35 @@ struct __bh_frozen_a { } #endif +/* + * MEMP_PGW -- + * Page-write state shared across the prep / I-O / finish phases so a + * write can be issued synchronously or asynchronously from one copy of + * the WAL-ordering, pgout, and bookkeeping logic. + * MEMP_AIO_W -- + * One asynchronous checkpoint write in flight: the prep state plus the + * pinned buffer and held file-handle reference to release on completion. + */ +typedef struct __memp_pgw { + ENV *env; + DB_MPOOLFILE *dbmfp; + DB_MPOOL_HASH *hp; + BH *bhp; + MPOOLFILE *mfp; + void *buf; /* page image to write (bhp->buf or copy) */ + int writers_inced; /* mfp->writers was incremented */ +} MEMP_PGW; + +typedef struct __memp_aio_w { + MEMP_PGW ctx; /* prep state */ + BH *bhp; /* pinned buffer (ref + shared mtx_buf) */ + DB_MPOOLFILE *dbmfp; /* held file-handle reference */ + int opened; /* dbmfp opened here (close on finish) */ + volatile int io_ret; /* write result (set by completion) */ + volatile int done; /* completion observed */ +} MEMP_AIO_W; + +#define MEMP_AIO_WINDOW 16 /* max checkpoint writes in flight */ + #include "dbinc_auto/mp_ext.h" #endif /* !_DB_MP_H_ */ diff --git a/src/dbinc_auto/mp_ext.h b/src/dbinc_auto/mp_ext.h index d142b5846..b5be8e825 100644 --- a/src/dbinc_auto/mp_ext.h +++ b/src/dbinc_auto/mp_ext.h @@ -13,6 +13,8 @@ int __memp_backup_mpf __P((ENV *, DB_MPOOLFILE *, DB_THREAD_INFO *, db_pgno_t, d int __memp_backup_close __P((ENV *, DB_MPOOLFILE *, const char *, DB_FH *, void *HANDLE)); int __memp_failchk __P((ENV *)); int __memp_bhwrite __P((DB_MPOOL *, DB_MPOOL_HASH *, MPOOLFILE *, BH *, int)); +int __memp_bhwrite_async __P((DB_MPOOL *, DB_MPOOL_HASH *, MPOOLFILE *, BH *, struct __db_aio_context *, MEMP_AIO_W *, int *)); +int __memp_aio_drain __P((ENV *, DB_MPOOL *, struct __db_aio_context *, MEMP_AIO_W *, int)); int __memp_pgread __P((DB_MPOOLFILE *, BH *, int)); int __memp_pg __P((DB_MPOOLFILE *, db_pgno_t, void *, int)); int __memp_bhfree __P((DB_MPOOL *, REGINFO *, MPOOLFILE *, DB_MPOOL_HASH *, BH *, u_int32_t)); diff --git a/src/mp/mp_bh.c b/src/mp/mp_bh.c index 3b08d3efd..cf77b9499 100644 --- a/src/mp/mp_bh.c +++ b/src/mp/mp_bh.c @@ -300,23 +300,6 @@ __memp_pgread(dbmfp, bhp, can_create) err: return (ret); } -/* - * MEMP_PGW -- - * State carried across the prep / I/O / finish phases of a page write, - * so the write can be issued synchronously (__memp_pgwrite) or - * asynchronously (the checkpoint/sync path), sharing one copy of the - * WAL-ordering, pgout, and bookkeeping logic. - */ -typedef struct __memp_pgw { - ENV *env; - DB_MPOOLFILE *dbmfp; - DB_MPOOL_HASH *hp; - BH *bhp; - MPOOLFILE *mfp; - void *buf; /* page image to write (bhp->buf or copy) */ - int writers_inced; /* mfp->writers was incremented */ -} MEMP_PGW; - /* * __memp_pgwrite_prep -- * Everything before the page write: WAL flush, write-ahead verification, @@ -522,6 +505,183 @@ __memp_pgwrite(env, dbmfp, hp, bhp) return (__memp_pgwrite_finish(&c, did_io, ret)); } +/* + * __memp_aio_writeback_done -- + * os_aio completion callback for an async checkpoint write. Records the + * result only; the finish + reference release run in the reaping thread + * (via __memp_aio_drain), so no latches are taken in this callback. + */ +static void +__memp_aio_writeback_done(env, cookie, io_ret) + ENV *env; + void *cookie; + int io_ret; +{ + MEMP_AIO_W *w; + + COMPQUIET(env, NULL); + w = cookie; + w->io_ret = io_ret; + w->done = 1; +} + +/* + * __memp_aio_writeback_finish -- + * Complete one async checkpoint write: run the shared page-write finish, + * then release the held file-handle reference (mirrors __memp_bhwrite's + * tail; opened is always 0 on the async fast path). + */ +static int +__memp_aio_writeback_finish(dbmp, w) + DB_MPOOL *dbmp; + MEMP_AIO_W *w; +{ + DB_MPOOLFILE *dbmfp; + ENV *env; + MPOOLFILE *mfp; + int ret; + + env = dbmp->env; + ret = __memp_pgwrite_finish(&w->ctx, 1, w->io_ret); + + dbmfp = w->dbmfp; + mfp = dbmfp->mfp; + MUTEX_LOCK(env, dbmp->mutex); + if (!w->opened && dbmfp->ref == 1) { + if (!F_ISSET(dbmfp, MP_FLUSH)) { + F_SET(dbmfp, MP_FLUSH); + MUTEX_LOCK(env, mfp->mutex); + if (!F_ISSET(dbmfp, MP_FOR_FLUSH)) { + mfp->neutral_cnt++; + F_SET(dbmfp, MP_FOR_FLUSH); + } + MUTEX_UNLOCK(env, mfp->mutex); + } + } else + --dbmfp->ref; + MUTEX_UNLOCK(env, dbmp->mutex); + return (ret); +} + +/* + * __memp_bhwrite_async -- + * Asynchronous variant of __memp_bhwrite for the checkpoint/sync path. + * For the common case -- a durable, already-open file handle -- it + * prepares the write and submits it via os_aio, holding the buffer pin + * (the caller's ref + shared mtx_buf) and a file-handle reference until + * completion; *deferredp is set and the caller must later reap via + * __memp_aio_drain. Dead/temporary/extent/unopened/read-only files and + * the skip/error cases are handled synchronously here (*deferredp == 0). + * + * PUBLIC: int __memp_bhwrite_async __P((DB_MPOOL *, DB_MPOOL_HASH *, + * PUBLIC: MPOOLFILE *, BH *, struct __db_aio_context *, MEMP_AIO_W *, + * PUBLIC: int *)); + */ +int +__memp_bhwrite_async(dbmp, hp, mfp, bhp, aioc, w, deferredp) + DB_MPOOL *dbmp; + DB_MPOOL_HASH *hp; + MPOOLFILE *mfp; + BH *bhp; + struct __db_aio_context *aioc; + MEMP_AIO_W *w; + int *deferredp; +{ + DB_AIO_OP op; + DB_MPOOLFILE *dbmfp; + ENV *env; + size_t nw; + int do_io, ret; + + env = dbmp->env; + *deferredp = 0; + + /* Only an already-open durable handle takes the async fast path. */ + if (mfp->deadfile) + return (__memp_bhwrite(dbmp, hp, mfp, bhp, 1)); + MUTEX_LOCK(env, dbmp->mutex); + TAILQ_FOREACH(dbmfp, &dbmp->dbmfq, q) + if (dbmfp->mfp == mfp && !F_ISSET(dbmfp, MP_READONLY)) { + ++dbmfp->ref; + break; + } + MUTEX_UNLOCK(env, dbmp->mutex); + if (dbmfp == NULL || dbmfp->fhp == NULL) { + if (dbmfp != NULL) { + MUTEX_LOCK(env, dbmp->mutex); + --dbmfp->ref; + MUTEX_UNLOCK(env, dbmp->mutex); + } + return (__memp_bhwrite(dbmp, hp, mfp, bhp, 1)); + } + + /* Prepare the write (WAL flush + pgout) into the slot's context. */ + ret = __memp_pgwrite_prep(env, dbmfp, hp, bhp, &w->ctx, &do_io); + if (ret != 0 || !do_io) { + ret = __memp_pgwrite_finish(&w->ctx, 0, ret); + MUTEX_LOCK(env, dbmp->mutex); + --dbmfp->ref; + MUTEX_UNLOCK(env, dbmp->mutex); + return (ret); + } + + w->bhp = bhp; + w->dbmfp = dbmfp; + w->opened = 0; + w->io_ret = 0; + w->done = 0; + + op.op = DB_IO_WRITE; + op.fhp = dbmfp->fhp; + op.pgno = bhp->pgno; + op.pagesize = w->ctx.mfp->pagesize; + op.buf = w->ctx.buf; + op.cookie = w; + op.done = __memp_aio_writeback_done; + if ((ret = __os_aio_submit(env, aioc, &op)) != 0) { + /* Submit failed: complete the write synchronously. */ + ret = __os_io(env, DB_IO_WRITE, dbmfp->fhp, bhp->pgno, + op.pagesize, 0, op.pagesize, w->ctx.buf, &nw); + ret = __memp_pgwrite_finish(&w->ctx, 1, ret); + MUTEX_LOCK(env, dbmp->mutex); + --dbmfp->ref; + MUTEX_UNLOCK(env, dbmp->mutex); + return (ret); + } + *deferredp = 1; + return (0); +} + +/* + * __memp_aio_drain -- + * Reap all "n" outstanding async checkpoint writes, run each completion + * (BH_DIRTY clear + file-handle release), and release each buffer pin. + * Returns the number of writes completed (n). + * + * PUBLIC: int __memp_aio_drain __P((ENV *, DB_MPOOL *, + * PUBLIC: struct __db_aio_context *, MEMP_AIO_W *, int)); + */ +int +__memp_aio_drain(env, dbmp, aioc, w, n) + ENV *env; + DB_MPOOL *dbmp; + struct __db_aio_context *aioc; + MEMP_AIO_W *w; + int n; +{ + int got, j; + + for (got = 0; got < n; ) + got += __os_aio_reap(env, aioc, -1, 1); + for (j = 0; j < n; j++) { + (void)__memp_aio_writeback_finish(dbmp, &w[j]); + DB_ASSERT(env, atomic_read(&w[j].bhp->ref) > 0); + atomic_dec(env, &w[j].bhp->ref); + MUTEX_UNLOCK(env, w[j].bhp->mtx_buf); + } + return (n); +} + /* * __memp_pg -- * Call the pgin/pgout routine. diff --git a/src/mp/mp_sync.c b/src/mp/mp_sync.c index c6d22993e..d26a495e1 100644 --- a/src/mp/mp_sync.c +++ b/src/mp/mp_sync.c @@ -302,11 +302,15 @@ __memp_sync_int(env, dbmfp, trickle_max, flags, wrote_totalp, interruptedp) u_int32_t ar_cnt, ar_max, i, n_cache, remaining, wrote_total; int32_t wrote_cnt; int dirty, filecnt, maxopenfd, required_write, ret, t_ret; + MEMP_AIO_W aiow[MEMP_AIO_WINDOW]; /* async writeback window */ + int deferred, nflight, use_aio; dbmp = env->mp_handle; mp = dbmp->reginfo[0].primary; last_mf_offset = INVALID_ROFF; filecnt = wrote_total = 0; + nflight = 0; + use_aio = dbmp->aio_ctx != NULL && __os_aio_ctx_available(dbmp->aio_ctx); if (wrote_totalp != NULL) *wrote_totalp = 0; @@ -558,10 +562,18 @@ __memp_sync_int(env, dbmfp, trickle_max, flags, wrote_totalp, interruptedp) * If the buffer is dirty, we write it. We only try to * write the buffer once. */ + deferred = 0; if (F_ISSET(bhp, BH_DIRTY)) { mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset); - if ((t_ret = - __memp_bhwrite(dbmp, hp, mfp, bhp, 1)) == 0) { + if (use_aio) + t_ret = __memp_bhwrite_async(dbmp, hp, mfp, + bhp, dbmp->aio_ctx, &aiow[nflight], + &deferred); + else + t_ret = __memp_bhwrite(dbmp, hp, mfp, bhp, 1); + if (deferred) + ++nflight; + else if (t_ret == 0) { ++wrote_cnt; ++wrote_total; } else { @@ -584,10 +596,22 @@ __memp_sync_int(env, dbmfp, trickle_max, flags, wrote_totalp, interruptedp) --remaining; bharray[i].track_hp = NULL; - /* Discard our buffer reference. */ - DB_ASSERT(env, atomic_read(&bhp->ref) > 0); - atomic_dec(env, &bhp->ref); - MUTEX_UNLOCK(env, bhp->mtx_buf); + /* + * Discard our buffer reference. For a deferred async write + * the pin (ref + shared mtx_buf) is held until the write + * completes; drain the window when it is full. + */ + if (!deferred) { + DB_ASSERT(env, atomic_read(&bhp->ref) > 0); + atomic_dec(env, &bhp->ref); + MUTEX_UNLOCK(env, bhp->mtx_buf); + } else if (nflight >= MEMP_AIO_WINDOW) { + t_ret = __memp_aio_drain(env, dbmp, + dbmp->aio_ctx, aiow, nflight); + wrote_cnt += t_ret; + wrote_total += t_ret; + nflight = 0; + } /* Check if the call has been interrupted. */ if (LF_ISSET(DB_SYNC_INTERRUPT_OK) && @@ -595,6 +619,11 @@ __memp_sync_int(env, dbmfp, trickle_max, flags, wrote_totalp, interruptedp) STAT(++mp->stat.st_sync_interrupted); if (interruptedp != NULL) *interruptedp = 1; + if (nflight > 0) { + wrote_total += __memp_aio_drain(env, + dbmp, dbmp->aio_ctx, aiow, nflight); + nflight = 0; + } goto err; } @@ -613,6 +642,16 @@ __memp_sync_int(env, dbmfp, trickle_max, flags, wrote_totalp, interruptedp) } done: /* + * Drain any async writes still in flight before forcing pages to + * disk: the fsync below must follow all completed writes. + */ + if (nflight > 0) { + wrote_total += __memp_aio_drain(env, + dbmp, dbmp->aio_ctx, aiow, nflight); + nflight = 0; + } + + /* * If a write is required, we have to force the pages to disk. We * don't do this as we go along because we want to give the OS as * much time as possible to lazily flush, and because we have to flush From 7065988d6ef8cbe2d063a4c5162493491a55024a Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Fri, 19 Jun 2026 09:13:07 -0400 Subject: [PATCH 09/11] perf(os): make the threadpool AIO backend global, lazy, and fork-safe The previous backend spawned 4 worker threads at every context (every env) creation, which env-churning workloads (and BDB's own env tests) pay repeatedly, and worker threads in a library are a fork hazard. Replace it with a single process-wide pool created lazily on the first submitted op: a context costs nothing until it actually issues an async write, and many environments share one pool. Each context keeps only its own completion FIFO + condvar; one global lock guards the submission FIFO and the completion FIFOs. A pthread_atfork child handler resets the pool to unstarted (workers do not survive fork) so a child re-spawns lazily and never blocks on an inherited-locked pool mutex. Context destroy drains its in-flight writes before freeing its state. Validated: lazy-pool submit/reap round-trip (data + 2 completions), test001 btree. --- src/os/os_aio_pool.c | 347 ++++++++++++++++++++++++------------------- 1 file changed, 192 insertions(+), 155 deletions(-) diff --git a/src/os/os_aio_pool.c b/src/os/os_aio_pool.c index 33c996b93..805298e36 100644 --- a/src/os/os_aio_pool.c +++ b/src/os/os_aio_pool.c @@ -3,21 +3,23 @@ * * Thread-pool offload backend for the os_aio abstraction. * - * The portable async path for every platform that lacks a native file - * completion engine (i.e. everything but Linux io_uring and Windows - * IOCP): a small fixed pool of worker threads drains a submission FIFO, - * performs each op with the normal synchronous __os_io, and posts the - * result to a completion FIFO that __os_aio_reap drains. Regular files - * are not pollable, so this offload is exactly how libxtc (src/ptc/ - * blocking.c + aio.c, ISC) does file AIO off io_uring/IOCP; the pool - * structure (worker loop, start-on-first-use, shutdown-join) is adapted - * from it, with a completion queue + condvar replacing libxtc's - * fiber-park wakeup. + * The portable async path for platforms without a native file completion + * engine (everything but Linux io_uring and Windows IOCP). A single, + * process-wide pool of worker threads -- created lazily on the first + * submitted op, not at context creation -- drains a global submission FIFO, + * performs each op with the normal synchronous __os_io, and routes the result + * to the submitting context's completion FIFO, which __os_aio_reap drains. * - * Built when configured with HAVE_AIO_THREADPOOL. POSIX uses pthreads; - * a Win32 path (CreateThread/CONDITION_VARIABLE) lands behind the same - * surface. Otherwise this is an empty translation unit and contexts - * fall back to the synchronous path in os_aio.c. + * Design notes: + * - Lazy + global: a context (one per environment) costs nothing until it + * actually issues an async write, and many environments share one pool + * rather than each spawning its own threads. + * - Fork-safe: a pthread_atfork child handler resets the pool to "unstarted" + * (the worker threads do not survive fork) so a child re-spawns lazily on + * its next submit and never deadlocks on an inherited-locked pool mutex. + * - The pool structure is adapted from libxtc (src/ptc/blocking.c, ISC). + * + * Built when configured with HAVE_AIO_THREADPOOL; otherwise an empty TU. */ #include "db_config.h" @@ -30,140 +32,146 @@ #define AIO_POOL_THREADS 4 -typedef struct __aio_pool_item { - DB_AIO_OP op; /* caller's op, copied. */ - int result; /* 0 or errno. */ - struct __aio_pool_item *next; -} AIO_POOL_ITEM; +/* One unit of work on the global pool. */ +typedef struct __aio_work { + ENV *env; + DB_AIO_OP op; /* copied from the caller */ + int result; /* 0 or errno */ + struct __aio_pool_state *owner; /* completion routed here */ + struct __aio_work *next; +} AIO_WORK; +/* Per-context (per-environment) completion state. */ typedef struct __aio_pool_state { - ENV *env; - pthread_mutex_t lock; - pthread_cond_t work_cv; /* workers wait for submissions. */ - pthread_cond_t done_cv; /* reap waits for completions. */ - AIO_POOL_ITEM *sub_head, *sub_tail; /* submission FIFO. */ - AIO_POOL_ITEM *cmp_head, *cmp_tail; /* completion FIFO. */ - pthread_t threads[AIO_POOL_THREADS]; - int nthreads; - int stopping; + pthread_cond_t done_cv; /* reap waits here */ + AIO_WORK *cmp_head, *cmp_tail; /* this context's completions */ } AIO_POOL_STATE; -static int __aio_pool_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); -static int __aio_pool_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); -static int __aio_pool_destroy __P((ENV *, DB_AIO_CONTEXT *)); +/* + * Process-wide lazy worker pool. Shared by every context; reset by the + * pthread_atfork child handler. g_lock protects the submission FIFO and + * every context's completion FIFO; each context has its own done_cv. + */ +static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t g_work_cv = PTHREAD_COND_INITIALIZER; +static AIO_WORK *g_sub_head, *g_sub_tail; +static pthread_t g_threads[AIO_POOL_THREADS]; +static int g_nthreads, g_started, g_stopping; +static pthread_once_t g_atfork_once = PTHREAD_ONCE_INIT; + +static AIO_WORK * +__aio_q_pop(head, tail) + AIO_WORK **head, **tail; +{ + AIO_WORK *w; -static const DB_AIO_BACKEND __aio_pool_backend = { - "threadpool", - __aio_pool_submit, - __aio_pool_reap, - NULL, - __aio_pool_destroy -}; + if ((w = *head) == NULL) + return (NULL); + if ((*head = w->next) == NULL) + *tail = NULL; + w->next = NULL; + return (w); +} -/* FIFO helpers (caller holds st->lock). */ static void -__aio_q_push(head, tail, it) - AIO_POOL_ITEM **head, **tail, *it; +__aio_q_push(head, tail, w) + AIO_WORK **head, **tail, *w; { - it->next = NULL; + w->next = NULL; if (*tail != NULL) - (*tail)->next = it; + (*tail)->next = w; else - *head = it; - *tail = it; -} - -static AIO_POOL_ITEM * -__aio_q_pop(head, tail) - AIO_POOL_ITEM **head, **tail; -{ - AIO_POOL_ITEM *it; - - if ((it = *head) == NULL) - return (NULL); - if ((*head = it->next) == NULL) - *tail = NULL; - it->next = NULL; - return (it); + *head = w; + *tail = w; } static void * __aio_pool_worker(arg) void *arg; { - AIO_POOL_STATE *st; - AIO_POOL_ITEM *it; + AIO_WORK *w; size_t nio; - int ret; - st = arg; + COMPQUIET(arg, NULL); for (;;) { - (void)pthread_mutex_lock(&st->lock); - while (st->sub_head == NULL && !st->stopping) - (void)pthread_cond_wait(&st->work_cv, &st->lock); - if (st->stopping && st->sub_head == NULL) { - (void)pthread_mutex_unlock(&st->lock); + (void)pthread_mutex_lock(&g_lock); + while (g_sub_head == NULL && !g_stopping) + (void)pthread_cond_wait(&g_work_cv, &g_lock); + if (g_stopping && g_sub_head == NULL) { + (void)pthread_mutex_unlock(&g_lock); return (NULL); } - it = __aio_q_pop(&st->sub_head, &st->sub_tail); - (void)pthread_mutex_unlock(&st->lock); + w = __aio_q_pop(&g_sub_head, &g_sub_tail); + (void)pthread_mutex_unlock(&g_lock); - /* Run the op synchronously on this worker thread. */ nio = 0; - ret = __os_io(st->env, it->op.op, it->op.fhp, it->op.pgno, - it->op.pagesize, 0, it->op.pagesize, - (u_int8_t *)it->op.buf, &nio); - it->result = ret; - - (void)pthread_mutex_lock(&st->lock); - __aio_q_push(&st->cmp_head, &st->cmp_tail, it); - (void)pthread_cond_signal(&st->done_cv); - (void)pthread_mutex_unlock(&st->lock); + w->result = __os_io(w->env, w->op.op, w->op.fhp, w->op.pgno, + w->op.pagesize, 0, w->op.pagesize, + (u_int8_t *)w->op.buf, &nio); + + (void)pthread_mutex_lock(&g_lock); + __aio_q_push(&w->owner->cmp_head, &w->owner->cmp_tail, w); + (void)pthread_cond_signal(&w->owner->done_cv); + (void)pthread_mutex_unlock(&g_lock); } } -/* - * __os_aio_pool_init -- - * Bring up the worker pool and attach the backend to the context. - * - * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); - */ -int -__os_aio_pool_init(env, ctx) - ENV *env; - DB_AIO_CONTEXT *ctx; +static void +__aio_atfork_prepare() { - AIO_POOL_STATE *st; - int i, ret; + (void)pthread_mutex_lock(&g_lock); +} - if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) - return (ret); - st->env = env; - if (pthread_mutex_init(&st->lock, NULL) != 0) - goto err0; - if (pthread_cond_init(&st->work_cv, NULL) != 0) - goto err1; - if (pthread_cond_init(&st->done_cv, NULL) != 0) - goto err2; +static void +__aio_atfork_parent() +{ + (void)pthread_mutex_unlock(&g_lock); +} + +static void +__aio_atfork_child() +{ + /* + * The worker threads did not survive the fork. Reset the pool to + * unstarted (re-init the lock we held across the fork, drop inherited + * submissions) so the child re-spawns lazily on its next submit and + * never blocks on a pool mutex no live thread will release. + */ + (void)pthread_mutex_init(&g_lock, NULL); + (void)pthread_cond_init(&g_work_cv, NULL); + g_sub_head = g_sub_tail = NULL; + g_nthreads = 0; + g_started = 0; + g_stopping = 0; +} + +static void +__aio_install_atfork() +{ + (void)pthread_atfork(__aio_atfork_prepare, + __aio_atfork_parent, __aio_atfork_child); +} + +/* Start the pool on first use. Caller holds g_lock. Returns 0 on success. */ +static int +__aio_pool_start_locked() +{ + int i; + if (g_started) + return (0); + g_stopping = 0; + g_nthreads = 0; for (i = 0; i < AIO_POOL_THREADS; i++) { - if (pthread_create(&st->threads[i], NULL, - __aio_pool_worker, st) != 0) + if (pthread_create(&g_threads[i], NULL, + __aio_pool_worker, NULL) != 0) break; - st->nthreads++; + g_nthreads++; } - if (st->nthreads == 0) - goto err3; - - ctx->priv = st; - ctx->backend = &__aio_pool_backend; + if (g_nthreads == 0) + return (-1); + g_started = 1; return (0); - -err3: (void)pthread_cond_destroy(&st->done_cv); -err2: (void)pthread_cond_destroy(&st->work_cv); -err1: (void)pthread_mutex_destroy(&st->lock); -err0: __os_free(env, st); - return (ret == 0 ? DB_OPNOTSUP : ret); } static int @@ -173,29 +181,31 @@ __aio_pool_submit(env, ctx, aio) DB_AIO_OP *aio; { AIO_POOL_STATE *st; - AIO_POOL_ITEM *it; + AIO_WORK *w; int ret; + (void)pthread_once(&g_atfork_once, __aio_install_atfork); st = ctx->priv; - if ((ret = __os_calloc(env, 1, sizeof(*it), &it)) != 0) + if ((ret = __os_calloc(env, 1, sizeof(*w), &w)) != 0) return (ret); - it->op = *aio; /* copy: caller's op may be transient. */ - it->result = 0; - - (void)pthread_mutex_lock(&st->lock); - __aio_q_push(&st->sub_head, &st->sub_tail, it); + w->env = env; + w->op = *aio; /* caller's op may be transient. */ + w->result = 0; + w->owner = st; + + (void)pthread_mutex_lock(&g_lock); + if (__aio_pool_start_locked() != 0) { + (void)pthread_mutex_unlock(&g_lock); + __os_free(env, w); + return (DB_OPNOTSUP); /* caller writes synchronously */ + } + __aio_q_push(&g_sub_head, &g_sub_tail, w); ctx->inflight++; - (void)pthread_cond_signal(&st->work_cv); - (void)pthread_mutex_unlock(&st->lock); + (void)pthread_cond_signal(&g_work_cv); + (void)pthread_mutex_unlock(&g_lock); return (0); } -/* - * __aio_pool_reap -- - * Drain completions, invoking each op's callback. With wait set and - * ops outstanding, block until at least one completes. Callbacks run - * without the lock held. - */ static int __aio_pool_reap(env, ctx, max, wait) ENV *env; @@ -203,34 +213,34 @@ __aio_pool_reap(env, ctx, max, wait) int max, wait; { AIO_POOL_STATE *st; - AIO_POOL_ITEM *it; + AIO_WORK *w; int got; st = ctx->priv; got = 0; - (void)pthread_mutex_lock(&st->lock); + (void)pthread_mutex_lock(&g_lock); if (wait) while (st->cmp_head == NULL && ctx->inflight != 0) - (void)pthread_cond_wait(&st->done_cv, &st->lock); + (void)pthread_cond_wait(&st->done_cv, &g_lock); for (;;) { if (max >= 0 && got >= max) break; - if ((it = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) == NULL) + if ((w = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) == NULL) break; if (ctx->inflight != 0) ctx->inflight--; - (void)pthread_mutex_unlock(&st->lock); + (void)pthread_mutex_unlock(&g_lock); - if (it->op.done != NULL) - it->op.done(env, it->op.cookie, it->result); - __os_free(env, it); + if (w->op.done != NULL) + w->op.done(env, w->op.cookie, w->result); + __os_free(env, w); got++; - (void)pthread_mutex_lock(&st->lock); + (void)pthread_mutex_lock(&g_lock); } - (void)pthread_mutex_unlock(&st->lock); + (void)pthread_mutex_unlock(&g_lock); return (got); } @@ -240,33 +250,60 @@ __aio_pool_destroy(env, ctx) DB_AIO_CONTEXT *ctx; { AIO_POOL_STATE *st; - AIO_POOL_ITEM *it; - int i; + AIO_WORK *w; if ((st = ctx->priv) == NULL) return (0); - (void)pthread_mutex_lock(&st->lock); - st->stopping = 1; - (void)pthread_cond_broadcast(&st->work_cv); - (void)pthread_mutex_unlock(&st->lock); - for (i = 0; i < st->nthreads; i++) - (void)pthread_join(st->threads[i], NULL); + /* Drain any writes still in flight so no worker references st. */ + while (ctx->inflight != 0) + (void)__aio_pool_reap(env, ctx, -1, 1); - /* Discard any uncollected completions (and pending submissions). */ - while ((it = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) != NULL) - __os_free(env, it); - while ((it = __aio_q_pop(&st->sub_head, &st->sub_tail)) != NULL) - __os_free(env, it); + (void)pthread_mutex_lock(&g_lock); + while ((w = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) != NULL) + __os_free(env, w); + (void)pthread_mutex_unlock(&g_lock); (void)pthread_cond_destroy(&st->done_cv); - (void)pthread_cond_destroy(&st->work_cv); - (void)pthread_mutex_destroy(&st->lock); __os_free(env, st); ctx->priv = NULL; return (0); } +static const DB_AIO_BACKEND __aio_pool_backend = { + "threadpool", + __aio_pool_submit, + __aio_pool_reap, + NULL, + __aio_pool_destroy +}; + +/* + * __os_aio_pool_init -- + * Attach the thread-pool backend to a context. No worker threads are + * created here; the shared pool starts lazily on the first submit. + * + * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_pool_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_POOL_STATE *st; + int ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + if (pthread_cond_init(&st->done_cv, NULL) != 0) { + __os_free(env, st); + return (DB_OPNOTSUP); + } + ctx->priv = st; + ctx->backend = &__aio_pool_backend; + return (0); +} + #else /* !HAVE_AIO_THREADPOOL */ /* From fee819d4425e11f8fa8aaeac383a787376bfbee0 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Fri, 19 Jun 2026 09:14:01 -0400 Subject: [PATCH 10/11] build(nix): provide liburing on Linux for the io_uring AIO backend Add pkgs.liburing (Linux only) to the devShell and the autoconf build inputs so configure autodetects liburing and HAVE_IO_URING + -luring are enabled in the nix build/dev environment. --- flake.nix | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/flake.nix b/flake.nix index f6db501e2..53009cd2e 100644 --- a/flake.nix +++ b/flake.nix @@ -28,6 +28,9 @@ inherit version; src = ./.; enableParallelBuilding = true; + buildInputs = pkgs.lib.optionals pkgs.stdenv.isLinux [ + pkgs.liburing # io_uring AIO backend + ]; configurePhase = '' runHook preConfigure cd build_unix @@ -45,6 +48,8 @@ pkgs.meson pkgs.ninja pkgs.python3 pkgs.pkg-config pkgs.gcc pkgs.clang pkgs.autoconf pkgs.gnumake pkgs.tcl # for the TCL test harness (--enable-test) + ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [ + pkgs.liburing # Linux io_uring AIO backend (HAVE_IO_URING) ]; shellHook = '' echo "libdb dev shell — Meson: 'meson setup build && ninja -C build'" From bd0a9f54666ae4166b812f19df1b4e1f1c150380 Mon Sep 17 00:00:00 2001 From: Greg Burd Date: Fri, 19 Jun 2026 14:05:44 -0400 Subject: [PATCH 11/11] perf(os): add native POSIX-aio and BSD kqueue AIO backends; fix C23 build Stage 2 previously offered only io_uring (Linux), IOCP (Windows), and a portable thread-pool offload, so every non-Linux/Windows platform fell back to the thread pool. Add the two missing native file-AIO engines and make the thread pool a true last resort. - os_aio_posix.c: POSIX.1b backend (aio_read/aio_write submit; aio_suspend + aio_error/aio_return reap), bounded in-flight table sized to ctx->depth, synchronous fallback when the table is full or the kernel refuses an op. Native path on Solaris/illumos and macOS. - os_aio_kqueue.c: BSD backend using aiocb with SIGEV_KEVENT so completions post EVFILT_AIO kevents reaped via kevent(). Gated on the sigev_notify_kqueue member, which FreeBSD has and macOS lacks, so macOS uses the POSIX backend. - os_aio.c: selection order io_uring > IOCP > kqueue-aio > POSIX aio > thread pool, each #ifdef-gated. - configure.ac: autodetect HAVE_AIO_POSIX (aio.h + aio_read in libc/librt) and HAVE_AIO_KQUEUE (sigev_notify_kqueue + EVFILT_AIO). Build fix (required for any modern toolchain): the tree is K&R C, and Autoconf >= 2.72 AC_PROG_CC adopts -std=gnu23, under which old-style definitions are a hard error. Pin gnu99 (strip an injected -std=gnu23 from CC, append -std=gnu99 to CFLAGS) so K&R stays legal, and silence the two inherent K&R diagnostics (-Wno-deprecated-non-prototype, -Wno-knr-promoted-parameter) behind compiler-support probes. configure regenerated with Autoconf 2.73 (the dev-flake toolchain). Verified: clean build on macOS (Apple clang 21) with zero source warnings; configure selects POSIX aio (kqueue correctly excluded for lack of sigev_notify_kqueue); all AIO objects compile. --- dist/Makefile.in | 6 +- dist/config.hin | 18 +- dist/configure | 6230 +++++++++++++++++++++++----------------- dist/configure.ac | 77 +- dist/srcfiles.in | 2 + src/dbinc/os_aio.h | 15 + src/os/os_aio.c | 15 +- src/os/os_aio_kqueue.c | 268 ++ src/os/os_aio_pool.c | 43 + src/os/os_aio_posix.c | 266 ++ 10 files changed, 4280 insertions(+), 2660 deletions(-) create mode 100644 src/os/os_aio_kqueue.c create mode 100644 src/os/os_aio_posix.c diff --git a/dist/Makefile.in b/dist/Makefile.in index eda19a9a8..5c0a242b0 100644 --- a/dist/Makefile.in +++ b/dist/Makefile.in @@ -281,7 +281,7 @@ DTRACE_OBJS= @ADDITIONAL_OBJS@ @REPLACEMENT_OBJS@ @CRYPTO_OBJS@ \ log_stat@o@ mkpath@o@ mp_alloc@o@ mp_backup@o@ mp_bh@o@ mp_fget@o@ \ mp_fmethod@o@ mp_fopen@o@ mp_fput@o@ mp_fset@o@ mp_method@o@ \ mp_mvcc@o@ mp_region@o@ mp_register@o@ mp_resize@o@ mp_stat@o@ \ - mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_iocp@o@ os_aio_pool@o@ os_aio_uring@o@ \ + mp_sync@o@ mp_trickle@o@ openflags@o@ os_abort@o@ os_abs@o@ os_aio@o@ os_aio_iocp@o@ os_aio_kqueue@o@ os_aio_pool@o@ os_aio_posix@o@ os_aio_uring@o@ \ os_alloc@o@ os_atomic@o@ os_clock@o@ os_cpu@o@ os_ctime@o@ os_config@o@ \ os_dir@o@ os_errno@o@ os_fid@o@ os_flock@o@ os_fsync@o@ \ os_getenv@o@ os_handle@o@ os_map@o@ os_method@o@ os_mkdir@o@ \ @@ -2243,6 +2243,10 @@ os_aio@o@: $(srcdir)/os/os_aio.c $(CC) $(CFLAGS) $? os_aio_uring@o@: $(srcdir)/os/os_aio_uring.c $(CC) $(CFLAGS) $? +os_aio_posix@o@: $(srcdir)/os/os_aio_posix.c + $(CC) $(CFLAGS) $? +os_aio_kqueue@o@: $(srcdir)/os/os_aio_kqueue.c + $(CC) $(CFLAGS) $? os_aio_pool@o@: $(srcdir)/os/os_aio_pool.c $(CC) $(CFLAGS) $? os_aio_iocp@o@: $(srcdir)/os/os_aio_iocp.c diff --git a/dist/config.hin b/dist/config.hin index a8db7b08d..4a2b1a758 100644 --- a/dist/config.hin +++ b/dist/config.hin @@ -30,6 +30,15 @@ /* Define to 1 if you have the 'abort' function. */ #undef HAVE_ABORT +/* Define to 1 to use the BSD kqueue+aio backend. */ +#undef HAVE_AIO_KQUEUE + +/* Define to 1 to use the POSIX aio backend. */ +#undef HAVE_AIO_POSIX + +/* Define to 1 to use the thread-pool AIO offload backend. */ +#undef HAVE_AIO_THREADPOOL + /* Define to 1 if you have the 'atoi' function. */ #undef HAVE_ATOI @@ -189,6 +198,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H +/* Define to 1 to use the Linux io_uring AIO backend. */ +#undef HAVE_IO_URING + /* Define to 1 if you have the 'isalpha' function. */ #undef HAVE_ISALPHA @@ -287,12 +299,6 @@ #undef HAVE_MUTEX_PPC_GCC_ASSEMBLY /* Define to 1 to use POSIX 1003.1 pthread_XXX mutexes. */ -/* Define to 1 to use the thread-pool AIO offload backend. */ -#undef HAVE_AIO_THREADPOOL - -/* Define to 1 to use the Linux io_uring AIO backend. */ -#undef HAVE_IO_URING - #undef HAVE_MUTEX_PTHREADS /* Define to 1 to use Reliant UNIX initspin mutexes. */ diff --git a/dist/configure b/dist/configure index 3948d25be..1af81ff8f 100755 --- a/dist/configure +++ b/dist/configure @@ -1,11 +1,11 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.72 for Berkeley DB 5.3.29. +# Generated by GNU Autoconf 2.73 for Berkeley DB 5.3.29. # # Report bugs to . # # -# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation, +# Copyright (C) 1992-1996, 1998-2017, 2020-2026 Free Software Foundation, # Inc. # # @@ -22,7 +22,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in #( @@ -109,7 +109,7 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi @@ -131,10 +131,13 @@ case $- in # (((( *x* ) as_opts=-x ;; * ) as_opts= ;; esac -exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +case $# in # (( + 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;; + *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;; +esac # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. -printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 +printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi # We don't want this to propagate to other subprocesses. @@ -145,7 +148,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case e in #( @@ -263,22 +266,25 @@ case $- in # (((( *x* ) as_opts=-x ;; * ) as_opts= ;; esac -exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +case $# in # (( + 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;; + *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;; +esac # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. -printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 +printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno then : - printf "%s\n" "$0: This script requires a shell more modern than all" - printf "%s\n" "$0: the shells that I found on your system." + printf '%s\n' "$0: This script requires a shell more modern than all" + printf '%s\n' "$0: the shells that I found on your system." if test ${ZSH_VERSION+y} ; then - printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should" - printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later." + printf '%s\n' "$0: In particular, zsh $ZSH_VERSION has bugs and should" + printf '%s\n' "$0: be upgraded to zsh 4.3.4 or later." else - printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and Oracle Technology + printf '%s\n' "$0: Please tell bug-autoconf@gnu.org and Oracle Technology $0: Network Berkeley DB forum about your system, including $0: any error possibly output before this message. Then $0: install a modern shell, or manually run the script @@ -339,7 +345,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" @@ -348,7 +354,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_dir" | +printf '%s\n' X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -431,9 +437,9 @@ as_fn_error () as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - printf "%s\n" "$as_me: error: $2" >&2 + printf '%s\n' "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error @@ -460,7 +466,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X/"$0" | +printf '%s\n' X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -506,7 +512,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || - { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + { printf '%s\n' "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall @@ -520,29 +526,6 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits exit } - -# Determine whether it's possible to make 'echo' print without a newline. -# These variables are no longer used directly by Autoconf, but are AC_SUBSTed -# for compatibility with existing Makefiles. -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in #((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -# For backward compatibility with old third-party macros, we provide -# the shell variables $as_echo and $as_echo_n. New code should use -# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. -as_echo='printf %s\n' -as_echo_n='printf %s' - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -603,6 +586,7 @@ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # Initializations. # ac_default_prefix=/usr/local +ac_clean_CONFIG_STATUS= ac_clean_files= ac_config_libobj_dir=. LIBOBJS= @@ -654,7 +638,7 @@ ac_includes_default="\ #endif" ac_header_c_list= -enable_year2038=no +: ${enable_year2038:=no} ac_subst_vars='LTLIBOBJS db_seq_decl UINT64_FMT @@ -823,13 +807,13 @@ build_os build_vendor build_cpu build +ECHO_T +ECHO_N +ECHO_C target_alias host_alias build_alias LIBS -ECHO_T -ECHO_N -ECHO_C DEFS mandir localedir @@ -1051,7 +1035,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1077,7 +1061,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1290,7 +1274,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1306,7 +1290,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1350,9 +1334,9 @@ Try '$0 --help' for more information" *) # FIXME: should be removed in autoconf 3.0. - printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2 + printf '%s\n' "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2 + printf '%s\n' "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; @@ -1360,7 +1344,7 @@ Try '$0 --help' for more information" done if test -n "$ac_prev"; then - ac_option=--`echo $ac_prev | sed 's/_/-/g'` + ac_option=--`printf '%s\n' $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi @@ -1368,7 +1352,7 @@ if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; - *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + *) printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi @@ -1432,7 +1416,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_myself" | +printf '%s\n' X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -1676,9 +1660,9 @@ if test "$ac_init_help" = "recursive"; then case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` + ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -1715,7 +1699,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix echo && $SHELL "$ac_srcdir/configure" --help=recursive else - printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + printf '%s\n' "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done @@ -1725,9 +1709,9 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF Berkeley DB configure 5.3.29 -generated by GNU Autoconf 2.72 +generated by GNU Autoconf 2.73 -Copyright (C) 2023 Free Software Foundation, Inc. +Copyright (C) 2026 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1751,7 +1735,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -1759,7 +1743,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err @@ -1767,7 +1751,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -1778,133 +1762,6 @@ fi } # ac_fn_c_try_compile -# ac_fn_cxx_try_compile LINENO -# ---------------------------- -# Try to compile conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_compile () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext conftest.beam - if { { ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_compile") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext -then : - ac_retval=0 -else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 ;; -esac -fi - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_compile - -# ac_fn_cxx_try_cpp LINENO -# ------------------------ -# Try to preprocess conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_cpp () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } > conftest.i && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - } -then : - ac_retval=0 -else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 ;; -esac -fi - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_cpp - -# ac_fn_c_try_link LINENO -# ----------------------- -# Try to link conftest.$ac_ext, and return whether this succeeded. -ac_fn_c_try_link () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext - if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_c_werror_flag" || - test ! -s conftest.err - } && test -s conftest$ac_exeext && { - test "$cross_compiling" = yes || - test -x conftest$ac_exeext - } -then : - ac_retval=0 -else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 ;; -esac -fi - # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information - # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would - # interfere with the next link command; also delete a directory that is - # left behind by Apple's compiler. We do this before executing the actions. - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_c_try_link - # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in @@ -1912,7 +1769,7 @@ fi ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : @@ -1934,80 +1791,16 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile -# ac_fn_c_check_func LINENO FUNC VAR -# ---------------------------------- -# Tests whether FUNC exists, setting the cache variable VAR accordingly -ac_fn_c_check_func () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -printf %s "checking for $2... " >&6; } -if eval test \${$3+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -/* Define $2 to an innocuous variant, in case declares $2. - For example, HP-UX 11i declares gettimeofday. */ -#define $2 innocuous_$2 - -/* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $2 (void); below. */ - -#include -#undef $2 - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char $2 (void); -/* The GNU C library defines this for functions which it implements - to always fail with ENOSYS. Some functions are actually named - something starting with __ and the normal name is an alias. */ -#if defined __stub_$2 || defined __stub___$2 -choke me -#endif - -int -main (void) -{ -return $2 (); - ; - return 0; -} -_ACEOF -if ac_fn_c_try_link "$LINENO" -then : - eval "$3=yes" -else case e in #( - e) eval "$3=no" ;; -esac -fi -rm -f core conftest.err conftest.$ac_objext conftest.beam \ - conftest$ac_exeext conftest.$ac_ext ;; -esac -fi -eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - -} # ac_fn_c_check_func - -# ac_fn_cxx_try_link LINENO -# ------------------------- +# ac_fn_c_try_link LINENO +# ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_link () +ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext @@ -2017,7 +1810,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -2025,9 +1818,9 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { - test -z "$ac_cxx_werror_flag" || + test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || @@ -2036,7 +1829,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -2050,7 +1843,7 @@ fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval -} # ac_fn_cxx_try_link +} # ac_fn_c_try_link # ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES # ---------------------------------------------------- @@ -2059,7 +1852,7 @@ fi ac_fn_c_check_member () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 printf %s "checking for $2.$3... " >&6; } if eval test \${$4+y} then : @@ -2109,52 +1902,297 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$4 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_member -# ac_fn_c_try_run LINENO -# ---------------------- -# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that -# executables *can* be run. -ac_fn_c_try_run () +# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR +# ------------------------------------------------------------------ +# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR +# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR. +ac_fn_check_decl () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' - { { case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; } + as_decl_name=`echo $2|sed 's/ *(.*//'` + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 +printf %s "checking whether $as_decl_name is declared... " >&6; } +if eval test \${$3+y} then : - ac_retval=0 + printf %s "(cached) " >&6 else case e in #( - e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 - printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 + e) as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` + eval ac_save_FLAGS=\$$6 + as_fn_append $6 " $5" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main (void) +{ +#ifndef $as_decl_name +#ifdef __cplusplus + (void) $as_decl_use; +#else + (void) $as_decl_name; +#endif +#endif - ac_retval=$ac_status ;; -esac -fi - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + eval "$3=yes" +else case e in #( + e) eval "$3=no" ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + eval $6=\$ac_save_FLAGS + ;; +esac +fi +eval ac_res=\$$3 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_check_decl + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest.beam + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext +then : + ac_retval=0 +else case e in #( + e) printf '%s\n' "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 ;; +esac +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + } +then : + ac_retval=0 +else case e in #( + e) printf '%s\n' "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 ;; +esac +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (void); below. */ + +#include +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (void); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main (void) +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO" +then : + eval "$3=yes" +else case e in #( + e) eval "$3=no" ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext ;; +esac +fi +eval ac_res=\$$3 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + } +then : + ac_retval=0 +else case e in #( + e) printf '%s\n' "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 ;; +esac +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that +# executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } +then : + ac_retval=0 +else case e in #( + e) printf '%s\n' "$as_me: program exited with status $ac_status" >&5 + printf '%s\n' "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status ;; +esac +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run @@ -2361,7 +2399,7 @@ rm -f conftest.val ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : @@ -2407,8 +2445,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_type @@ -2417,7 +2455,7 @@ for ac_arg do case $ac_arg in *\'*) - ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_configure_args_raw " '$ac_arg'" done @@ -2429,7 +2467,7 @@ case $ac_configure_args_raw in ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab. ac_unsafe_a="$ac_unsafe_z#~" ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g" - ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; + ac_configure_args_raw=` printf '%s\n' "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; esac cat >config.log <<_ACEOF @@ -2437,7 +2475,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by Berkeley DB $as_me 5.3.29, which was -generated by GNU Autoconf 2.72. Invocation command line was +generated by GNU Autoconf 2.73. Invocation command line was $ $0$ac_configure_args_raw @@ -2477,7 +2515,7 @@ do */) ;; *) as_dir=$as_dir/ ;; esac - printf "%s\n" "PATH: $as_dir" + printf '%s\n' "PATH: $as_dir" done IFS=$as_save_IFS @@ -2512,7 +2550,7 @@ do | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) - ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; @@ -2541,31 +2579,22 @@ done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} -# When interrupted or exit'd, cleanup temporary files, and complete -# config.log. We remove comments because anyway the quotes in there -# would cause problems or look ugly. -# WARNING: Use '\'' to represent an apostrophe within the trap. -# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. -trap 'exit_status=$? - # Sanitize IFS. - IFS=" "" $as_nl" - # Save into config.log some information that might help in debugging. - { - echo - - printf "%s\n" "## ---------------- ## -## Cache variables. ## -## ---------------- ##" - echo - # The following way of writing the cache mishandles newlines in values, +# Dump the cache to stdout. It can be in a pipe (this is a requirement). +ac_cache_dump () +{ + # The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. ( - for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + *_cv_*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +printf '%s\n' "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( @@ -2574,67 +2603,95 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} esac ;; esac done + (set) 2>&1 | - case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) + # 'set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ - "s/'\''/'\''\\\\'\'''\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) + # 'set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) - echo +} + +# Print debugging info to stdout. +ac_dump_debugging_info () +{ + echo + + printf '%s\n' "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + ac_cache_dump + echo - printf "%s\n" "## ----------------- ## + printf '%s\n' "## ----------------- ## ## Output variables. ## ## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;; + esac + printf '%s\n' "$ac_var='$ac_val'" + done | sort + echo + + if test -n "$ac_subst_files"; then + printf '%s\n' "## ------------------- ## +## File substitutions. ## +## ------------------- ##" echo - for ac_var in $ac_subst_vars + for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;; esac - printf "%s\n" "$ac_var='\''$ac_val'\''" + printf '%s\n' "$ac_var='$ac_val'" done | sort echo + fi - if test -n "$ac_subst_files"; then - printf "%s\n" "## ------------------- ## -## File substitutions. ## -## ------------------- ##" - echo - for ac_var in $ac_subst_files - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - printf "%s\n" "$ac_var='\''$ac_val'\''" - done | sort - echo - fi - - if test -s confdefs.h; then - printf "%s\n" "## ----------- ## + if test -s confdefs.h; then + printf '%s\n' "## ----------- ## ## confdefs.h. ## ## ----------- ##" - echo - cat confdefs.h - echo - fi - test "$ac_signal" != 0 && - printf "%s\n" "$as_me: caught signal $ac_signal" - printf "%s\n" "$as_me: exit $exit_status" - } >&5 - rm -f core *.core core.conftest.* && + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + printf '%s\n' "$as_me: caught signal $ac_signal" + printf '%s\n' "$as_me: exit $exit_status" +} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. +ac_exit_trap () +{ + exit_status= + # Sanitize IFS. + IFS=" "" $as_nl" + # Save into config.log some information that might help in debugging. + ac_dump_debugging_info >&5 + eval "rm -f $ac_clean_CONFIG_STATUS core *.core core.conftest.*" && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status -' 0 +} + +trap 'ac_exit_trap $?' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done @@ -2643,21 +2700,21 @@ ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h -printf "%s\n" "/* confdefs.h */" > confdefs.h +printf '%s\n' "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. -printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h -printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h -printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h -printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h -printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h -printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h +printf '%s\n' "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. @@ -2679,12 +2736,12 @@ do ac_site_file=./$ac_site_file ;; esac if test -f "$ac_site_file" && test -r "$ac_site_file"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 -printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +printf '%s\n' "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ - || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + || { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See 'config.log' for more details" "$LINENO" 5; } fi @@ -2694,27 +2751,120 @@ if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 -printf "%s\n" "$as_me: loading cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +printf '%s\n' "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 -printf "%s\n" "$as_me: creating cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +printf '%s\n' "$as_me: creating cache $cache_file" >&6;} >$cache_file fi +# Test code for whether the C compiler supports C23 (global declarations) +ac_c_conftest_c23_globals=' +/* Does the compiler advertise conformance to C17 or earlier? + Although GCC 14 does not do that, even with -std=gnu23, + it is close enough, and defines __STDC_VERSION == 202000L. */ +#if !defined __STDC_VERSION__ || __STDC_VERSION__ <= 201710L +# error "Compiler advertises conformance to C17 or earlier" +#endif + +// Check alignas. +char alignas (double) c23_aligned_as_double; +char alignas (0) c23_no_special_alignment; +extern char c23_aligned_as_int; +char alignas (0) alignas (int) c23_aligned_as_int; + +// Check alignof. +enum +{ + c23_int_alignment = alignof (int), + c23_int_array_alignment = alignof (int[100]), + c23_char_alignment = alignof (char) +}; +static_assert (0 < -alignof (int), "alignof is signed"); + +int function_with_unnamed_parameter (int) { return 0; } + +void c23_noreturn (); + +/* Test parsing of string and char UTF-8 literals (including hex escapes). + The parens pacify GCC 15. */ +bool use_u8 = (!sizeof u8"\xFF") == (!u8'\''x'\''); + +bool check_that_bool_works = true | false | !nullptr; +#if !true +# error "true does not work in #if" +#endif +#if false +#elifdef __STDC_VERSION__ +#else +# error "#elifdef does not work" +#endif + +#ifndef __has_c_attribute +# error "__has_c_attribute not defined" +#endif + +#ifndef __has_include +# error "__has_include not defined" +#endif + +#define LPAREN() ( +#define FORTY_TWO(x) 42 +#define VA_OPT_TEST(r, x, ...) __VA_OPT__ (FORTY_TWO r x)) +static_assert (VA_OPT_TEST (LPAREN (), 0, <:-) == 42); + +static_assert (0b101010 == 42); +static_assert (0B101010 == 42); +static_assert (0xDEAD'\''BEEF == 3'\''735'\''928'\''559); +static_assert (0.500'\''000'\''000 == 0.5); + +enum unsignedish : unsigned int { uione = 1 }; +static_assert (0 < -uione); + +#include +constexpr nullptr_t null_pointer = nullptr; + +static typeof (1 + 1L) two () { return 2; } +static long int three () { return 3; } +' + +# Test code for whether the C compiler supports C23 (body of main). +ac_c_conftest_c23_main=' + { + label_before_declaration: + int arr[10] = {}; + if (arr[0]) + goto label_before_declaration; + if (!arr[0]) + goto label_at_end_of_block; + label_at_end_of_block: + } + ok |= !null_pointer; + ok |= two != three; +' + +# Test code for whether the C compiler supports C23 (complete). +ac_c_conftest_c23_program="${ac_c_conftest_c23_globals} + +int +main (int, char **) +{ + int ok = 0; + ${ac_c_conftest_c23_main} + return ok; +} +" + # Test code for whether the C compiler supports C89 (global declarations) ac_c_conftest_c89_globals=' -/* Does the compiler advertise C89 conformance? - Do not test the value of __STDC__, because some compilers set it to 0 - while being otherwise adequately conformant. */ -#if !defined __STDC__ -# error "Compiler does not advertise C89 conformance" -#endif +/* Do not test the value of __STDC__, because some compilers define it to 0 + or do not define it, while otherwise adequately conforming. */ #include #include @@ -2794,7 +2944,8 @@ extern void free (void *); // Check varargs macros. These examples are taken from C99 6.10.3.5. // dprintf is used instead of fprintf to avoid needing to declare -// FILE and stderr. +// FILE and stderr, and "aND" is used instead of "and" to work around +// GCC bug 40564 which is irrelevant here. #define debug(...) dprintf (2, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) @@ -2805,7 +2956,7 @@ test_varargs_macros (void) int y = 5678; debug ("Flag"); debug ("X = %d\n", x); - showlist (The first, second, and third items.); + showlist (The first, second, aND third items.); report (x>y, "x is %d but y is %d", x, y); } @@ -2893,15 +3044,15 @@ ac_c_conftest_c99_main=' // Check restrict. if (test_restrict ("String literal") == 0) success = true; - char *restrict newvar = "Another string"; + const char *restrict newvar = "Another string"; // Check varargs. success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. - struct incomplete_array *ia = - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); + static struct incomplete_array *volatile incomplete_array_pointer; + struct incomplete_array *ia = incomplete_array_pointer; ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; @@ -2917,13 +3068,12 @@ ac_c_conftest_c99_main=' ni.number = 58; - int dynamic_array[ni.number]; - dynamic_array[0] = argv[0][0]; - dynamic_array[ni.number - 1] = 543; + // Do not test for VLAs, as some otherwise-conforming compilers lack them. + // C code should instead use __STDC_NO_VLA__; see Autoconf manual. // work around unused variable warnings ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' - || dynamic_array[ni.number - 1] != 543); + || ni.number != 58); ' # Test code for whether the C compiler supports C11 (global declarations) @@ -3032,222 +3182,6 @@ main (int argc, char **argv) } " -# Test code for whether the C++ compiler supports C++98 (global declarations) -ac_cxx_conftest_cxx98_globals=' -// Does the compiler advertise C++98 conformance? -#if !defined __cplusplus || __cplusplus < 199711L -# error "Compiler does not advertise C++98 conformance" -#endif - -// These inclusions are to reject old compilers that -// lack the unsuffixed header files. -#include -#include - -// and are *not* freestanding headers in C++98. -extern void assert (int); -namespace std { - extern int strcmp (const char *, const char *); -} - -// Namespaces, exceptions, and templates were all added after "C++ 2.0". -using std::exception; -using std::strcmp; - -namespace { - -void test_exception_syntax() -{ - try { - throw "test"; - } catch (const char *s) { - // Extra parentheses suppress a warning when building autoconf itself, - // due to lint rules shared with more typical C programs. - assert (!(strcmp) (s, "test")); - } -} - -template struct test_template -{ - T const val; - explicit test_template(T t) : val(t) {} - template T add(U u) { return static_cast(u) + val; } -}; - -} // anonymous namespace -' - -# Test code for whether the C++ compiler supports C++98 (body of main) -ac_cxx_conftest_cxx98_main=' - assert (argc); - assert (! argv[0]); -{ - test_exception_syntax (); - test_template tt (2.0); - assert (tt.add (4) == 6.0); - assert (true && !false); -} -' - -# Test code for whether the C++ compiler supports C++11 (global declarations) -ac_cxx_conftest_cxx11_globals=' -// Does the compiler advertise C++ 2011 conformance? -#if !defined __cplusplus || __cplusplus < 201103L -# error "Compiler does not advertise C++11 conformance" -#endif - -namespace cxx11test -{ - constexpr int get_val() { return 20; } - - struct testinit - { - int i; - double d; - }; - - class delegate - { - public: - delegate(int n) : n(n) {} - delegate(): delegate(2354) {} - - virtual int getval() { return this->n; }; - protected: - int n; - }; - - class overridden : public delegate - { - public: - overridden(int n): delegate(n) {} - virtual int getval() override final { return this->n * 2; } - }; - - class nocopy - { - public: - nocopy(int i): i(i) {} - nocopy() = default; - nocopy(const nocopy&) = delete; - nocopy & operator=(const nocopy&) = delete; - private: - int i; - }; - - // for testing lambda expressions - template Ret eval(Fn f, Ret v) - { - return f(v); - } - - // for testing variadic templates and trailing return types - template auto sum(V first) -> V - { - return first; - } - template auto sum(V first, Args... rest) -> V - { - return first + sum(rest...); - } -} -' - -# Test code for whether the C++ compiler supports C++11 (body of main) -ac_cxx_conftest_cxx11_main=' -{ - // Test auto and decltype - auto a1 = 6538; - auto a2 = 48573953.4; - auto a3 = "String literal"; - - int total = 0; - for (auto i = a3; *i; ++i) { total += *i; } - - decltype(a2) a4 = 34895.034; -} -{ - // Test constexpr - short sa[cxx11test::get_val()] = { 0 }; -} -{ - // Test initializer lists - cxx11test::testinit il = { 4323, 435234.23544 }; -} -{ - // Test range-based for - int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, - 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; - for (auto &x : array) { x += 23; } -} -{ - // Test lambda expressions - using cxx11test::eval; - assert (eval ([](int x) { return x*2; }, 21) == 42); - double d = 2.0; - assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0); - assert (d == 5.0); - assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0); - assert (d == 5.0); -} -{ - // Test use of variadic templates - using cxx11test::sum; - auto a = sum(1); - auto b = sum(1, 2); - auto c = sum(1.0, 2.0, 3.0); -} -{ - // Test constructor delegation - cxx11test::delegate d1; - cxx11test::delegate d2(); - cxx11test::delegate d3(45); -} -{ - // Test override and final - cxx11test::overridden o1(55464); -} -{ - // Test nullptr - char *c = nullptr; -} -{ - // Test template brackets - test_template<::test_template> v(test_template(12)); -} -{ - // Unicode literals - char const *utf8 = u8"UTF-8 string \u2500"; - char16_t const *utf16 = u"UTF-8 string \u2500"; - char32_t const *utf32 = U"UTF-32 string \u2500"; -} -' - -# Test code for whether the C compiler supports C++11 (complete). -ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals} -${ac_cxx_conftest_cxx11_globals} - -int -main (int argc, char **argv) -{ - int ok = 0; - ${ac_cxx_conftest_cxx98_main} - ${ac_cxx_conftest_cxx11_main} - return ok; -} -" - -# Test code for whether the C compiler supports C++98 (complete). -ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals} -int -main (int argc, char **argv) -{ - int ok = 0; - ${ac_cxx_conftest_cxx98_main} - return ok; -} -" - as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" @@ -3271,7 +3205,7 @@ ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${ # $ac_aux_dir_candidates and give up. ac_missing_aux_files="" ac_first_candidate=: -printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 +printf '%s\n' "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in $ac_aux_dir_candidates @@ -3284,7 +3218,7 @@ do esac as_found=: - printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 ac_aux_dir_found=yes ac_install_sh= for ac_aux in $ac_aux_files @@ -3295,13 +3229,13 @@ do if test x"$ac_aux" = x"install-sh" then if test -f "${as_dir}install-sh"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 ac_install_sh="${as_dir}install-sh -c" elif test -f "${as_dir}install.sh"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 ac_install_sh="${as_dir}install.sh -c" elif test -f "${as_dir}shtool"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 ac_install_sh="${as_dir}shtool install -c" else ac_aux_dir_found=no @@ -3313,7 +3247,7 @@ do fi else if test -f "${as_dir}${ac_aux}"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 else ac_aux_dir_found=no if $ac_first_candidate; then @@ -3366,38 +3300,44 @@ for ac_var in $ac_precious_vars; do eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 -printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 +printf '%s\n' "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 -printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 +printf '%s\n' "$as_me: error: '$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. - ac_old_val_w=`echo x $ac_old_val` - ac_new_val_w=`echo x $ac_new_val` + ac_old_val_w= + for ac_val in x $ac_old_val; do + ac_old_val_w="$ac_old_val_w $ac_val" + done + ac_new_val_w= + for ac_val in x $ac_new_val; do + ac_new_val_w="$ac_new_val_w $ac_val" + done if test "$ac_old_val_w" != "$ac_new_val_w"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 -printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 +printf '%s\n' "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 -printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 +printf '%s\n' "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 -printf "%s\n" "$as_me: former value: '$ac_old_val'" >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 -printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 +printf '%s\n' "$as_me: former value: '$ac_old_val'" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 +printf '%s\n' "$as_me: current value: '$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in - *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=$ac_var=`printf '%s\n' "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in @@ -3407,10 +3347,10 @@ printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} fi done if $ac_cache_corrupted; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 -printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +printf '%s\n' "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file' and start over" "$LINENO" 5 fi @@ -3418,6 +3358,23 @@ fi ## Main body of script. ## ## -------------------- ## + +# Determine whether it's possible to make 'echo' print without a newline. +# These variables are no longer used directly by Autoconf, but are AC_SUBSTed +# for compatibility with existing Makefiles. +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -3443,7 +3400,7 @@ ac_config_headers="$ac_config_headers db_config.h:config.hin" $SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 printf %s "checking build system type... " >&6; } if test ${ac_cv_build+y} then : @@ -3459,8 +3416,8 @@ ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 -printf "%s\n" "$ac_cv_build" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +printf '%s\n' "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; @@ -3476,10 +3433,10 @@ shift; shift # except with old shells: build_os=$* IFS=$ac_save_IFS -case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac +case $build_os in *\ *) build_os=`printf '%s\n' "$build_os" | sed 's/ /-/g'`;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 printf %s "checking host system type... " >&6; } if test ${ac_cv_host+y} then : @@ -3494,8 +3451,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 -printf "%s\n" "$ac_cv_host" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +printf '%s\n' "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; @@ -3511,7 +3468,7 @@ shift; shift # except with old shells: host_os=$* IFS=$ac_save_IFS -case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac +case $host_os in *\ *) host_os=`printf '%s\n' "$host_os" | sed 's/ /-/g'`;; esac test "$program_prefix" != NONE && @@ -3522,22 +3479,22 @@ test "$program_suffix" != NONE && # Double any \ or $. # By default was 's,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' -program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` +program_transform_name=`printf '%s\n' "$program_transform_name" | sed "$ac_script"` # Don't build in the dist directory. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if building in the top-level or dist directories" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if building in the top-level or dist directories" >&5 printf %s "checking if building in the top-level or dist directories... " >&6; } if test -f configure.ac ; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } as_fn_error $? "\ Berkeley DB should not be built in the \"dist\" directory. \ Change directory to the build_unix directory and run ../dist/configure \ from there." "$LINENO" 5 fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } topdir=`echo "$srcdir/.." | sed 's,/dist/\.\.,,'` # Substitution variables. BDB additions need to be documented. @@ -3630,7 +3587,7 @@ DB_VERSION_FULL_STRING='"Berkeley DB 11g Release 2, library version 11.2.5.3.29: # Process all options before using them. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-smallbuild option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-smallbuild option specified" >&5 printf %s "checking if --enable-smallbuild option specified... " >&6; } # Check whether --enable-smallbuild was given. if test ${enable_smallbuild+y} @@ -3645,10 +3602,10 @@ case "$db_cv_smallbuild" in yes) db_cv_build_full="no";; *) db_cv_build_full="yes";; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_smallbuild" >&5 -printf "%s\n" "$db_cv_smallbuild" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_smallbuild" >&5 +printf '%s\n' "$db_cv_smallbuild" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-atomicsupport option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-atomicsupport option specified" >&5 printf %s "checking if --disable-atomicsupport option specified... " >&6; } # Check whether --enable-atomicsupport was given. if test ${enable_atomicsupport+y} @@ -3661,10 +3618,10 @@ fi db_cv_build_atomicsupport="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac # --enable-bigfile was the configuration option that Berkeley DB used before @@ -3676,7 +3633,7 @@ then : fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-compression option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-compression option specified" >&5 printf %s "checking if --disable-compression option specified... " >&6; } # Check whether --enable-compression was given. if test ${enable_compression+y} @@ -3689,13 +3646,13 @@ fi db_cv_build_compression="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-hash option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-hash option specified" >&5 printf %s "checking if --disable-hash option specified... " >&6; } # Check whether --enable-hash was given. if test ${enable_hash+y} @@ -3708,13 +3665,13 @@ fi db_cv_build_hash="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-heap option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-heap option specified" >&5 printf %s "checking if --disable-heap option specified... " >&6; } # Check whether --enable-heap was given. if test ${enable_heap+y} @@ -3727,13 +3684,13 @@ fi db_cv_build_heap="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-mutexsupport option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-mutexsupport option specified" >&5 printf %s "checking if --disable-mutexsupport option specified... " >&6; } # Check whether --enable-mutexsupport was given. if test ${enable_mutexsupport+y} @@ -3746,13 +3703,13 @@ fi db_cv_build_mutexsupport="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-log_checksum option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-log_checksum option specified" >&5 printf %s "checking if --disable-log_checksum option specified... " >&6; } # Check whether --enable-log_checksum was given. if test ${enable_log_checksum+y} @@ -3767,14 +3724,14 @@ esac fi case "$db_cv_log_checksum" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-partition option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-partition option specified" >&5 printf %s "checking if --disable-partition option specified... " >&6; } # Check whether --enable-partition was given. if test ${enable_partition+y} @@ -3787,13 +3744,13 @@ fi db_cv_build_partition="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-queue option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-queue option specified" >&5 printf %s "checking if --disable-queue option specified... " >&6; } # Check whether --enable-queue was given. if test ${enable_queue+y} @@ -3806,13 +3763,13 @@ fi db_cv_build_queue="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-replication option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-replication option specified" >&5 printf %s "checking if --disable-replication option specified... " >&6; } # Check whether --enable-replication was given. if test ${enable_replication+y} @@ -3825,13 +3782,13 @@ fi db_cv_build_replication="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-statistics option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-statistics option specified" >&5 printf %s "checking if --disable-statistics option specified... " >&6; } # Check whether --enable-statistics was given. if test ${enable_statistics+y} @@ -3844,13 +3801,13 @@ fi db_cv_build_statistics="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --disable-verify option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --disable-verify option specified" >&5 printf %s "checking if --disable-verify option specified... " >&6; } # Check whether --enable-verify was given. if test ${enable_verify+y} @@ -3863,13 +3820,13 @@ fi db_cv_build_verify="$enableval" case "$enableval" in - no) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; };; -yes) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; };; + no) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; };; +yes) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; };; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-compat185 option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-compat185 option specified" >&5 printf %s "checking if --enable-compat185 option specified... " >&6; } # Check whether --enable-compat185 was given. if test ${enable_compat185+y} @@ -3880,10 +3837,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_compat185" >&5 -printf "%s\n" "$db_cv_compat185" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_compat185" >&5 +printf '%s\n' "$db_cv_compat185" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-cxx option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-cxx option specified" >&5 printf %s "checking if --enable-cxx option specified... " >&6; } # Check whether --enable-cxx was given. if test ${enable_cxx+y} @@ -3894,10 +3851,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_cxx" >&5 -printf "%s\n" "$db_cv_cxx" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_cxx" >&5 +printf '%s\n' "$db_cv_cxx" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-debug option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-debug option specified" >&5 printf %s "checking if --enable-debug option specified... " >&6; } # Check whether --enable-debug was given. if test ${enable_debug+y} @@ -3908,10 +3865,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug" >&5 -printf "%s\n" "$db_cv_debug" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug" >&5 +printf '%s\n' "$db_cv_debug" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-debug_rop option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-debug_rop option specified" >&5 printf %s "checking if --enable-debug_rop option specified... " >&6; } # Check whether --enable-debug_rop was given. if test ${enable_debug_rop+y} @@ -3922,10 +3879,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug_rop" >&5 -printf "%s\n" "$db_cv_debug_rop" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug_rop" >&5 +printf '%s\n' "$db_cv_debug_rop" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-debug_wop option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-debug_wop option specified" >&5 printf %s "checking if --enable-debug_wop option specified... " >&6; } # Check whether --enable-debug_wop was given. if test ${enable_debug_wop+y} @@ -3936,10 +3893,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug_wop" >&5 -printf "%s\n" "$db_cv_debug_wop" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_debug_wop" >&5 +printf '%s\n' "$db_cv_debug_wop" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-diagnostic option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-diagnostic option specified" >&5 printf %s "checking if --enable-diagnostic option specified... " >&6; } # Check whether --enable-diagnostic was given. if test ${enable_diagnostic+y} @@ -3951,25 +3908,25 @@ esac fi if test "$db_cv_diagnostic" = "yes"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_diagnostic" >&5 -printf "%s\n" "$db_cv_diagnostic" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_diagnostic" >&5 +printf '%s\n' "$db_cv_diagnostic" >&6; } fi if test "$db_cv_diagnostic" = "no" -a "$db_cv_debug_rop" = "yes"; then db_cv_diagnostic="yes" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: by --enable-debug_rop" >&5 -printf "%s\n" "by --enable-debug_rop" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: by --enable-debug_rop" >&5 +printf '%s\n' "by --enable-debug_rop" >&6; } fi if test "$db_cv_diagnostic" = "no" -a "$db_cv_debug_wop" = "yes"; then db_cv_diagnostic="yes" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: by --enable-debug_wop" >&5 -printf "%s\n" "by --enable-debug_wop" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: by --enable-debug_wop" >&5 +printf '%s\n' "by --enable-debug_wop" >&6; } fi if test "$db_cv_diagnostic" = "no"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_diagnostic" >&5 -printf "%s\n" "$db_cv_diagnostic" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_diagnostic" >&5 +printf '%s\n' "$db_cv_diagnostic" >&6; } fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-dump185 option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-dump185 option specified" >&5 printf %s "checking if --enable-dump185 option specified... " >&6; } # Check whether --enable-dump185 was given. if test ${enable_dump185+y} @@ -3980,10 +3937,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_dump185" >&5 -printf "%s\n" "$db_cv_dump185" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_dump185" >&5 +printf '%s\n' "$db_cv_dump185" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-java option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-java option specified" >&5 printf %s "checking if --enable-java option specified... " >&6; } # Check whether --enable-java was given. if test ${enable_java+y} @@ -3994,10 +3951,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_java" >&5 -printf "%s\n" "$db_cv_java" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_java" >&5 +printf '%s\n' "$db_cv_java" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-mingw option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-mingw option specified" >&5 printf %s "checking if --enable-mingw option specified... " >&6; } # Check whether --enable-mingw was given. if test ${enable_mingw+y} @@ -4008,10 +3965,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_mingw" >&5 -printf "%s\n" "$db_cv_mingw" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_mingw" >&5 +printf '%s\n' "$db_cv_mingw" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-o_direct option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-o_direct option specified" >&5 printf %s "checking if --enable-o_direct option specified... " >&6; } # Check whether --enable-o_direct was given. if test ${enable_o_direct+y} @@ -4022,10 +3979,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_o_direct" >&5 -printf "%s\n" "$db_cv_o_direct" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_o_direct" >&5 +printf '%s\n' "$db_cv_o_direct" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-posixmutexes option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-posixmutexes option specified" >&5 printf %s "checking if --enable-posixmutexes option specified... " >&6; } # Check whether --enable-posixmutexes was given. if test ${enable_posixmutexes+y} @@ -4036,26 +3993,26 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_posixmutexes" >&5 -printf "%s\n" "$db_cv_posixmutexes" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_posixmutexes" >&5 +printf '%s\n' "$db_cv_posixmutexes" >&6; } # Check whether --enable-pthread_self was given. if test ${enable_pthread_self+y} then : - enableval=$enable_pthread_self; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: --enable-pthread_self is now always enabled" >&5 -printf "%s\n" "$as_me: WARNING: --enable-pthread_self is now always enabled" >&2;} + enableval=$enable_pthread_self; { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: --enable-pthread_self is now always enabled" >&5 +printf '%s\n' "$as_me: WARNING: --enable-pthread_self is now always enabled" >&2;} fi # Check whether --enable-pthread_api was given. if test ${enable_pthread_api+y} then : - enableval=$enable_pthread_api; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: --enable-pthread_api is now always enabled" >&5 -printf "%s\n" "$as_me: WARNING: --enable-pthread_api is now always enabled" >&2;} + enableval=$enable_pthread_api; { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: --enable-pthread_api is now always enabled" >&5 +printf '%s\n' "$as_me: WARNING: --enable-pthread_api is now always enabled" >&2;} fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-rpc option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-rpc option specified" >&5 printf %s "checking if --enable-rpc option specified... " >&6; } # Check whether --enable-rpc was given. if test ${enable_rpc+y} @@ -4067,10 +4024,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_rpc" >&5 -printf "%s\n" "$db_cv_rpc" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_rpc" >&5 +printf '%s\n' "$db_cv_rpc" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-sql option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-sql option specified" >&5 printf %s "checking if --enable-sql option specified... " >&6; } # Check whether --enable-sql was given. if test ${enable_sql+y} @@ -4081,10 +4038,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql" >&5 -printf "%s\n" "$db_cv_sql" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql" >&5 +printf '%s\n' "$db_cv_sql" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-sql_compat option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-sql_compat option specified" >&5 printf %s "checking if --enable-sql_compat option specified... " >&6; } # Check whether --enable-sql_compat was given. if test ${enable_sql_compat+y} @@ -4095,10 +4052,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_compat" >&5 -printf "%s\n" "$db_cv_sql_compat" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_compat" >&5 +printf '%s\n' "$db_cv_sql_compat" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-jdbc option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-jdbc option specified" >&5 printf %s "checking if --enable-jdbc option specified... " >&6; } # Check whether --enable-jdbc was given. if test ${enable_jdbc+y} @@ -4109,10 +4066,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_jdbc" >&5 -printf "%s\n" "$db_cv_jdbc" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_jdbc" >&5 +printf '%s\n' "$db_cv_jdbc" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --with-jdbc=DIR option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --with-jdbc=DIR option specified" >&5 printf %s "checking if --with-jdbc=DIR option specified... " >&6; } # Check whether --with-jdbc was given. @@ -4124,13 +4081,13 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_jdbc" >&5 -printf "%s\n" "$with_jdbc" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_jdbc" >&5 +printf '%s\n' "$with_jdbc" >&6; } if test "$with_jdbc" != "no"; then db_cv_jdbc="yes" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-amalgamation option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-amalgamation option specified" >&5 printf %s "checking if --enable-amalgamation option specified... " >&6; } # Check whether --enable-amalgamation was given. if test ${enable_amalgamation+y} @@ -4141,10 +4098,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_amalgamation" >&5 -printf "%s\n" "$db_cv_sql_amalgamation" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_amalgamation" >&5 +printf '%s\n' "$db_cv_sql_amalgamation" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-sql_codegen option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-sql_codegen option specified" >&5 printf %s "checking if --enable-sql_codegen option specified... " >&6; } # Check whether --enable-sql_codegen was given. if test ${enable_sql_codegen+y} @@ -4155,10 +4112,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_codegen" >&5 -printf "%s\n" "$db_cv_sql_codegen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_sql_codegen" >&5 +printf '%s\n' "$db_cv_sql_codegen" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-stl option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-stl option specified" >&5 printf %s "checking if --enable-stl option specified... " >&6; } # Check whether --enable-stl was given. if test ${enable_stl+y} @@ -4172,10 +4129,10 @@ fi if test "$db_cv_stl" = "yes" -a "$db_cv_cxx" = "no"; then db_cv_cxx="yes" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_stl" >&5 -printf "%s\n" "$db_cv_stl" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_stl" >&5 +printf '%s\n' "$db_cv_stl" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-tcl option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-tcl option specified" >&5 printf %s "checking if --enable-tcl option specified... " >&6; } # Check whether --enable-tcl was given. if test ${enable_tcl+y} @@ -4186,10 +4143,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_tcl" >&5 -printf "%s\n" "$db_cv_tcl" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_tcl" >&5 +printf '%s\n' "$db_cv_tcl" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-test option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-test option specified" >&5 printf %s "checking if --enable-test option specified... " >&6; } # Check whether --enable-test was given. if test ${enable_test+y} @@ -4200,10 +4157,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_test" >&5 -printf "%s\n" "$db_cv_test" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_test" >&5 +printf '%s\n' "$db_cv_test" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-localization option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-localization option specified" >&5 printf %s "checking if --enable-localization option specified... " >&6; } # Check whether --enable-localization was given. if test ${enable_localization+y} @@ -4214,10 +4171,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_localization" >&5 -printf "%s\n" "$db_cv_localization" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_localization" >&5 +printf '%s\n' "$db_cv_localization" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-stripped_messages option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-stripped_messages option specified" >&5 printf %s "checking if --enable-stripped_messages option specified... " >&6; } # Check whether --enable-stripped_messages was given. if test ${enable_stripped_messages+y} @@ -4228,10 +4185,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_stripped_messages" >&5 -printf "%s\n" "$db_cv_stripped_messages" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_stripped_messages" >&5 +printf '%s\n' "$db_cv_stripped_messages" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-dbm option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-dbm option specified" >&5 printf %s "checking if --enable-dbm option specified... " >&6; } # Check whether --enable-dbm was given. if test ${enable_dbm+y} @@ -4242,10 +4199,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_dbm" >&5 -printf "%s\n" "$db_cv_dbm" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_dbm" >&5 +printf '%s\n' "$db_cv_dbm" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-dtrace option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-dtrace option specified" >&5 printf %s "checking if --enable-dtrace option specified... " >&6; } # Check whether --enable-dtrace was given. if test ${enable_dtrace+y} @@ -4256,10 +4213,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_dtrace" >&5 -printf "%s\n" "$db_cv_dtrace" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_dtrace" >&5 +printf '%s\n' "$db_cv_dtrace" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-systemtap option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-systemtap option specified" >&5 printf %s "checking if --enable-systemtap option specified... " >&6; } # Check whether --enable-systemtap was given. if test ${enable_systemtap+y} @@ -4270,10 +4227,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_systemtap" >&5 -printf "%s\n" "$db_cv_systemtap" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_systemtap" >&5 +printf '%s\n' "$db_cv_systemtap" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-perfmon-statistics option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-perfmon-statistics option specified" >&5 printf %s "checking if --enable-perfmon-statistics option specified... " >&6; } # Check whether --enable-perfmon_statistics was given. if test ${enable_perfmon_statistics+y} @@ -4284,10 +4241,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_perfmon_statistics" >&5 -printf "%s\n" "$db_cv_perfmon_statistics" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_perfmon_statistics" >&5 +printf '%s\n' "$db_cv_perfmon_statistics" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-uimutexes option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-uimutexes option specified" >&5 printf %s "checking if --enable-uimutexes option specified... " >&6; } # Check whether --enable-uimutexes was given. if test ${enable_uimutexes+y} @@ -4298,10 +4255,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_uimutexes" >&5 -printf "%s\n" "$db_cv_uimutexes" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_uimutexes" >&5 +printf '%s\n' "$db_cv_uimutexes" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-umrw option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-umrw option specified" >&5 printf %s "checking if --enable-umrw option specified... " >&6; } # Check whether --enable-umrw was given. if test ${enable_umrw+y} @@ -4312,8 +4269,8 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_umrw" >&5 -printf "%s\n" "$db_cv_umrw" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_umrw" >&5 +printf '%s\n' "$db_cv_umrw" >&6; } # Solaris, AI/X, OS/X and other BSD-derived systems default to POSIX-conforming # disk i/o: A single read or write call is atomic. Other systems do not @@ -4323,7 +4280,7 @@ case "$host_os" in solaris* | aix* | bsdi3* | freebsd* | darwin*) atomicfileread="yes";; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-atomicfileread option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-atomicfileread option specified" >&5 printf %s "checking if --enable-atomicfileread option specified... " >&6; } # Check whether --enable-atomicfileread was given. if test ${enable_atomicfileread+y} @@ -4334,10 +4291,10 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomicfileread" >&5 -printf "%s\n" "$db_cv_atomicfileread" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomicfileread" >&5 +printf '%s\n' "$db_cv_atomicfileread" >&6; } if test "$db_cv_atomicfileread" = "yes"; then - printf "%s\n" "#define HAVE_ATOMICFILEREAD 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMICFILEREAD 1" >>confdefs.h fi @@ -4353,7 +4310,7 @@ fi # --with-cryptography={yes|no|ipp} # which defaults to yes. The old enable/disable-cryptography argument is still # supported for backwards compatibility. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --with-cryptography option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --with-cryptography option specified" >&5 printf %s "checking if --with-cryptography option specified... " >&6; } # Check whether --enable-cryptography was given. if test ${enable_cryptography+y} @@ -4380,10 +4337,10 @@ yes|no|ipp) ;; *) as_fn_error $? "unknown --with-cryptography argument \'$with_cryptography\'" "$LINENO" 5 ;; esac db_cv_build_cryptography="$with_cryptography" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_build_cryptography" >&5 -printf "%s\n" "$db_cv_build_cryptography" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_build_cryptography" >&5 +printf '%s\n' "$db_cv_build_cryptography" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --with-mutex=MUTEX option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --with-mutex=MUTEX option specified" >&5 printf %s "checking if --with-mutex=MUTEX option specified... " >&6; } # Check whether --with-mutex was given. @@ -4401,8 +4358,8 @@ fi if test "$with_mutex" != "no"; then db_cv_mutex="$with_mutex" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_mutex" >&5 -printf "%s\n" "$with_mutex" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_mutex" >&5 +printf '%s\n' "$with_mutex" >&6; } # --with-mutexalign=ALIGNMENT was the configuration option that Berkeley DB # used before the DbEnv::mutex_set_align method was added. @@ -4425,7 +4382,7 @@ esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --with-tcl=DIR option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --with-tcl=DIR option specified" >&5 printf %s "checking if --with-tcl=DIR option specified... " >&6; } # Check whether --with-tcl was given. @@ -4437,13 +4394,13 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_tclconfig" >&5 -printf "%s\n" "$with_tclconfig" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_tclconfig" >&5 +printf '%s\n' "$with_tclconfig" >&6; } if test "$with_tclconfig" != "no"; then db_cv_tcl="yes" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --with-uniquename=NAME option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --with-uniquename=NAME option specified" >&5 printf %s "checking if --with-uniquename=NAME option specified... " >&6; } # Check whether --with-uniquename was given. @@ -4458,8 +4415,8 @@ fi if test "$with_uniquename" = "no"; then db_cv_uniquename="no" DB_VERSION_UNIQUE_NAME="" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_uniquename" >&5 -printf "%s\n" "$with_uniquename" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_uniquename" >&5 +printf '%s\n' "$with_uniquename" >&6; } else db_cv_uniquename="yes" if test "$with_uniquename" = "yes"; then @@ -4467,8 +4424,8 @@ else else DB_VERSION_UNIQUE_NAME="$with_uniquename" fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DB_VERSION_UNIQUE_NAME" >&5 -printf "%s\n" "$DB_VERSION_UNIQUE_NAME" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DB_VERSION_UNIQUE_NAME" >&5 +printf '%s\n' "$DB_VERSION_UNIQUE_NAME" >&6; } fi # Undocumented option used for the dbsql command line tool (to match SQLite). @@ -4492,7 +4449,7 @@ if test "$db_cv_jdbc" = "yes" -a "$db_cv_sql" = "no"; then db_cv_sql=$db_cv_jdbc fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if --enable-compile-commands option specified" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if --enable-compile-commands option specified" >&5 printf %s "checking if --enable-compile-commands option specified... " >&6; } # Check whether --enable-compile-commands was given. if test ${enable_compile_commands+y} @@ -4503,8 +4460,8 @@ else case e in #( esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_compile_commands" >&5 -printf "%s\n" "$db_cv_compile_commands" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_compile_commands" >&5 +printf '%s\n' "$db_cv_compile_commands" >&6; } # Testing requires Tcl. if test "$db_cv_test" = "yes" -a "$db_cv_tcl" = "no"; then @@ -4515,7 +4472,7 @@ fi if test "$db_cv_compile_commands" = "yes"; then # Extract the first word of "bear", so it can be a program name with args. set dummy bear; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_BEAR+y} then : @@ -4536,7 +4493,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_BEAR="bear" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4548,11 +4505,11 @@ esac fi BEAR=$ac_cv_prog_BEAR if test -n "$BEAR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BEAR" >&5 -printf "%s\n" "$BEAR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $BEAR" >&5 +printf '%s\n' "$BEAR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -4563,34 +4520,34 @@ fi # Set some #defines based on configuration options. if test "$db_cv_diagnostic" = "yes"; then - printf "%s\n" "#define DIAGNOSTIC 1" >>confdefs.h + printf '%s\n' "#define DIAGNOSTIC 1" >>confdefs.h fi if test "$db_cv_debug_rop" = "yes"; then - printf "%s\n" "#define DEBUG_ROP 1" >>confdefs.h + printf '%s\n' "#define DEBUG_ROP 1" >>confdefs.h fi if test "$db_cv_debug_wop" = "yes"; then - printf "%s\n" "#define DEBUG_WOP 1" >>confdefs.h + printf '%s\n' "#define DEBUG_WOP 1" >>confdefs.h fi if test "$db_cv_umrw" = "yes"; then - printf "%s\n" "#define UMRW 1" >>confdefs.h + printf '%s\n' "#define UMRW 1" >>confdefs.h fi if test "$db_cv_test" = "yes"; then - printf "%s\n" "#define CONFIG_TEST 1" >>confdefs.h + printf '%s\n' "#define CONFIG_TEST 1" >>confdefs.h fi -printf "%s\n" "#define HAVE_UPGRADE_SUPPORT 1" >>confdefs.h +printf '%s\n' "#define HAVE_UPGRADE_SUPPORT 1" >>confdefs.h # Check for programs used in building and installation. @@ -4599,7 +4556,7 @@ printf "%s\n" "#define HAVE_UPGRADE_SUPPORT 1" >>confdefs.h if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}chmod", so it can be a program name with args. set dummy ${ac_tool_prefix}chmod; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CHMOD+y} then : @@ -4620,7 +4577,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CHMOD="${ac_tool_prefix}chmod" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4632,11 +4589,11 @@ esac fi CHMOD=$ac_cv_prog_CHMOD if test -n "$CHMOD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 -printf "%s\n" "$CHMOD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 +printf '%s\n' "$CHMOD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -4645,7 +4602,7 @@ if test -z "$ac_cv_prog_CHMOD"; then ac_ct_CHMOD=$CHMOD # Extract the first word of "chmod", so it can be a program name with args. set dummy chmod; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CHMOD+y} then : @@ -4666,7 +4623,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CHMOD="chmod" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4678,11 +4635,11 @@ esac fi ac_ct_CHMOD=$ac_cv_prog_ac_ct_CHMOD if test -n "$ac_ct_CHMOD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CHMOD" >&5 -printf "%s\n" "$ac_ct_CHMOD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CHMOD" >&5 +printf '%s\n' "$ac_ct_CHMOD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CHMOD" = x; then @@ -4690,8 +4647,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CHMOD=$ac_ct_CHMOD @@ -4705,7 +4662,7 @@ test "$CHMOD" = "none" && as_fn_error $? "No chmod utility found." "$LINENO" 5 if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cp", so it can be a program name with args. set dummy ${ac_tool_prefix}cp; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CP+y} then : @@ -4726,7 +4683,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CP="${ac_tool_prefix}cp" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4738,11 +4695,11 @@ esac fi CP=$ac_cv_prog_CP if test -n "$CP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 -printf "%s\n" "$CP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 +printf '%s\n' "$CP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -4751,7 +4708,7 @@ if test -z "$ac_cv_prog_CP"; then ac_ct_CP=$CP # Extract the first word of "cp", so it can be a program name with args. set dummy cp; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CP+y} then : @@ -4772,7 +4729,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CP="cp" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4784,11 +4741,11 @@ esac fi ac_ct_CP=$ac_cv_prog_ac_ct_CP if test -n "$ac_ct_CP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CP" >&5 -printf "%s\n" "$ac_ct_CP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CP" >&5 +printf '%s\n' "$ac_ct_CP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CP" = x; then @@ -4796,8 +4753,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CP=$ac_ct_CP @@ -4813,7 +4770,7 @@ if test "$db_cv_test" = "yes"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}kill", so it can be a program name with args. set dummy ${ac_tool_prefix}kill; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_KILL+y} then : @@ -4834,7 +4791,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_KILL="${ac_tool_prefix}kill" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4846,11 +4803,11 @@ esac fi KILL=$ac_cv_prog_KILL if test -n "$KILL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $KILL" >&5 -printf "%s\n" "$KILL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $KILL" >&5 +printf '%s\n' "$KILL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -4859,7 +4816,7 @@ if test -z "$ac_cv_prog_KILL"; then ac_ct_KILL=$KILL # Extract the first word of "kill", so it can be a program name with args. set dummy kill; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_KILL+y} then : @@ -4880,7 +4837,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_KILL="kill" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4892,11 +4849,11 @@ esac fi ac_ct_KILL=$ac_cv_prog_ac_ct_KILL if test -n "$ac_ct_KILL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_KILL" >&5 -printf "%s\n" "$ac_ct_KILL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_KILL" >&5 +printf '%s\n' "$ac_ct_KILL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_KILL" = x; then @@ -4904,8 +4861,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac KILL=$ac_ct_KILL @@ -4920,7 +4877,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ln", so it can be a program name with args. set dummy ${ac_tool_prefix}ln; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_LN+y} then : @@ -4941,7 +4898,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_LN="${ac_tool_prefix}ln" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4953,11 +4910,11 @@ esac fi LN=$ac_cv_prog_LN if test -n "$LN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5 -printf "%s\n" "$LN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LN" >&5 +printf '%s\n' "$LN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -4966,7 +4923,7 @@ if test -z "$ac_cv_prog_LN"; then ac_ct_LN=$LN # Extract the first word of "ln", so it can be a program name with args. set dummy ln; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_LN+y} then : @@ -4987,7 +4944,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_LN="ln" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4999,11 +4956,11 @@ esac fi ac_ct_LN=$ac_cv_prog_ac_ct_LN if test -n "$ac_ct_LN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LN" >&5 -printf "%s\n" "$ac_ct_LN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LN" >&5 +printf '%s\n' "$ac_ct_LN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_LN" = x; then @@ -5011,8 +4968,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac LN=$ac_ct_LN @@ -5026,7 +4983,7 @@ test "$LN" = "none" && as_fn_error $? "No ln utility found." "$LINENO" 5 if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mkdir", so it can be a program name with args. set dummy ${ac_tool_prefix}mkdir; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_MKDIR+y} then : @@ -5047,7 +5004,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MKDIR="${ac_tool_prefix}mkdir" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5059,11 +5016,11 @@ esac fi MKDIR=$ac_cv_prog_MKDIR if test -n "$MKDIR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 -printf "%s\n" "$MKDIR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 +printf '%s\n' "$MKDIR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5072,7 +5029,7 @@ if test -z "$ac_cv_prog_MKDIR"; then ac_ct_MKDIR=$MKDIR # Extract the first word of "mkdir", so it can be a program name with args. set dummy mkdir; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_MKDIR+y} then : @@ -5093,7 +5050,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_MKDIR="mkdir" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5105,11 +5062,11 @@ esac fi ac_ct_MKDIR=$ac_cv_prog_ac_ct_MKDIR if test -n "$ac_ct_MKDIR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MKDIR" >&5 -printf "%s\n" "$ac_ct_MKDIR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MKDIR" >&5 +printf '%s\n' "$ac_ct_MKDIR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_MKDIR" = x; then @@ -5117,8 +5074,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac MKDIR=$ac_ct_MKDIR @@ -5132,7 +5089,7 @@ test "$MKDIR" = "none" && as_fn_error $? "No mkdir utility found." "$LINENO" 5 if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}rm", so it can be a program name with args. set dummy ${ac_tool_prefix}rm; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_RM+y} then : @@ -5153,7 +5110,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RM="${ac_tool_prefix}rm" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5165,11 +5122,11 @@ esac fi RM=$ac_cv_prog_RM if test -n "$RM"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 -printf "%s\n" "$RM" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 +printf '%s\n' "$RM" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5178,7 +5135,7 @@ if test -z "$ac_cv_prog_RM"; then ac_ct_RM=$RM # Extract the first word of "rm", so it can be a program name with args. set dummy rm; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_RM+y} then : @@ -5199,7 +5156,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_RM="rm" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5211,11 +5168,11 @@ esac fi ac_ct_RM=$ac_cv_prog_ac_ct_RM if test -n "$ac_ct_RM"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RM" >&5 -printf "%s\n" "$ac_ct_RM" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RM" >&5 +printf '%s\n' "$ac_ct_RM" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_RM" = x; then @@ -5223,8 +5180,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RM=$ac_ct_RM @@ -5241,7 +5198,7 @@ RM="$RM -f" if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mv", so it can be a program name with args. set dummy ${ac_tool_prefix}mv; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_MV+y} then : @@ -5262,7 +5219,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MV="${ac_tool_prefix}mv" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5274,11 +5231,11 @@ esac fi MV=$ac_cv_prog_MV if test -n "$MV"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 -printf "%s\n" "$MV" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 +printf '%s\n' "$MV" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5287,7 +5244,7 @@ if test -z "$ac_cv_prog_MV"; then ac_ct_MV=$MV # Extract the first word of "mv", so it can be a program name with args. set dummy mv; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_MV+y} then : @@ -5308,7 +5265,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_MV="mv" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5320,11 +5277,11 @@ esac fi ac_ct_MV=$ac_cv_prog_ac_ct_MV if test -n "$ac_ct_MV"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MV" >&5 -printf "%s\n" "$ac_ct_MV" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MV" >&5 +printf '%s\n' "$ac_ct_MV" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_MV" = x; then @@ -5332,8 +5289,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac MV=$ac_ct_MV @@ -5348,7 +5305,7 @@ if test "$db_cv_systemtap" = "yes" -o "$db_cv_dtrace" = "yes"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}stap", so it can be a program name with args. set dummy ${ac_tool_prefix}stap; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STAP+y} then : @@ -5369,7 +5326,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STAP="${ac_tool_prefix}stap" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5381,11 +5338,11 @@ esac fi STAP=$ac_cv_prog_STAP if test -n "$STAP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAP" >&5 -printf "%s\n" "$STAP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STAP" >&5 +printf '%s\n' "$STAP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5394,7 +5351,7 @@ if test -z "$ac_cv_prog_STAP"; then ac_ct_STAP=$STAP # Extract the first word of "stap", so it can be a program name with args. set dummy stap; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STAP+y} then : @@ -5415,7 +5372,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STAP="stap" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5427,11 +5384,11 @@ esac fi ac_ct_STAP=$ac_cv_prog_ac_ct_STAP if test -n "$ac_ct_STAP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STAP" >&5 -printf "%s\n" "$ac_ct_STAP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STAP" >&5 +printf '%s\n' "$ac_ct_STAP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_STAP" = x; then @@ -5439,8 +5396,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STAP=$ac_ct_STAP @@ -5458,7 +5415,7 @@ if test "$db_cv_dtrace" = "yes"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dtrace", so it can be a program name with args. set dummy ${ac_tool_prefix}dtrace; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DTRACE+y} then : @@ -5479,7 +5436,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DTRACE="${ac_tool_prefix}dtrace" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5491,11 +5448,11 @@ esac fi DTRACE=$ac_cv_prog_DTRACE if test -n "$DTRACE"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5 -printf "%s\n" "$DTRACE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5 +printf '%s\n' "$DTRACE" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5504,7 +5461,7 @@ if test -z "$ac_cv_prog_DTRACE"; then ac_ct_DTRACE=$DTRACE # Extract the first word of "dtrace", so it can be a program name with args. set dummy dtrace; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DTRACE+y} then : @@ -5525,7 +5482,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DTRACE="dtrace" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5537,11 +5494,11 @@ esac fi ac_ct_DTRACE=$ac_cv_prog_ac_ct_DTRACE if test -n "$ac_ct_DTRACE"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DTRACE" >&5 -printf "%s\n" "$ac_ct_DTRACE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DTRACE" >&5 +printf '%s\n' "$ac_ct_DTRACE" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DTRACE" = x; then @@ -5549,8 +5506,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DTRACE=$ac_ct_DTRACE @@ -5565,7 +5522,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}sed", so it can be a program name with args. set dummy ${ac_tool_prefix}sed; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_SED+y} then : @@ -5586,7 +5543,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_SED="${ac_tool_prefix}sed" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5598,11 +5555,11 @@ esac fi SED=$ac_cv_prog_SED if test -n "$SED"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 -printf "%s\n" "$SED" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +printf '%s\n' "$SED" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5611,7 +5568,7 @@ if test -z "$ac_cv_prog_SED"; then ac_ct_SED=$SED # Extract the first word of "sed", so it can be a program name with args. set dummy sed; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_SED+y} then : @@ -5632,7 +5589,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_SED="sed" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5644,11 +5601,11 @@ esac fi ac_ct_SED=$ac_cv_prog_ac_ct_SED if test -n "$ac_ct_SED"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_SED" >&5 -printf "%s\n" "$ac_ct_SED" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_SED" >&5 +printf '%s\n' "$ac_ct_SED" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_SED" = x; then @@ -5656,8 +5613,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac SED=$ac_ct_SED @@ -5669,7 +5626,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}perl", so it can be a program name with args. set dummy ${ac_tool_prefix}perl; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_PERL+y} then : @@ -5690,7 +5647,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PERL="${ac_tool_prefix}perl" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5702,11 +5659,11 @@ esac fi PERL=$ac_cv_prog_PERL if test -n "$PERL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5 -printf "%s\n" "$PERL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5 +printf '%s\n' "$PERL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5715,7 +5672,7 @@ if test -z "$ac_cv_prog_PERL"; then ac_ct_PERL=$PERL # Extract the first word of "perl", so it can be a program name with args. set dummy perl; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_PERL+y} then : @@ -5736,7 +5693,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_PERL="perl" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5748,11 +5705,11 @@ esac fi ac_ct_PERL=$ac_cv_prog_ac_ct_PERL if test -n "$ac_ct_PERL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PERL" >&5 -printf "%s\n" "$ac_ct_PERL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PERL" >&5 +printf '%s\n' "$ac_ct_PERL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_PERL" = x; then @@ -5760,8 +5717,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac PERL=$ac_ct_PERL @@ -5779,7 +5736,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}sh", so it can be a program name with args. set dummy ${ac_tool_prefix}sh; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_db_cv_path_sh+y} then : @@ -5802,7 +5759,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_db_cv_path_sh="$as_dir$ac_word$ac_exec_ext" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5815,11 +5772,11 @@ esac fi db_cv_path_sh=$ac_cv_path_db_cv_path_sh if test -n "$db_cv_path_sh"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_path_sh" >&5 -printf "%s\n" "$db_cv_path_sh" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_path_sh" >&5 +printf '%s\n' "$db_cv_path_sh" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5828,7 +5785,7 @@ if test -z "$ac_cv_path_db_cv_path_sh"; then ac_pt_db_cv_path_sh=$db_cv_path_sh # Extract the first word of "sh", so it can be a program name with args. set dummy sh; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_ac_pt_db_cv_path_sh+y} then : @@ -5851,7 +5808,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_db_cv_path_sh="$as_dir$ac_word$ac_exec_ext" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5864,11 +5821,11 @@ esac fi ac_pt_db_cv_path_sh=$ac_cv_path_ac_pt_db_cv_path_sh if test -n "$ac_pt_db_cv_path_sh"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_db_cv_path_sh" >&5 -printf "%s\n" "$ac_pt_db_cv_path_sh" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_pt_db_cv_path_sh" >&5 +printf '%s\n' "$ac_pt_db_cv_path_sh" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_pt_db_cv_path_sh" = x; then @@ -5876,8 +5833,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac db_cv_path_sh=$ac_pt_db_cv_path_sh @@ -5907,7 +5864,7 @@ fi # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 printf %s "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if test ${ac_cv_path_install+y} @@ -5930,8 +5887,8 @@ case $as_dir in #(( ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *) - # OSF1 and SCO ODT 3.0 have their own names for install. - # Don't use installbsd from OSF since it installs stuff as root + # OSF/1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF/1 since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do @@ -5981,8 +5938,8 @@ fi INSTALL=$ac_install_sh fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 -printf "%s\n" "$INSTALL" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +printf '%s\n' "$INSTALL" >&6; } # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. @@ -6004,84 +5961,14 @@ fi # Respect the environment LIBS settings LIBSO_LIBS="$LIBS" -# This is where we handle stuff that autoconf can't handle: compiler, -# preprocessor and load flags, libraries that the standard tests don't -# look for. -# -# There are additional libraries we need for some compiler/architecture -# combinations. -# -# Some architectures require DB to be compiled with special flags and/or -# libraries for threaded applications -# -# The makefile CC may be different than the CC used in config testing, -# because the makefile CC may be set to use $(LIBTOOL). -# -# Don't override anything if it's already set from the environment. -optimize_flag="-O" -extra_cflags="" - -case "$host_os" in -aix4.3.*|aix[5-9]*) - case "$host_os" in - aix4.3.*) - CPPFLAGS="$CPPFLAGS -D_LINUX_SOURCE_COMPAT";; - esac - # IBM's XLC compilers (at least versions 7/8/9) generate incorrect code - # when ordinary optimization is enabled because they make strong - # assumptions about the types held at each memory location, and some - # Berkeley DB code violates those assumptions. [#16141] - extra_cflags=" -qalias=noansi" - optimize_flag="-O2" - CC=${CC-"xlc_r"} - CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" - LDFLAGS="$LDFLAGS -Wl,-brtl";; -bsdi3*) CC=${CC-"shlicc2"} - LIBSO_LIBS="$LIBSO_LIBS -lipc";; -cygwin*) - CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE -D_REENTRANT";; -freebsd*) - CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" - LDFLAGS="$LDFLAGS -pthread";; -gnu*|k*bsd*-gnu|linux*) - CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE -D_REENTRANT";; -hpux*) CPPFLAGS="$CPPFLAGS -D_REENTRANT";; -irix*) optimize_flag="-O2" - CPPFLAGS="$CPPFLAGS -D_SGI_MP_SOURCE";; -mpeix*) CPPFLAGS="$CPPFLAGS -D_POSIX_SOURCE -D_SOCKET_SOURCE" - LIBSO_LIBS="$LIBSO_LIBS -lsocket -lsvipc";; -osf*) CPPFLAGS="$CPPFLAGS -pthread";; -*qnx*) qnx_build="yes" - printf "%s\n" "#define HAVE_QNX 1" >>confdefs.h - - ;; -solaris*) - CPPFLAGS="$CPPFLAGS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS ";; -esac - -# Set CFLAGS/CXXFLAGS. We MUST set the flags before we call autoconf -# compiler configuration macros, because if we don't, they set CFLAGS -# to no optimization and -g, which isn't what we want. -# -# If the user wants a debugging environment, add -g the their compiler flags -# and don't automatically optimize. If you want to compile with a different -# set of flags, specify CFLAGS in the environment before configuring. -if test "$db_cv_debug" = "yes"; then - printf "%s\n" "#define DEBUG 1" >>confdefs.h +# Asynchronous I/O backends for the buffer pool (os_aio), selected at +# runtime in preference order: io_uring (Linux) > IOCP (Windows) > +# kqueue+aio (BSD) > POSIX aio (Solaris/illumos, macOS) > thread-pool +# offload (last-resort fallback). All are optional -- without any, os_aio +# falls back to synchronous I/O. - CFLAGS="-g $CFLAGS" -else - CFLAGS=${CFLAGS-$optimize_flag} -fi - -CFLAGS="$CFLAGS$extra_cflags" -CXXFLAGS=${CXXFLAGS-"$CFLAGS"} - -# The default compiler is cc (NOT gcc), the default CFLAGS is as specified -# above, NOT what is set by AC_PROG_CC, as it won't set optimization flags -# for any compiler other than gcc. @@ -6097,11 +5984,225 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then - for ac_prog in cc gcc + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_ac_ct_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" + fi +fi +fi ;; +esac +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -6122,7 +6223,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -6134,11 +6235,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -6147,11 +6248,11 @@ fi fi if test -z "$CC"; then ac_ct_CC=$CC - for ac_prog in cc gcc + for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : @@ -6172,7 +6273,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -6184,11 +6285,11 @@ esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -printf "%s\n" "$ac_ct_CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -6200,22 +6301,130 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args. +set dummy ${ac_tool_prefix}clang; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}clang" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "clang", so it can be a program name with args. +set dummy clang; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_ac_ct_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="clang" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi +else + CC="$ac_cv_prog_CC" +fi + fi -test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +test -z "$CC" && { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See 'config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. -printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion -version; do @@ -6225,7 +6434,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -6235,7 +6444,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done @@ -6255,9 +6464,9 @@ ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 printf %s "checking whether the C compiler works... " >&6; } -ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +ac_link_default=`printf '%s\n' "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" @@ -6278,10 +6487,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'. @@ -6322,29 +6531,29 @@ esac fi if test -z "$ac_file" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } -printf "%s\n" "$as_me: failed program was:" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See 'config.log' for more details" "$LINENO" 5; } else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } ;; + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 printf %s "checking for C compiler default output file name... " >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 -printf "%s\n" "$ac_file" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +printf '%s\n' "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 printf %s "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in @@ -6352,10 +6561,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # If both 'conftest.exe' and 'conftest' are 'present' (well, observable) @@ -6372,15 +6581,15 @@ for ac_file in conftest.exe conftest conftest.*; do esac done else case e in #( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See 'config.log' for more details" "$LINENO" 5; } ;; esac fi rm -f conftest conftest$ac_cv_exeext -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 -printf "%s\n" "$ac_cv_exeext" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +printf '%s\n' "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext @@ -6403,7 +6612,7 @@ _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 printf %s "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" @@ -6412,10 +6621,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in @@ -6423,31 +6632,31 @@ printf "%s\n" "$ac_try_echo"; } >&5 *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "cannot run C compiled programs. If you meant to cross compile, use '--host'. See 'config.log' for more details" "$LINENO" 5; } fi fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 -printf "%s\n" "$cross_compiling" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +printf '%s\n' "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext \ conftest.o conftest.obj conftest.out ac_clean_files=$ac_clean_files_save -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 printf %s "checking for suffix of object files... " >&6; } if test ${ac_cv_objext+y} then : @@ -6471,10 +6680,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : for ac_file in conftest.o conftest.obj conftest.*; do @@ -6486,11 +6695,11 @@ then : esac done else case e in #( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -6498,11 +6707,906 @@ fi rm -f conftest.$ac_cv_objext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 -printf "%s\n" "$ac_cv_objext" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +printf '%s\n' "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 +printf %s "checking whether the compiler supports GNU C... " >&6; } +if test ${ac_cv_c_compiler_gnu+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_compiler_gnu=yes +else case e in #( + e) ac_compiler_gnu=no ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_c_compiler_gnu" >&6; } +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+y} +ac_save_CFLAGS=$CFLAGS +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +printf %s "checking whether $CC accepts -g... " >&6; } +if test ${ac_cv_prog_cc_g+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +else case e in #( + e) CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + +else case e in #( + e) ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +printf '%s\n' "$ac_cv_prog_cc_g" >&6; } +if test $ac_test_CFLAGS; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +ac_prog_cc_stdc=no +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C23 features" >&5 +printf %s "checking for $CC option to enable C23 features... " >&6; } +if test ${ac_cv_prog_cc_c23+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_cv_prog_cc_c23=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c23_program +_ACEOF +for ac_arg in '' -std=gnu23 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c23=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c23" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c23" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in #( + e) if test "x$ac_cv_prog_cc_c23" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in #( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c23" >&5 +printf '%s\n' "$ac_cv_prog_cc_c23" >&6; } + CC="$CC $ac_cv_prog_cc_c23" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c23 + ac_prog_cc_stdc=c23 ;; +esac +fi +fi +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 +printf %s "checking for $CC option to enable C11 features... " >&6; } +if test ${ac_cv_prog_cc_c11+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_cv_prog_cc_c11=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c11_program +_ACEOF +for ac_arg in '' -std=gnu11 -std:c11 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c11=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c11" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c11" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in #( + e) if test "x$ac_cv_prog_cc_c11" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in #( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 +printf '%s\n' "$ac_cv_prog_cc_c11" >&6; } + CC="$CC $ac_cv_prog_cc_c11" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 + ac_prog_cc_stdc=c11 ;; +esac +fi +fi +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 +printf %s "checking for $CC option to enable C99 features... " >&6; } +if test ${ac_cv_prog_cc_c99+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_cv_prog_cc_c99=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c99_program +_ACEOF +for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c99=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c99" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c99" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in #( + e) if test "x$ac_cv_prog_cc_c99" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in #( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +printf '%s\n' "$ac_cv_prog_cc_c99" >&6; } + CC="$CC $ac_cv_prog_cc_c99" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 + ac_prog_cc_stdc=c99 ;; +esac +fi +fi +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 +printf %s "checking for $CC option to enable C89 features... " >&6; } +if test ${ac_cv_prog_cc_c89+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c89_program +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c89" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in #( + e) if test "x$ac_cv_prog_cc_c89" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in #( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +printf '%s\n' "$ac_cv_prog_cc_c89" >&6; } + CC="$CC $ac_cv_prog_cc_c89" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 + ac_prog_cc_stdc=c89 ;; +esac +fi +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_header= ac_cache= +for ac_item in $ac_header_c_list +do + if test $ac_cache; then + ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" + if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then + printf '%s\n' "#define $ac_item 1" >> confdefs.h + fi + ac_header= ac_cache= + elif test $ac_header; then + ac_cache=$ac_item + else + ac_header=$ac_item + fi +done + + + + + + + + +if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes +then : + +printf '%s\n' "#define STDC_HEADERS 1" >>confdefs.h + +fi +ac_fn_c_check_header_compile "$LINENO" "liburing.h" "ac_cv_header_liburing_h" "$ac_includes_default" +if test "x$ac_cv_header_liburing_h" = xyes +then : + + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for io_uring_queue_init in -luring" >&5 +printf %s "checking for io_uring_queue_init in -luring... " >&6; } +if test ${ac_cv_lib_uring_io_uring_queue_init+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS +LIBS="-luring $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char io_uring_queue_init (void); +int +main (void) +{ +return io_uring_queue_init (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO" +then : + ac_cv_lib_uring_io_uring_queue_init=yes +else case e in #( + e) ac_cv_lib_uring_io_uring_queue_init=no ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_uring_io_uring_queue_init" >&5 +printf '%s\n' "$ac_cv_lib_uring_io_uring_queue_init" >&6; } +if test "x$ac_cv_lib_uring_io_uring_queue_init" = xyes +then : + + +printf '%s\n' "#define HAVE_IO_URING 1" >>confdefs.h + + LIBSO_LIBS="$LIBSO_LIBS -luring" + LIBS="$LIBS -luring" +fi + +fi + + +# POSIX aio: aio_read/aio_write may live in libc (BSD/macOS) or librt +# (Solaris/illumos, glibc). Record the library so os_aio_posix links. +ac_fn_c_check_header_compile "$LINENO" "aio.h" "ac_cv_header_aio_h" "$ac_includes_default" +if test "x$ac_cv_header_aio_h" = xyes +then : + + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing aio_read" >&5 +printf %s "checking for library containing aio_read... " >&6; } +if test ${ac_cv_search_aio_read+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_func_search_save_LIBS=$LIBS +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char aio_read (void); +int +main (void) +{ +return aio_read (); + ; + return 0; +} +_ACEOF +for ac_lib in '' rt aio +do + if test -z "$ac_lib"; then + ac_res="none required" + else + ac_res=-l$ac_lib + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + fi + if ac_fn_c_try_link "$LINENO" +then : + ac_cv_search_aio_read=$ac_res +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext + if test ${ac_cv_search_aio_read+y} +then : + break +fi +done +if test ${ac_cv_search_aio_read+y} +then : + +else case e in #( + e) ac_cv_search_aio_read=no ;; +esac +fi +rm conftest.$ac_ext +LIBS=$ac_func_search_save_LIBS ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_aio_read" >&5 +printf '%s\n' "$ac_cv_search_aio_read" >&6; } +ac_res=$ac_cv_search_aio_read +if test "$ac_res" != no +then : + test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + + +printf '%s\n' "#define HAVE_AIO_POSIX 1" >>confdefs.h + +fi + +fi + + +# kqueue+aio (BSD, notably FreeBSD): needs EVFILT_AIO and, crucially, the +# sigev_notify_kqueue member of struct sigevent so a completed aiocb posts a +# kevent. macOS has EVFILT_AIO but lacks sigev_notify_kqueue, so it is +# excluded here and uses the POSIX aio backend instead. +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to detect undeclared functions" >&5 +printf %s "checking for $CC options to detect undeclared functions... " >&6; } +if test ${ac_cv_c_undeclared_builtin_options+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_save_CFLAGS=$CFLAGS + ac_cv_c_undeclared_builtin_options='cannot detect' + for ac_arg in '' -fno-builtin; do + CFLAGS="$ac_save_CFLAGS $ac_arg" + # This test program should *not* compile successfully. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ +(void) strchr; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + +else case e in #( + e) # This test program should compile successfully. + # No library function is consistently available on + # freestanding implementations, so test against a dummy + # declaration. Include always-available headers on the + # off chance that they somehow elicit warnings. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include +extern void ac_decl (int, char *); + +int +main (void) +{ +(void) ac_decl (0, (char *) 0); + (void) ac_decl; + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + if test x"$ac_arg" = x +then : + ac_cv_c_undeclared_builtin_options='none needed' +else case e in #( + e) ac_cv_c_undeclared_builtin_options=$ac_arg ;; +esac +fi + break +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + done + CFLAGS=$ac_save_CFLAGS + ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5 +printf '%s\n' "$ac_cv_c_undeclared_builtin_options" >&6; } + case $ac_cv_c_undeclared_builtin_options in #( + 'cannot detect') : + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} +as_fn_error $? "cannot make $CC report undeclared builtins +See 'config.log' for more details" "$LINENO" 5; } ;; #( + 'none needed') : + ac_c_undeclared_builtin_options='' ;; #( + *) : + ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; +esac + +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to ignore future-version functions" >&5 +printf %s "checking for $CC options to ignore future-version functions... " >&6; } +if test ${ac_cv_c_future_darwin_options+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_compile_saved="$ac_compile" + ac_compile="$ac_compile -Werror=unguarded-availability-new" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#if ! (defined __APPLE__ && defined __MACH__) + #error "-Werror=unguarded-availability-new not needed here" + #endif + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_c_future_darwin_options='-Werror=unguarded-availability-new' +else case e in #( + e) ac_cv_c_future_darwin_options='none needed' ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_compile="$ac_compile_saved" + ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_future_darwin_options" >&5 +printf '%s\n' "$ac_cv_c_future_darwin_options" >&6; } + case $ac_cv_c_future_darwin_options in #( + 'none needed') : + ac_c_future_darwin_options='' ;; #( + *) : + ac_c_future_darwin_options=$ac_cv_c_future_darwin_options ;; +esac + +ac_fn_c_check_member "$LINENO" "struct sigevent" "sigev_notify_kqueue" "ac_cv_member_struct_sigevent_sigev_notify_kqueue" "#include +#include +" +if test "x$ac_cv_member_struct_sigevent_sigev_notify_kqueue" = xyes +then : + ac_fn_check_decl "$LINENO" "EVFILT_AIO" "ac_cv_have_decl_EVFILT_AIO" "#include +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" +if test "x$ac_cv_have_decl_EVFILT_AIO" = xyes +then : + + +printf '%s\n' "#define HAVE_AIO_KQUEUE 1" >>confdefs.h + +fi +fi + + +ac_fn_c_check_header_compile "$LINENO" "pthread.h" "ac_cv_header_pthread_h" "$ac_includes_default" +if test "x$ac_cv_header_pthread_h" = xyes +then : + + +printf '%s\n' "#define HAVE_AIO_THREADPOOL 1" >>confdefs.h + +fi + + +# This is where we handle stuff that autoconf can't handle: compiler, +# preprocessor and load flags, libraries that the standard tests don't +# look for. +# +# There are additional libraries we need for some compiler/architecture +# combinations. +# +# Some architectures require DB to be compiled with special flags and/or +# libraries for threaded applications +# +# The makefile CC may be different than the CC used in config testing, +# because the makefile CC may be set to use $(LIBTOOL). +# +# Don't override anything if it's already set from the environment. +optimize_flag="-O" +extra_cflags="" + +case "$host_os" in +aix4.3.*|aix[5-9]*) + case "$host_os" in + aix4.3.*) + CPPFLAGS="$CPPFLAGS -D_LINUX_SOURCE_COMPAT";; + esac + # IBM's XLC compilers (at least versions 7/8/9) generate incorrect code + # when ordinary optimization is enabled because they make strong + # assumptions about the types held at each memory location, and some + # Berkeley DB code violates those assumptions. [#16141] + extra_cflags=" -qalias=noansi" + optimize_flag="-O2" + CC=${CC-"xlc_r"} + CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" + LDFLAGS="$LDFLAGS -Wl,-brtl";; +bsdi3*) CC=${CC-"shlicc2"} + LIBSO_LIBS="$LIBSO_LIBS -lipc";; +cygwin*) + CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE -D_REENTRANT";; +freebsd*) + CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" + LDFLAGS="$LDFLAGS -pthread";; +gnu*|k*bsd*-gnu|linux*) + CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE -D_REENTRANT";; +hpux*) CPPFLAGS="$CPPFLAGS -D_REENTRANT";; +irix*) optimize_flag="-O2" + CPPFLAGS="$CPPFLAGS -D_SGI_MP_SOURCE";; +mpeix*) CPPFLAGS="$CPPFLAGS -D_POSIX_SOURCE -D_SOCKET_SOURCE" + LIBSO_LIBS="$LIBSO_LIBS -lsocket -lsvipc";; +osf*) CPPFLAGS="$CPPFLAGS -pthread";; +*qnx*) qnx_build="yes" + printf '%s\n' "#define HAVE_QNX 1" >>confdefs.h + + ;; +solaris*) + CPPFLAGS="$CPPFLAGS -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS ";; +esac + +# Set CFLAGS/CXXFLAGS. We MUST set the flags before we call autoconf +# compiler configuration macros, because if we don't, they set CFLAGS +# to no optimization and -g, which isn't what we want. +# +# If the user wants a debugging environment, add -g the their compiler flags +# and don't automatically optimize. If you want to compile with a different +# set of flags, specify CFLAGS in the environment before configuring. +if test "$db_cv_debug" = "yes"; then + printf '%s\n' "#define DEBUG 1" >>confdefs.h + + + + CFLAGS="-g $CFLAGS" +else + CFLAGS=${CFLAGS-$optimize_flag} +fi + +CFLAGS="$CFLAGS$extra_cflags" +CXXFLAGS=${CXXFLAGS-"$CFLAGS"} + +# The default compiler is cc (NOT gcc), the default CFLAGS is as specified +# above, NOT what is set by AC_PROG_CC, as it won't set optimization flags +# for any compiler other than gcc. +# +# Berkeley DB is written in K&R (old-style) C: function definitions name +# their parameters in a list following the parenthesis, with the prototype +# supplied separately via the __P() macro. C23 (gnu23) removed old-style +# definitions from the language, so a modern Autoconf (>= 2.72) AC_PROG_CC, +# which probes -std=gnu23 first and adopts it, turns every definition in the +# tree into a hard error. Suppress that probe by pre-seeding the C11/C23 +# feature-test cache variables to "no" so AC_PROG_CC adds no -std flag, then +# pin a K&R-compatible standard (gnu99) ourselves below. +ac_cv_prog_cc_c23=no +ac_cv_prog_cc_c11=no +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + for ac_prog in cc gcc + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cc gcc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +printf %s "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_ac_ct_CC+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi ;; +esac +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } +else + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + + +test -z "$CC" && { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See 'config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion -version; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +printf '%s\n' "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : @@ -6534,8 +7638,8 @@ ac_cv_c_compiler_gnu=$ac_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 -printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_c_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_c_compiler_gnu if test $ac_compiler_gnu = yes; then @@ -6545,7 +7649,7 @@ else fi ac_test_CFLAGS=${CFLAGS+y} ac_save_CFLAGS=$CFLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : @@ -6613,8 +7717,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 -printf "%s\n" "$ac_cv_prog_cc_g" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +printf '%s\n' "$ac_cv_prog_cc_g" >&6; } if test $ac_test_CFLAGS; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then @@ -6633,7 +7737,56 @@ fi ac_prog_cc_stdc=no if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C23 features" >&5 +printf %s "checking for $CC option to enable C23 features... " >&6; } +if test ${ac_cv_prog_cc_c23+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) ac_cv_prog_cc_c23=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c23_program +_ACEOF +for ac_arg in '' -std=gnu23 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c23=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c23" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c23" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in #( + e) if test "x$ac_cv_prog_cc_c23" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in #( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c23" >&5 +printf '%s\n' "$ac_cv_prog_cc_c23" >&6; } + CC="$CC $ac_cv_prog_cc_c23" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c23 + ac_prog_cc_stdc=c23 ;; +esac +fi +fi +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : @@ -6645,7 +7798,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c11_program _ACEOF -for ac_arg in '' -std=gnu11 +for ac_arg in '' -std=gnu11 -std:c11 do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" @@ -6662,16 +7815,16 @@ fi if test "x$ac_cv_prog_cc_c11" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c11" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 -printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 +printf '%s\n' "$ac_cv_prog_cc_c11" >&6; } CC="$CC $ac_cv_prog_cc_c11" ;; esac fi @@ -6682,7 +7835,7 @@ fi fi if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : @@ -6711,16 +7864,16 @@ fi if test "x$ac_cv_prog_cc_c99" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c99" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 -printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +printf '%s\n' "$ac_cv_prog_cc_c99" >&6; } CC="$CC $ac_cv_prog_cc_c99" ;; esac fi @@ -6731,7 +7884,7 @@ fi fi if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : @@ -6760,16 +7913,16 @@ fi if test "x$ac_cv_prog_cc_c89" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c89" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +printf '%s\n' "$ac_cv_prog_cc_c89" >&6; } CC="$CC $ac_cv_prog_cc_c89" ;; esac fi @@ -6786,6 +7939,68 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $ ac_compiler_gnu=$ac_cv_c_compiler_gnu +# A modern Autoconf may still splice -std=gnu23 (or -std=c23) directly into +# $CC despite the cache pre-seeding above. Strip it so the K&R-incompatible +# standard cannot win, then pin gnu99 in CFLAGS below. +CC=`echo "$CC" | sed -e 's/ -std=gnu23//g' -e 's/ -std=c23//g'` + +# Pin a K&R-compatible C standard. gnu99 keeps old-style definitions legal +# (and retains the GNU extensions the tree relies on) under compilers that +# would otherwise default to C23. +case " $CFLAGS " in +*" -std="*) ;; # caller already chose a standard +*) CFLAGS="$CFLAGS -std=gnu99";; +esac + +# The tree is deliberately K&R. Even under gnu99, a sufficiently new clang +# still warns on every old-style definition (-Wdeprecated-non-prototype) and +# on sub-int K&R parameters whose default-argument promotion differs from the +# ANSI prototype (-Wknr-promoted-parameter). Both are inherent to the +# intentional K&R style, so silence exactly those two warnings where the +# compiler supports the flag. Keep all other warnings. +for db_knr_flag in -Wno-deprecated-non-prototype -Wno-knr-promoted-parameter; do + as_db_knr_cv=`printf '%s\n' "db_cv_cflag$db_knr_flag" | sed "$as_sed_sh"` + + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts $db_knr_flag" >&5 +printf %s "checking whether $CC accepts $db_knr_flag... " >&6; } +if eval test \${$as_db_knr_cv+y} +then : + printf %s "(cached) " >&6 +else case e in #( + e) save_cflags="$CFLAGS" + CFLAGS="$CFLAGS $db_knr_flag -Werror" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + eval "$as_db_knr_cv=yes" +else case e in #( + e) eval "$as_db_knr_cv=no" ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + CFLAGS="$save_cflags" ;; +esac +fi +eval ac_res=\$$as_db_knr_cv + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } + if eval test \"x\$"$as_db_knr_cv"\" = x"yes" +then : + CFLAGS="$CFLAGS $db_knr_flag" +fi + +done + # We know what compiler we're going to use, now. Set per-compiler flags. if test "$GCC" = "yes"; then # Use -O3 if we're using gcc, unless we're doing a small build, in @@ -6799,11 +8014,6 @@ if test "$GCC" = "yes"; then else CFLAGS=`echo "$CFLAGS" | sed 's/-O /-O3 /g'` fi - - # Suppress K&R function declaration warnings for legacy codebase - # Berkeley DB has many K&R style function declarations that would - # require extensive refactoring to modernize to ANSI C prototypes - CFLAGS="$CFLAGS -Wno-deprecated-non-prototype" else case "$host_os" in hpux11.0*) ;; @@ -6814,8 +8024,7 @@ else fi # Check for "const" and "inline" keywords. - -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 printf %s "checking for an ANSI C-conforming const... " >&6; } if test ${ac_cv_c_const+y} then : @@ -6856,15 +8065,12 @@ main (void) *t++ = 0; if (s) return 0; } - { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ + { /* Derived from code rejected by Sun C 1.0 and similar vintage. */ int x[] = {25, 17}; - const int *foo = &x[0]; + typedef int const *iptr; + iptr foo = &x[0]; ++foo; - } - { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ - typedef const int *iptr; - iptr p = 0; - ++p; + if (!*foo) return 0; } { /* IBM XL C 1.02.0.0 rejects this sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ @@ -6892,15 +8098,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 -printf "%s\n" "$ac_cv_c_const" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 +printf '%s\n' "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then -printf "%s\n" "#define const /**/" >>confdefs.h +printf '%s\n' "#define const /**/" >>confdefs.h fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 printf %s "checking for inline... " >&6; } if test ${ac_cv_c_inline+y} then : @@ -6927,8 +8133,8 @@ done ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 -printf "%s\n" "$ac_cv_c_inline" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 +printf '%s\n' "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; @@ -6959,7 +8165,7 @@ fi # We use alignment attributes in db.h - figure out if the compiler supports # them. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC aligned attribute" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GCC aligned attribute" >&5 printf %s "checking for GCC aligned attribute... " >&6; } if test ${db_cv_aligned_attribute+y} then : @@ -6987,8 +8193,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_aligned_attribute" >&5 -printf "%s\n" "$db_cv_aligned_attribute" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_aligned_attribute" >&5 +printf '%s\n' "$db_cv_aligned_attribute" >&6; } if test "$db_cv_aligned_attribute" = "yes"; then DB_STRUCT_ALIGN8="__attribute__ ((aligned (8)))" fi @@ -7022,7 +8228,7 @@ if test "$db_cv_cxx" = "yes"; then aix*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}xlC_r", so it can be a program name with args. set dummy ${ac_tool_prefix}xlC_r; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CCC+y} then : @@ -7043,7 +8249,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCC="${ac_tool_prefix}xlC_r" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7055,11 +8261,11 @@ esac fi CCC=$ac_cv_prog_CCC if test -n "$CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 -printf "%s\n" "$CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 +printf '%s\n' "$CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7068,7 +8274,7 @@ if test -z "$ac_cv_prog_CCC"; then ac_ct_CCC=$CCC # Extract the first word of "xlC_r", so it can be a program name with args. set dummy xlC_r; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CCC+y} then : @@ -7089,7 +8295,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CCC="xlC_r" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7101,11 +8307,11 @@ esac fi ac_ct_CCC=$ac_cv_prog_ac_ct_CCC if test -n "$ac_ct_CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 -printf "%s\n" "$ac_ct_CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 +printf '%s\n' "$ac_ct_CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CCC" = x; then @@ -7113,8 +8319,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CCC=$ac_ct_CCC @@ -7128,7 +8334,7 @@ fi hpux*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}aCC", so it can be a program name with args. set dummy ${ac_tool_prefix}aCC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CCC+y} then : @@ -7149,7 +8355,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCC="${ac_tool_prefix}aCC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7161,11 +8367,11 @@ esac fi CCC=$ac_cv_prog_CCC if test -n "$CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 -printf "%s\n" "$CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 +printf '%s\n' "$CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7174,7 +8380,7 @@ if test -z "$ac_cv_prog_CCC"; then ac_ct_CCC=$CCC # Extract the first word of "aCC", so it can be a program name with args. set dummy aCC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CCC+y} then : @@ -7195,7 +8401,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CCC="aCC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7207,11 +8413,11 @@ esac fi ac_ct_CCC=$ac_cv_prog_ac_ct_CCC if test -n "$ac_ct_CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 -printf "%s\n" "$ac_ct_CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 +printf '%s\n' "$ac_ct_CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CCC" = x; then @@ -7219,8 +8425,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CCC=$ac_ct_CCC @@ -7232,7 +8438,7 @@ fi irix*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}CC", so it can be a program name with args. set dummy ${ac_tool_prefix}CC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CCC+y} then : @@ -7253,7 +8459,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCC="${ac_tool_prefix}CC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7265,11 +8471,11 @@ esac fi CCC=$ac_cv_prog_CCC if test -n "$CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 -printf "%s\n" "$CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 +printf '%s\n' "$CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7278,7 +8484,7 @@ if test -z "$ac_cv_prog_CCC"; then ac_ct_CCC=$CCC # Extract the first word of "CC", so it can be a program name with args. set dummy CC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CCC+y} then : @@ -7299,7 +8505,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CCC="CC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7311,11 +8517,11 @@ esac fi ac_ct_CCC=$ac_cv_prog_ac_ct_CCC if test -n "$ac_ct_CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 -printf "%s\n" "$ac_ct_CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 +printf '%s\n' "$ac_ct_CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CCC" = x; then @@ -7323,8 +8529,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CCC=$ac_ct_CCC @@ -7336,7 +8542,7 @@ fi osf*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cxx", so it can be a program name with args. set dummy ${ac_tool_prefix}cxx; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CCC+y} then : @@ -7357,7 +8563,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCC="${ac_tool_prefix}cxx" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7369,11 +8575,11 @@ esac fi CCC=$ac_cv_prog_CCC if test -n "$CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 -printf "%s\n" "$CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 +printf '%s\n' "$CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7382,7 +8588,7 @@ if test -z "$ac_cv_prog_CCC"; then ac_ct_CCC=$CCC # Extract the first word of "cxx", so it can be a program name with args. set dummy cxx; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CCC+y} then : @@ -7403,7 +8609,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CCC="cxx" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7415,11 +8621,11 @@ esac fi ac_ct_CCC=$ac_cv_prog_ac_ct_CCC if test -n "$ac_ct_CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 -printf "%s\n" "$ac_ct_CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 +printf '%s\n' "$ac_ct_CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CCC" = x; then @@ -7427,8 +8633,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CCC=$ac_ct_CCC @@ -7443,7 +8649,7 @@ fi solaris*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}CC", so it can be a program name with args. set dummy ${ac_tool_prefix}CC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CCC+y} then : @@ -7464,7 +8670,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCC="${ac_tool_prefix}CC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7476,11 +8682,11 @@ esac fi CCC=$ac_cv_prog_CCC if test -n "$CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 -printf "%s\n" "$CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CCC" >&5 +printf '%s\n' "$CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7489,7 +8695,7 @@ if test -z "$ac_cv_prog_CCC"; then ac_ct_CCC=$CCC # Extract the first word of "CC", so it can be a program name with args. set dummy CC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CCC+y} then : @@ -7510,7 +8716,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CCC="CC" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7522,11 +8728,11 @@ esac fi ac_ct_CCC=$ac_cv_prog_ac_ct_CCC if test -n "$ac_ct_CCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 -printf "%s\n" "$ac_ct_CCC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CCC" >&5 +printf '%s\n' "$ac_ct_CCC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CCC" = x; then @@ -7534,8 +8740,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CCC=$ac_ct_CCC @@ -7546,13 +8752,7 @@ fi ;; esac fi - - - - - - -ac_ext=cpp + ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' @@ -7566,7 +8766,7 @@ if test -z "$CXX"; then do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CXX+y} then : @@ -7587,7 +8787,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7599,11 +8799,11 @@ esac fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -printf "%s\n" "$CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf '%s\n' "$CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7616,7 +8816,7 @@ if test -z "$CXX"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CXX+y} then : @@ -7637,7 +8837,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7649,11 +8849,11 @@ esac fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -printf "%s\n" "$ac_ct_CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +printf '%s\n' "$ac_ct_CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7665,8 +8865,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CXX=$ac_ct_CXX @@ -7676,7 +8876,7 @@ fi fi fi # Provide some information about the compiler. -printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do @@ -7686,7 +8886,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -7696,11 +8896,11 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 printf %s "checking whether the compiler supports GNU C++... " >&6; } if test ${ac_cv_cxx_compiler_gnu+y} then : @@ -7732,8 +8932,8 @@ ac_cv_cxx_compiler_gnu=$ac_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_cxx_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if test $ac_compiler_gnu = yes; then @@ -7743,7 +8943,7 @@ else fi ac_test_CXXFLAGS=${CXXFLAGS+y} ac_save_CXXFLAGS=$CXXFLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 printf %s "checking whether $CXX accepts -g... " >&6; } if test ${ac_cv_prog_cxx_g+y} then : @@ -7811,8 +9011,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -printf "%s\n" "$ac_cv_prog_cxx_g" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +printf '%s\n' "$ac_cv_prog_cxx_g" >&6; } if test $ac_test_CXXFLAGS; then CXXFLAGS=$ac_save_CXXFLAGS elif test $ac_cv_prog_cxx_g = yes; then @@ -7828,106 +9028,6 @@ else CXXFLAGS= fi fi -ac_prog_cxx_stdcxx=no -if test x$ac_prog_cxx_stdcxx = xno -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5 -printf %s "checking for $CXX option to enable C++11 features... " >&6; } -if test ${ac_cv_prog_cxx_cxx11+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) ac_cv_prog_cxx_cxx11=no -ac_save_CXX=$CXX -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$ac_cxx_conftest_cxx11_program -_ACEOF -for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA -do - CXX="$ac_save_CXX $ac_arg" - if ac_fn_cxx_try_compile "$LINENO" -then : - ac_cv_prog_cxx_cxx11=$ac_arg -fi -rm -f core conftest.err conftest.$ac_objext conftest.beam - test "x$ac_cv_prog_cxx_cxx11" != "xno" && break -done -rm -f conftest.$ac_ext -CXX=$ac_save_CXX ;; -esac -fi - -if test "x$ac_cv_prog_cxx_cxx11" = xno -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } -else case e in #( - e) if test "x$ac_cv_prog_cxx_cxx11" = x -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } -else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5 -printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; } - CXX="$CXX $ac_cv_prog_cxx_cxx11" ;; -esac -fi - ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 - ac_prog_cxx_stdcxx=cxx11 ;; -esac -fi -fi -if test x$ac_prog_cxx_stdcxx = xno -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5 -printf %s "checking for $CXX option to enable C++98 features... " >&6; } -if test ${ac_cv_prog_cxx_cxx98+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) ac_cv_prog_cxx_cxx98=no -ac_save_CXX=$CXX -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$ac_cxx_conftest_cxx98_program -_ACEOF -for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA -do - CXX="$ac_save_CXX $ac_arg" - if ac_fn_cxx_try_compile "$LINENO" -then : - ac_cv_prog_cxx_cxx98=$ac_arg -fi -rm -f core conftest.err conftest.$ac_objext conftest.beam - test "x$ac_cv_prog_cxx_cxx98" != "xno" && break -done -rm -f conftest.$ac_ext -CXX=$ac_save_CXX ;; -esac -fi - -if test "x$ac_cv_prog_cxx_cxx98" = xno -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } -else case e in #( - e) if test "x$ac_cv_prog_cxx_cxx98" = x -then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } -else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5 -printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; } - CXX="$CXX $ac_cv_prog_cxx_cxx98" ;; -esac -fi - ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98 - ac_prog_cxx_stdcxx=cxx98 ;; -esac -fi -fi - ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -7940,7 +9040,7 @@ ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 printf %s "checking how to run the C++ preprocessor... " >&6; } if test -z "$CXXCPP"; then if test ${ac_cv_prog_CXXCPP+y} @@ -8007,8 +9107,8 @@ fi else ac_cv_prog_CXXCPP=$CXXCPP fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 -printf "%s\n" "$CXXCPP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +printf '%s\n' "$CXXCPP" >&6; } ac_preproc_ok=false for ac_cxx_preproc_warn_flag in '' yes do @@ -8056,8 +9156,8 @@ if $ac_preproc_ok then : else case e in #( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -8073,7 +9173,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C++ supports the ISO C++ standard includes" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C++ supports the ISO C++ standard includes" >&5 printf %s "checking whether C++ supports the ISO C++ standard includes... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -8112,8 +9212,8 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_cxx_have_stdheaders" >&5 -printf "%s\n" "$db_cv_cxx_have_stdheaders" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_cxx_have_stdheaders" >&5 +printf '%s\n' "$db_cv_cxx_have_stdheaders" >&6; } if test "$db_cv_cxx_have_stdheaders" = yes; then cxx_have_stdheaders="#define HAVE_CXX_STDHEADERS 1" fi @@ -8123,7 +9223,7 @@ fi # Do some gcc specific configuration. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are using gcc version 2.96" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether we are using gcc version 2.96" >&5 printf %s "checking whether we are using gcc version 2.96... " >&6; } if test ${db_cv_gcc_2_96+y} then : @@ -8140,15 +9240,15 @@ if test "$GCC" = "yes"; then fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_gcc_2_96" >&5 -printf "%s\n" "$db_cv_gcc_2_96" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_gcc_2_96" >&5 +printf '%s\n' "$db_cv_gcc_2_96" >&6; } if test "$db_cv_gcc_2_96" = "yes"; then CFLAGS=`echo "$CFLAGS" | sed 's/-O2/-O/'` CXXFLAGS=`echo "$CXXFLAGS" | sed 's/-O2/-O/'` - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: INSTALLED GCC COMPILER HAS SERIOUS BUGS; PLEASE UPGRADE." >&5 -printf "%s\n" "$as_me: WARNING: INSTALLED GCC COMPILER HAS SERIOUS BUGS; PLEASE UPGRADE." >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: GCC OPTIMIZATION LEVEL SET TO -O." >&5 -printf "%s\n" "$as_me: WARNING: GCC OPTIMIZATION LEVEL SET TO -O." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: INSTALLED GCC COMPILER HAS SERIOUS BUGS; PLEASE UPGRADE." >&5 +printf '%s\n' "$as_me: WARNING: INSTALLED GCC COMPILER HAS SERIOUS BUGS; PLEASE UPGRADE." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: GCC OPTIMIZATION LEVEL SET TO -O." >&5 +printf '%s\n' "$as_me: WARNING: GCC OPTIMIZATION LEVEL SET TO -O." >&2;} fi # We need the -Kthread/-pthread flag when compiling on SCO/Caldera's UnixWare @@ -8173,8 +9273,8 @@ CCC=$CXX case `pwd` in *\ * | *\ *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 -printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 +printf '%s\n' "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; esac @@ -8218,7 +9318,7 @@ ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 printf %s "checking how to print strings... " >&6; } # Test print first, because it will be a builtin if present. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ @@ -8245,12 +9345,12 @@ func_echo_all () } case "$ECHO" in - printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5 -printf "%s\n" "printf" >&6; } ;; - print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 -printf "%s\n" "print -r" >&6; } ;; - *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5 -printf "%s\n" "cat" >&6; } ;; + printf*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: printf" >&5 +printf '%s\n' "printf" >&6; } ;; + print*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 +printf '%s\n' "print -r" >&6; } ;; + *) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: cat" >&5 +printf '%s\n' "cat" >&6; } ;; esac @@ -8266,7 +9366,7 @@ esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 printf %s "checking for a sed that does not truncate output... " >&6; } if test ${ac_cv_path_SED+y} then : @@ -8309,7 +9409,7 @@ case `"$ac_path_SED" --version 2>&1` in #( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" '' >> "conftest.nl" + printf '%s\n' '' >> "conftest.nl" "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -8338,8 +9438,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 -printf "%s\n" "$ac_cv_path_SED" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +printf '%s\n' "$ac_cv_path_SED" >&6; } SED="$ac_cv_path_SED" rm -f conftest.sed @@ -8356,7 +9456,7 @@ Xsed="$SED -e 1s/^X//" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 printf %s "checking for grep that handles long lines and -e... " >&6; } if test ${ac_cv_path_GREP+y} then : @@ -8393,7 +9493,7 @@ case `"$ac_path_GREP" --version 2>&1` in #( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'GREP' >> "conftest.nl" + printf '%s\n' 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -8422,12 +9522,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -printf "%s\n" "$ac_cv_path_GREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +printf '%s\n' "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 printf %s "checking for egrep... " >&6; } if test ${ac_cv_path_EGREP+y} then : @@ -8467,7 +9567,7 @@ case `"$ac_path_EGREP" --version 2>&1` in #( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'EGREP' >> "conftest.nl" + printf '%s\n' 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -8497,14 +9597,14 @@ fi fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -printf "%s\n" "$ac_cv_path_EGREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +printf '%s\n' "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" EGREP_TRADITIONAL=$EGREP ac_cv_path_EGREP_TRADITIONAL=$EGREP -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 printf %s "checking for fgrep... " >&6; } if test ${ac_cv_path_FGREP+y} then : @@ -8544,7 +9644,7 @@ case `"$ac_path_FGREP" --version 2>&1` in #( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'FGREP' >> "conftest.nl" + printf '%s\n' 'FGREP' >> "conftest.nl" "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -8574,8 +9674,8 @@ fi fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 -printf "%s\n" "$ac_cv_path_FGREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +printf '%s\n' "$ac_cv_path_FGREP" >&6; } FGREP="$ac_cv_path_FGREP" @@ -8611,7 +9711,7 @@ fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 printf %s "checking for ld used by $CC... " >&6; } case $host in *-*-mingw*) @@ -8641,10 +9741,10 @@ printf %s "checking for ld used by $CC... " >&6; } ;; esac elif test "$with_gnu_ld" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 printf %s "checking for GNU ld... " >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 printf %s "checking for non-GNU ld... " >&6; } fi if test ${lt_cv_path_LD+y} @@ -8680,14 +9780,14 @@ fi LD="$lt_cv_path_LD" if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -printf "%s\n" "$LD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +printf '%s\n' "$LD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${lt_cv_prog_gnu_ld+y} then : @@ -8704,8 +9804,8 @@ case `$LD -v 2>&1 &5 -printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5 +printf '%s\n' "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld @@ -8716,7 +9816,7 @@ with_gnu_ld=$lt_cv_prog_gnu_ld -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; } if test ${lt_cv_path_NM+y} then : @@ -8767,8 +9867,8 @@ else fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 -printf "%s\n" "$lt_cv_path_NM" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +printf '%s\n' "$lt_cv_path_NM" >&6; } if test "$lt_cv_path_NM" != "no"; then NM="$lt_cv_path_NM" else @@ -8781,7 +9881,7 @@ else do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DUMPBIN+y} then : @@ -8802,7 +9902,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8814,11 +9914,11 @@ esac fi DUMPBIN=$ac_cv_prog_DUMPBIN if test -n "$DUMPBIN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 -printf "%s\n" "$DUMPBIN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +printf '%s\n' "$DUMPBIN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -8831,7 +9931,7 @@ if test -z "$DUMPBIN"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DUMPBIN+y} then : @@ -8852,7 +9952,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8864,11 +9964,11 @@ esac fi ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN if test -n "$ac_ct_DUMPBIN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 -printf "%s\n" "$ac_ct_DUMPBIN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 +printf '%s\n' "$ac_ct_DUMPBIN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -8880,8 +9980,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DUMPBIN=$ac_ct_DUMPBIN @@ -8909,7 +10009,7 @@ test -z "$NM" && NM=nm -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 printf %s "checking the name lister ($NM) interface... " >&6; } if test ${lt_cv_nm_interface+y} then : @@ -8931,22 +10031,22 @@ else case e in #( rm -f conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 -printf "%s\n" "$lt_cv_nm_interface" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 +printf '%s\n' "$lt_cv_nm_interface" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 printf %s "checking whether ln -s works... " >&6; } LN_S=$as_ln_s if test "$LN_S" = "ln -s"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 -printf "%s\n" "no, using $LN_S" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +printf '%s\n' "no, using $LN_S" >&6; } fi # find the maximum length of command line arguments -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 printf %s "checking the maximum length of command line arguments... " >&6; } if test ${lt_cv_sys_max_cmd_len+y} then : @@ -9073,11 +10173,11 @@ esac fi if test -n $lt_cv_sys_max_cmd_len ; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 -printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +printf '%s\n' "$lt_cv_sys_max_cmd_len" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5 -printf "%s\n" "none" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none" >&5 +printf '%s\n' "none" >&6; } fi max_cmd_len=$lt_cv_sys_max_cmd_len @@ -9090,7 +10190,7 @@ max_cmd_len=$lt_cv_sys_max_cmd_len : ${MV="mv -f"} : ${RM="rm -f"} -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 printf %s "checking whether the shell understands some XSI constructs... " >&6; } # Try some XSI features xsi_shell=no @@ -9100,18 +10200,18 @@ xsi_shell=no && eval 'test $(( 1 + 1 )) -eq 2 \ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ && xsi_shell=yes -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 -printf "%s\n" "$xsi_shell" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 +printf '%s\n' "$xsi_shell" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 printf %s "checking whether the shell understands \"+=\"... " >&6; } lt_shell_append=no ( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ >/dev/null 2>&1 \ && lt_shell_append=yes -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 -printf "%s\n" "$lt_shell_append" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 +printf '%s\n' "$lt_shell_append" >&6; } if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then @@ -9145,7 +10245,7 @@ esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 printf %s "checking how to convert $build file names to $host format... " >&6; } if test ${lt_cv_to_host_file_cmd+y} then : @@ -9187,14 +10287,14 @@ esac fi to_host_file_cmd=$lt_cv_to_host_file_cmd -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 -printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 +printf '%s\n' "$lt_cv_to_host_file_cmd" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 printf %s "checking how to convert $build file names to toolchain format... " >&6; } if test ${lt_cv_to_tool_file_cmd+y} then : @@ -9216,14 +10316,14 @@ esac fi to_tool_file_cmd=$lt_cv_to_tool_file_cmd -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 -printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 +printf '%s\n' "$lt_cv_to_tool_file_cmd" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 printf %s "checking for $LD option to reload object files... " >&6; } if test ${lt_cv_ld_reload_flag+y} then : @@ -9232,8 +10332,8 @@ else case e in #( e) lt_cv_ld_reload_flag='-r' ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 -printf "%s\n" "$lt_cv_ld_reload_flag" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +printf '%s\n' "$lt_cv_ld_reload_flag" >&6; } reload_flag=$lt_cv_ld_reload_flag case $reload_flag in "" | " "*) ;; @@ -9266,7 +10366,7 @@ esac if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OBJDUMP+y} then : @@ -9287,7 +10387,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9299,11 +10399,11 @@ esac fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 -printf "%s\n" "$OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +printf '%s\n' "$OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -9312,7 +10412,7 @@ if test -z "$ac_cv_prog_OBJDUMP"; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of "objdump", so it can be a program name with args. set dummy objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OBJDUMP+y} then : @@ -9333,7 +10433,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJDUMP="objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9345,11 +10445,11 @@ esac fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 -printf "%s\n" "$ac_ct_OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +printf '%s\n' "$ac_ct_OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OBJDUMP" = x; then @@ -9357,8 +10457,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP @@ -9377,7 +10477,7 @@ test -z "$OBJDUMP" && OBJDUMP=objdump -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 printf %s "checking how to recognize dependent libraries... " >&6; } if test ${lt_cv_deplibs_check_method+y} then : @@ -9581,8 +10681,8 @@ esac ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 -printf "%s\n" "$lt_cv_deplibs_check_method" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +printf '%s\n' "$lt_cv_deplibs_check_method" >&6; } file_magic_glob= want_nocaseglob=no @@ -9626,7 +10726,7 @@ test -z "$deplibs_check_method" && deplibs_check_method=unknown if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DLLTOOL+y} then : @@ -9647,7 +10747,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9659,11 +10759,11 @@ esac fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 -printf "%s\n" "$DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +printf '%s\n' "$DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -9672,7 +10772,7 @@ if test -z "$ac_cv_prog_DLLTOOL"; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of "dlltool", so it can be a program name with args. set dummy dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DLLTOOL+y} then : @@ -9693,7 +10793,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DLLTOOL="dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9705,11 +10805,11 @@ esac fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 -printf "%s\n" "$ac_ct_DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +printf '%s\n' "$ac_ct_DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DLLTOOL" = x; then @@ -9717,8 +10817,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL @@ -9738,7 +10838,7 @@ test -z "$DLLTOOL" && DLLTOOL=dlltool -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 printf %s "checking how to associate runtime and link libraries... " >&6; } if test ${lt_cv_sharedlib_from_linklib_cmd+y} then : @@ -9767,8 +10867,8 @@ esac ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 -printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 +printf '%s\n' "$lt_cv_sharedlib_from_linklib_cmd" >&6; } sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO @@ -9783,7 +10883,7 @@ if test -n "$ac_tool_prefix"; then do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AR+y} then : @@ -9804,7 +10904,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AR="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9816,11 +10916,11 @@ esac fi AR=$ac_cv_prog_AR if test -n "$AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 -printf "%s\n" "$AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +printf '%s\n' "$AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -9833,7 +10933,7 @@ if test -z "$AR"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_AR+y} then : @@ -9854,7 +10954,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AR="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -9866,11 +10966,11 @@ esac fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 -printf "%s\n" "$ac_ct_AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +printf '%s\n' "$ac_ct_AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -9882,8 +10982,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR @@ -9903,7 +11003,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 printf %s "checking for archiver @FILE support... " >&6; } if test ${lt_cv_ar_at_file+y} then : @@ -9928,7 +11028,7 @@ then : { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -eq 0; then # Ensure the archiver fails upon bogus file names. @@ -9936,7 +11036,7 @@ then : { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -ne 0; then lt_cv_ar_at_file=@ @@ -9949,8 +11049,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 -printf "%s\n" "$lt_cv_ar_at_file" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 +printf '%s\n' "$lt_cv_ar_at_file" >&6; } if test "x$lt_cv_ar_at_file" = xno; then archiver_list_spec= @@ -9967,7 +11067,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : @@ -9988,7 +11088,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10000,11 +11100,11 @@ esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 -printf "%s\n" "$STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +printf '%s\n' "$STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10013,7 +11113,7 @@ if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : @@ -10034,7 +11134,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10046,11 +11146,11 @@ esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 -printf "%s\n" "$ac_ct_STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +printf '%s\n' "$ac_ct_STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then @@ -10058,8 +11158,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP @@ -10078,7 +11178,7 @@ test -z "$STRIP" && STRIP=: if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_RANLIB+y} then : @@ -10099,7 +11199,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10111,11 +11211,11 @@ esac fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 -printf "%s\n" "$RANLIB" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +printf '%s\n' "$RANLIB" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10124,7 +11224,7 @@ if test -z "$ac_cv_prog_RANLIB"; then ac_ct_RANLIB=$RANLIB # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_RANLIB+y} then : @@ -10145,7 +11245,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_RANLIB="ranlib" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10157,11 +11257,11 @@ esac fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 -printf "%s\n" "$ac_ct_RANLIB" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +printf '%s\n' "$ac_ct_RANLIB" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_RANLIB" = x; then @@ -10169,8 +11269,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB @@ -10230,11 +11330,11 @@ esac -for ac_prog in gawk mawk nawk awk +for ac_prog in gawk mawk nawk awk 'busybox awk' do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AWK+y} then : @@ -10255,7 +11355,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10267,11 +11367,11 @@ esac fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 -printf "%s\n" "$AWK" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +printf '%s\n' "$AWK" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10307,7 +11407,7 @@ compiler=$CC # Check for command to grab the raw symbol name followed by C symbol from nm. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 printf %s "checking command to parse $NM output from $compiler object... " >&6; } if test ${lt_cv_sys_global_symbol_pipe+y} then : @@ -10430,14 +11530,14 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Now try to grab the symbols. nlist=conftest.nm if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5 (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s "$nlist"; then # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then @@ -10506,7 +11606,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext}; then pipe_works=yes fi @@ -10542,11 +11642,11 @@ if test -z "$lt_cv_sys_global_symbol_pipe"; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: failed" >&5 -printf "%s\n" "failed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +printf '%s\n' "failed" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5 -printf "%s\n" "ok" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +printf '%s\n' "ok" >&6; } fi # Response file support. @@ -10582,7 +11682,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 printf %s "checking for sysroot... " >&6; } # Check whether --with-sysroot was given. @@ -10608,14 +11708,14 @@ case ${with_sysroot} in #( no|'') ;; #( *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 -printf "%s\n" "${with_sysroot}" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 +printf '%s\n' "${with_sysroot}" >&6; } as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 -printf "%s\n" "${lt_sysroot:-no}" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 +printf '%s\n' "${lt_sysroot:-no}" >&6; } @@ -10638,7 +11738,7 @@ ia64-*-hpux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) @@ -10657,7 +11757,7 @@ ia64-*-hpux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then if test "$lt_cv_prog_gnu_ld" = yes; then case `/usr/bin/file conftest.$ac_objext` in @@ -10695,7 +11795,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.o` in *32-bit*) @@ -10745,7 +11845,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -belf" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 printf %s "checking whether the C compiler needs -belf... " >&6; } if test ${lt_cv_cc_needs_belf+y} then : @@ -10785,8 +11885,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 -printf "%s\n" "$lt_cv_cc_needs_belf" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +printf '%s\n' "$lt_cv_cc_needs_belf" >&6; } if test x"$lt_cv_cc_needs_belf" != x"yes"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS="$SAVE_CFLAGS" @@ -10798,7 +11898,7 @@ sparc*-*solaris*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.o` in *64-bit*) @@ -10822,7 +11922,7 @@ need_locks="$enable_libtool_lock" if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. set dummy ${ac_tool_prefix}mt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_MANIFEST_TOOL+y} then : @@ -10843,7 +11943,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10855,11 +11955,11 @@ esac fi MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL if test -n "$MANIFEST_TOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 -printf "%s\n" "$MANIFEST_TOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 +printf '%s\n' "$MANIFEST_TOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10868,7 +11968,7 @@ if test -z "$ac_cv_prog_MANIFEST_TOOL"; then ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL # Extract the first word of "mt", so it can be a program name with args. set dummy mt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y} then : @@ -10889,7 +11989,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10901,11 +12001,11 @@ esac fi ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL if test -n "$ac_ct_MANIFEST_TOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 -printf "%s\n" "$ac_ct_MANIFEST_TOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 +printf '%s\n' "$ac_ct_MANIFEST_TOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_MANIFEST_TOOL" = x; then @@ -10913,8 +12013,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL @@ -10924,7 +12024,7 @@ else fi test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } if test ${lt_cv_path_mainfest_tool+y} then : @@ -10940,8 +12040,8 @@ else case e in #( rm -f conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 -printf "%s\n" "$lt_cv_path_mainfest_tool" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 +printf '%s\n' "$lt_cv_path_mainfest_tool" >&6; } if test "x$lt_cv_path_mainfest_tool" != xyes; then MANIFEST_TOOL=: fi @@ -10956,7 +12056,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DSYMUTIL+y} then : @@ -10977,7 +12077,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10989,11 +12089,11 @@ esac fi DSYMUTIL=$ac_cv_prog_DSYMUTIL if test -n "$DSYMUTIL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 -printf "%s\n" "$DSYMUTIL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 +printf '%s\n' "$DSYMUTIL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11002,7 +12102,7 @@ if test -z "$ac_cv_prog_DSYMUTIL"; then ac_ct_DSYMUTIL=$DSYMUTIL # Extract the first word of "dsymutil", so it can be a program name with args. set dummy dsymutil; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DSYMUTIL+y} then : @@ -11023,7 +12123,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11035,11 +12135,11 @@ esac fi ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL if test -n "$ac_ct_DSYMUTIL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 -printf "%s\n" "$ac_ct_DSYMUTIL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 +printf '%s\n' "$ac_ct_DSYMUTIL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DSYMUTIL" = x; then @@ -11047,8 +12147,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DSYMUTIL=$ac_ct_DSYMUTIL @@ -11060,7 +12160,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. set dummy ${ac_tool_prefix}nmedit; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_NMEDIT+y} then : @@ -11081,7 +12181,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11093,11 +12193,11 @@ esac fi NMEDIT=$ac_cv_prog_NMEDIT if test -n "$NMEDIT"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 -printf "%s\n" "$NMEDIT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 +printf '%s\n' "$NMEDIT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11106,7 +12206,7 @@ if test -z "$ac_cv_prog_NMEDIT"; then ac_ct_NMEDIT=$NMEDIT # Extract the first word of "nmedit", so it can be a program name with args. set dummy nmedit; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_NMEDIT+y} then : @@ -11127,7 +12227,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_NMEDIT="nmedit" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11139,11 +12239,11 @@ esac fi ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT if test -n "$ac_ct_NMEDIT"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 -printf "%s\n" "$ac_ct_NMEDIT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 +printf '%s\n' "$ac_ct_NMEDIT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_NMEDIT" = x; then @@ -11151,8 +12251,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac NMEDIT=$ac_ct_NMEDIT @@ -11164,7 +12264,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. set dummy ${ac_tool_prefix}lipo; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_LIPO+y} then : @@ -11185,7 +12285,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_LIPO="${ac_tool_prefix}lipo" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11197,11 +12297,11 @@ esac fi LIPO=$ac_cv_prog_LIPO if test -n "$LIPO"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 -printf "%s\n" "$LIPO" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 +printf '%s\n' "$LIPO" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11210,7 +12310,7 @@ if test -z "$ac_cv_prog_LIPO"; then ac_ct_LIPO=$LIPO # Extract the first word of "lipo", so it can be a program name with args. set dummy lipo; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_LIPO+y} then : @@ -11231,7 +12331,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_LIPO="lipo" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11243,11 +12343,11 @@ esac fi ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO if test -n "$ac_ct_LIPO"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 -printf "%s\n" "$ac_ct_LIPO" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 +printf '%s\n' "$ac_ct_LIPO" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_LIPO" = x; then @@ -11255,8 +12355,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac LIPO=$ac_ct_LIPO @@ -11268,7 +12368,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. set dummy ${ac_tool_prefix}otool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL+y} then : @@ -11289,7 +12389,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL="${ac_tool_prefix}otool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11301,11 +12401,11 @@ esac fi OTOOL=$ac_cv_prog_OTOOL if test -n "$OTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 -printf "%s\n" "$OTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +printf '%s\n' "$OTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11314,7 +12414,7 @@ if test -z "$ac_cv_prog_OTOOL"; then ac_ct_OTOOL=$OTOOL # Extract the first word of "otool", so it can be a program name with args. set dummy otool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL+y} then : @@ -11335,7 +12435,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL="otool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11347,11 +12447,11 @@ esac fi ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL if test -n "$ac_ct_OTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 -printf "%s\n" "$ac_ct_OTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 +printf '%s\n' "$ac_ct_OTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OTOOL" = x; then @@ -11359,8 +12459,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL=$ac_ct_OTOOL @@ -11372,7 +12472,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. set dummy ${ac_tool_prefix}otool64; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL64+y} then : @@ -11393,7 +12493,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11405,11 +12505,11 @@ esac fi OTOOL64=$ac_cv_prog_OTOOL64 if test -n "$OTOOL64"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 -printf "%s\n" "$OTOOL64" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 +printf '%s\n' "$OTOOL64" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11418,7 +12518,7 @@ if test -z "$ac_cv_prog_OTOOL64"; then ac_ct_OTOOL64=$OTOOL64 # Extract the first word of "otool64", so it can be a program name with args. set dummy otool64; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL64+y} then : @@ -11439,7 +12539,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL64="otool64" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11451,11 +12551,11 @@ esac fi ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 if test -n "$ac_ct_OTOOL64"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 -printf "%s\n" "$ac_ct_OTOOL64" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 +printf '%s\n' "$ac_ct_OTOOL64" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OTOOL64" = x; then @@ -11463,8 +12563,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL64=$ac_ct_OTOOL64 @@ -11499,7 +12599,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 printf %s "checking for -single_module linker flag... " >&6; } if test ${lt_cv_apple_cc_single_mod+y} then : @@ -11528,9 +12628,9 @@ else case e in #( fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 -printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 +printf '%s\n' "$lt_cv_apple_cc_single_mod" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 printf %s "checking for -exported_symbols_list linker flag... " >&6; } if test ${lt_cv_ld_exported_symbols_list+y} then : @@ -11564,9 +12664,9 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 -printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 +printf '%s\n' "$lt_cv_ld_exported_symbols_list" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 printf %s "checking for -force_load linker flag... " >&6; } if test ${lt_cv_ld_force_load+y} then : @@ -11598,8 +12698,8 @@ _LT_EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 -printf "%s\n" "$lt_cv_ld_force_load" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 +printf '%s\n' "$lt_cv_ld_force_load" >&6; } case $host_os in rhapsody* | darwin1.[012]) _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; @@ -11635,40 +12735,11 @@ printf "%s\n" "$lt_cv_ld_force_load" >&6; } ;; esac -ac_header= ac_cache= -for ac_item in $ac_header_c_list -do - if test $ac_cache; then - ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" - if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then - printf "%s\n" "#define $ac_item 1" >> confdefs.h - fi - ac_header= ac_cache= - elif test $ac_header; then - ac_cache=$ac_item - else - ac_header=$ac_item - fi -done - - - - - - - - -if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes -then : - -printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h - -fi ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default " if test "x$ac_cv_header_dlfcn_h" = xyes then : - printf "%s\n" "#define HAVE_DLFCN_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_DLFCN_H 1" >>confdefs.h fi @@ -11866,7 +12937,7 @@ if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 printf %s "checking for objdir... " >&6; } if test ${lt_cv_objdir+y} then : @@ -11883,15 +12954,15 @@ fi rmdir .libs 2>/dev/null ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 -printf "%s\n" "$lt_cv_objdir" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +printf '%s\n' "$lt_cv_objdir" >&6; } objdir=$lt_cv_objdir -printf "%s\n" "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h +printf '%s\n' "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h @@ -11944,7 +13015,7 @@ test -z "$MAGIC_CMD" && MAGIC_CMD=file case $deplibs_check_method in file_magic*) if test "$file_magic_cmd" = '$MAGIC_CMD'; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 printf %s "checking for ${ac_tool_prefix}file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : @@ -11999,11 +13070,11 @@ fi MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 -printf "%s\n" "$MAGIC_CMD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +printf '%s\n' "$MAGIC_CMD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -12012,7 +13083,7 @@ fi if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for file" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for file" >&5 printf %s "checking for file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : @@ -12067,11 +13138,11 @@ fi MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 -printf "%s\n" "$MAGIC_CMD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +printf '%s\n' "$MAGIC_CMD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -12156,7 +13227,7 @@ if test "$GCC" = yes; then lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } if test ${lt_cv_prog_compiler_rtti_exceptions+y} then : @@ -12193,8 +13264,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 -printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +printf '%s\n' "$lt_cv_prog_compiler_rtti_exceptions" >&6; } if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" @@ -12503,7 +13574,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic+y} then : @@ -12512,15 +13583,15 @@ else case e in #( e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic" >&6; } lt_prog_compiler_pic=$lt_cv_prog_compiler_pic # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } if test ${lt_cv_prog_compiler_pic_works+y} then : @@ -12557,8 +13628,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works" >&6; } if test x"$lt_cv_prog_compiler_pic_works" = xyes; then case $lt_prog_compiler_pic in @@ -12586,7 +13657,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works+y} then : @@ -12616,8 +13687,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works" >&6; } if test x"$lt_cv_prog_compiler_static_works" = xyes; then : @@ -12631,7 +13702,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : @@ -12680,15 +13751,15 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : @@ -12737,8 +13808,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; } @@ -12746,7 +13817,7 @@ printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } hard_links="nottested" if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 printf %s "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* @@ -12754,11 +13825,11 @@ printf %s "checking if we can lock with hard links... " >&6; } touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 -printf "%s\n" "$hard_links" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +printf '%s\n' "$hard_links" >&6; } if test "$hard_links" = no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 -printf "%s\n" "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +printf '%s\n' "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} need_locks=warn fi else @@ -12770,7 +13841,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } runpath_var= @@ -13586,7 +14657,7 @@ fi # Older versions of the 11.00 compiler do not understand -b yet # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 printf %s "checking if $CC understands -b... " >&6; } if test ${lt_cv_prog_compiler__b+y} then : @@ -13616,8 +14687,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 -printf "%s\n" "$lt_cv_prog_compiler__b" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 +printf '%s\n' "$lt_cv_prog_compiler__b" >&6; } if test x"$lt_cv_prog_compiler__b" = xyes; then archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' @@ -13657,7 +14728,7 @@ fi # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&6; } if test ${lt_cv_irix_exported_symbol+y} then : @@ -13681,8 +14752,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LDFLAGS="$save_LDFLAGS" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 -printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 +printf '%s\n' "$lt_cv_irix_exported_symbol" >&6; } if test "$lt_cv_irix_exported_symbol" = yes; then archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' fi @@ -13940,8 +15011,8 @@ printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; } fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 -printf "%s\n" "$ld_shlibs" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +printf '%s\n' "$ld_shlibs" >&6; } test "$ld_shlibs" = no && can_build_shared=no with_gnu_ld=$with_gnu_ld @@ -13977,7 +15048,7 @@ x|xyes) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 printf %s "checking whether -lc should be explicitly linked in... " >&6; } if test ${lt_cv_archive_cmds_need_lc+y} then : @@ -13989,7 +15060,7 @@ else case e in #( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest @@ -14007,7 +15078,7 @@ else case e in #( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc=no @@ -14022,8 +15093,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 -printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 +printf '%s\n' "$lt_cv_archive_cmds_need_lc" >&6; } archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc ;; esac @@ -14187,7 +15258,7 @@ esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 printf %s "checking dynamic linker characteristics... " >&6; } if test "$GCC" = yes; then @@ -14927,8 +15998,8 @@ uts4*) dynamic_linker=no ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 -printf "%s\n" "$dynamic_linker" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +printf '%s\n' "$dynamic_linker" >&6; } test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" @@ -15034,7 +16105,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 printf %s "checking how to hardcode library paths into programs... " >&6; } hardcode_action= if test -n "$hardcode_libdir_flag_spec" || @@ -15059,8 +16130,8 @@ else # directories. hardcode_action=unsupported fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 -printf "%s\n" "$hardcode_action" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +printf '%s\n' "$hardcode_action" >&6; } if test "$hardcode_action" = relink || test "$inherit_rpath" = yes; then @@ -15104,7 +16175,7 @@ else darwin*) # if libdl is installed we need to link against it - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : @@ -15145,8 +16216,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" @@ -15167,7 +16238,7 @@ if test "x$ac_cv_func_shl_load" = xyes then : lt_cv_dlopen="shl_load" else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 printf %s "checking for shl_load in -ldld... " >&6; } if test ${ac_cv_lib_dld_shl_load+y} then : @@ -15208,8 +16279,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 -printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +printf '%s\n' "$ac_cv_lib_dld_shl_load" >&6; } if test "x$ac_cv_lib_dld_shl_load" = xyes then : lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" @@ -15219,7 +16290,7 @@ if test "x$ac_cv_func_dlopen" = xyes then : lt_cv_dlopen="dlopen" else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : @@ -15260,13 +16331,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 printf %s "checking for dlopen in -lsvld... " >&6; } if test ${ac_cv_lib_svld_dlopen+y} then : @@ -15307,13 +16378,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_svld_dlopen" >&6; } if test "x$ac_cv_lib_svld_dlopen" = xyes then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 printf %s "checking for dld_link in -ldld... " >&6; } if test ${ac_cv_lib_dld_dld_link+y} then : @@ -15354,8 +16425,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 -printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +printf '%s\n' "$ac_cv_lib_dld_dld_link" >&6; } if test "x$ac_cv_lib_dld_dld_link" = xyes then : lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" @@ -15401,7 +16472,7 @@ fi save_LIBS="$LIBS" LIBS="$lt_cv_dlopen_libs $LIBS" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 printf %s "checking whether a program can dlopen itself... " >&6; } if test ${lt_cv_dlopen_self+y} then : @@ -15485,7 +16556,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? @@ -15504,12 +16575,12 @@ rm -fr conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 -printf "%s\n" "$lt_cv_dlopen_self" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +printf '%s\n' "$lt_cv_dlopen_self" >&6; } if test "x$lt_cv_dlopen_self" = xyes; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 printf %s "checking whether a statically linked program can dlopen itself... " >&6; } if test ${lt_cv_dlopen_self_static+y} then : @@ -15593,7 +16664,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? @@ -15612,8 +16683,8 @@ rm -fr conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 -printf "%s\n" "$lt_cv_dlopen_self_static" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +printf '%s\n' "$lt_cv_dlopen_self_static" >&6; } fi CPPFLAGS="$save_CPPFLAGS" @@ -15651,13 +16722,13 @@ fi striplib= old_striplib= -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 printf %s "checking whether stripping libraries is possible... " >&6; } if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" test -z "$striplib" && striplib="$STRIP --strip-unneeded" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in @@ -15665,16 +16736,16 @@ else if test -n "$STRIP" ; then striplib="$STRIP -x" old_striplib="$STRIP -S" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi ;; *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } ;; esac fi @@ -15691,12 +16762,12 @@ fi # Report which library types will actually be built - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 printf %s "checking if libtool supports shared libraries... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 -printf "%s\n" "$can_build_shared" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +printf '%s\n' "$can_build_shared" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 printf %s "checking whether to build shared libraries... " >&6; } test "$can_build_shared" = "no" && enable_shared=no @@ -15717,15 +16788,15 @@ printf %s "checking whether to build shared libraries... " >&6; } fi ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 -printf "%s\n" "$enable_shared" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +printf '%s\n' "$enable_shared" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 printf %s "checking whether to build static libraries... " >&6; } # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 -printf "%s\n" "$enable_static" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +printf '%s\n' "$enable_static" >&6; } @@ -15747,7 +16818,7 @@ ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 printf %s "checking how to run the C++ preprocessor... " >&6; } if test -z "$CXXCPP"; then if test ${ac_cv_prog_CXXCPP+y} @@ -15814,8 +16885,8 @@ fi else ac_cv_prog_CXXCPP=$CXXCPP fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 -printf "%s\n" "$CXXCPP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +printf '%s\n' "$CXXCPP" >&6; } ac_preproc_ok=false for ac_cxx_preproc_warn_flag in '' yes do @@ -15863,8 +16934,8 @@ if $ac_preproc_ok then : else case e in #( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -16020,7 +17091,7 @@ fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 printf %s "checking for ld used by $CC... " >&6; } case $host in *-*-mingw*) @@ -16050,10 +17121,10 @@ printf %s "checking for ld used by $CC... " >&6; } ;; esac elif test "$with_gnu_ld" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 printf %s "checking for GNU ld... " >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 printf %s "checking for non-GNU ld... " >&6; } fi if test ${lt_cv_path_LD+y} @@ -16089,14 +17160,14 @@ fi LD="$lt_cv_path_LD" if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -printf "%s\n" "$LD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +printf '%s\n' "$LD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${lt_cv_prog_gnu_ld+y} then : @@ -16113,8 +17184,8 @@ case `$LD -v 2>&1 &5 -printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5 +printf '%s\n' "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld @@ -16168,7 +17239,7 @@ with_gnu_ld=$lt_cv_prog_gnu_ld fi # PORTME: fill in a description of your system's C++ link characteristics - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } ld_shlibs_CXX=yes case $host_os in @@ -17178,8 +18249,8 @@ fi ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 -printf "%s\n" "$ld_shlibs_CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +printf '%s\n' "$ld_shlibs_CXX" >&6; } test "$ld_shlibs_CXX" = no && can_build_shared=no GCC_CXX="$GXX" @@ -17216,7 +18287,7 @@ esac if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Parse the compiler output and extract the necessary # objects, libraries and library flags. @@ -17736,7 +18807,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic_CXX+y} then : @@ -17745,15 +18816,15 @@ else case e in #( e) lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_CXX" >&6; } lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } if test ${lt_cv_prog_compiler_pic_works_CXX+y} then : @@ -17790,8 +18861,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works_CXX" >&6; } if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then case $lt_prog_compiler_pic_CXX in @@ -17813,7 +18884,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works_CXX+y} then : @@ -17843,8 +18914,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works_CXX" >&6; } if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then : @@ -17855,7 +18926,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o_CXX+y} then : @@ -17904,12 +18975,12 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o_CXX" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o_CXX+y} then : @@ -17958,8 +19029,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o_CXX" >&6; } @@ -17967,7 +19038,7 @@ printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } hard_links="nottested" if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 printf %s "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* @@ -17975,11 +19046,11 @@ printf %s "checking if we can lock with hard links... " >&6; } touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 -printf "%s\n" "$hard_links" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +printf '%s\n' "$hard_links" >&6; } if test "$hard_links" = no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 -printf "%s\n" "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +printf '%s\n' "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} need_locks=warn fi else @@ -17988,7 +19059,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' @@ -18022,8 +19093,8 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 -printf "%s\n" "$ld_shlibs_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +printf '%s\n' "$ld_shlibs_CXX" >&6; } test "$ld_shlibs_CXX" = no && can_build_shared=no with_gnu_ld_CXX=$with_gnu_ld @@ -18050,7 +19121,7 @@ x|xyes) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 printf %s "checking whether -lc should be explicitly linked in... " >&6; } if test ${lt_cv_archive_cmds_need_lc_CXX+y} then : @@ -18062,7 +19133,7 @@ else case e in #( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest @@ -18080,7 +19151,7 @@ else case e in #( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc_CXX=no @@ -18095,8 +19166,8 @@ else case e in #( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 -printf "%s\n" "$lt_cv_archive_cmds_need_lc_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 +printf '%s\n' "$lt_cv_archive_cmds_need_lc_CXX" >&6; } archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX ;; esac @@ -18167,7 +19238,7 @@ esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 printf %s "checking dynamic linker characteristics... " >&6; } library_names_spec= @@ -18841,8 +19912,8 @@ uts4*) dynamic_linker=no ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 -printf "%s\n" "$dynamic_linker" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +printf '%s\n' "$dynamic_linker" >&6; } test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" @@ -18894,7 +19965,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 printf %s "checking how to hardcode library paths into programs... " >&6; } hardcode_action_CXX= if test -n "$hardcode_libdir_flag_spec_CXX" || @@ -18919,8 +19990,8 @@ else # directories. hardcode_action_CXX=unsupported fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 -printf "%s\n" "$hardcode_action_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +printf '%s\n' "$hardcode_action_CXX" >&6; } if test "$hardcode_action_CXX" = relink || test "$inherit_rpath_CXX" = yes; then @@ -18983,7 +20054,7 @@ SOFLAGS="-rpath \$(libdir)" # Set SOSUFFIX and friends - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking SOSUFFIX from libtool" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking SOSUFFIX from libtool" >&5 printf %s "checking SOSUFFIX from libtool... " >&6; } module=no @@ -18996,21 +20067,21 @@ printf %s "checking SOSUFFIX from libtool... " >&6; } if test "$enable_shared" != "yes"; then if test "$_SOSUFFIX_MESSAGE" = ""; then _SOSUFFIX_MESSAGE=yes - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 -printf "%s\n" "$as_me: WARNING: libtool may not know about this architecture." >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 -printf "%s\n" "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 +printf '%s\n' "$as_me: WARNING: libtool may not know about this architecture." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 +printf '%s\n' "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} fi fi fi SOSUFFIX=$_SOSUFFIX - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SOSUFFIX" >&5 -printf "%s\n" "$SOSUFFIX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $SOSUFFIX" >&5 +printf '%s\n' "$SOSUFFIX" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking MODSUFFIX from libtool" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking MODSUFFIX from libtool" >&5 printf %s "checking MODSUFFIX from libtool... " >&6; } module=yes @@ -19023,21 +20094,21 @@ printf %s "checking MODSUFFIX from libtool... " >&6; } if test "$enable_shared" != "yes"; then if test "$_SOSUFFIX_MESSAGE" = ""; then _SOSUFFIX_MESSAGE=yes - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 -printf "%s\n" "$as_me: WARNING: libtool may not know about this architecture." >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 -printf "%s\n" "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 +printf '%s\n' "$as_me: WARNING: libtool may not know about this architecture." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 +printf '%s\n' "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} fi fi fi MODSUFFIX=$_SOSUFFIX - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MODSUFFIX" >&5 -printf "%s\n" "$MODSUFFIX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MODSUFFIX" >&5 +printf '%s\n' "$MODSUFFIX" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking JMODSUFFIX from libtool" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking JMODSUFFIX from libtool" >&5 printf %s "checking JMODSUFFIX from libtool... " >&6; } module=yes @@ -19050,10 +20121,10 @@ printf %s "checking JMODSUFFIX from libtool... " >&6; } if test "$enable_shared" != "yes"; then if test "$_SOSUFFIX_MESSAGE" = ""; then _SOSUFFIX_MESSAGE=yes - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 -printf "%s\n" "$as_me: WARNING: libtool may not know about this architecture." >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 -printf "%s\n" "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: libtool may not know about this architecture." >&5 +printf '%s\n' "$as_me: WARNING: libtool may not know about this architecture." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&5 +printf '%s\n' "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries." >&2;} fi fi fi @@ -19063,8 +20134,8 @@ printf "%s\n" "$as_me: WARNING: assuming $_SOSUFFIX suffix for dynamic libraries else JMODSUFFIX=$_SOSUFFIX fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JMODSUFFIX" >&5 -printf "%s\n" "$JMODSUFFIX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JMODSUFFIX" >&5 +printf '%s\n' "$JMODSUFFIX" >&6; } @@ -19152,7 +20223,7 @@ if test "x$JAVAPREFIX" = x; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVAC+y} then : @@ -19173,7 +20244,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVAC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19185,11 +20256,11 @@ esac fi JAVAC=$ac_cv_prog_JAVAC if test -n "$JAVAC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 -printf "%s\n" "$JAVAC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 +printf '%s\n' "$JAVAC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19201,7 +20272,7 @@ else do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVAC+y} then : @@ -19222,7 +20293,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVAC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19234,11 +20305,11 @@ esac fi JAVAC=$ac_cv_prog_JAVAC if test -n "$JAVAC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 -printf "%s\n" "$JAVAC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 +printf '%s\n' "$JAVAC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19249,7 +20320,7 @@ test -n "$JAVAC" || JAVAC="$JAVAPREFIX" fi test "x$JAVAC" = x && as_fn_error $? "no acceptable Java compiler found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $JAVAC works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $JAVAC works" >&5 printf %s "checking if $JAVAC works... " >&6; } if test ${ac_cv_prog_javac_works+y} then : @@ -19259,7 +20330,7 @@ else case e in #( JAVA_TEST=Test.java CLASS_TEST=Test.class cat << \EOF > $JAVA_TEST -/* #line 19262 "configure" */ +/* #line 20333 "configure" */ public class Test { } EOF @@ -19267,7 +20338,7 @@ if { ac_try='$JAVAC $JAVACFLAGS $JAVA_TEST' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null 2>&1; then ac_cv_prog_javac_works=yes else @@ -19279,8 +20350,8 @@ rm -f $JAVA_TEST $CLASS_TEST ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_javac_works" >&5 -printf "%s\n" "$ac_cv_prog_javac_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_javac_works" >&5 +printf '%s\n' "$ac_cv_prog_javac_works" >&6; } @@ -19289,7 +20360,7 @@ if test "x$JAVAPREFIX" = x; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAR+y} then : @@ -19310,7 +20381,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAR="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19322,11 +20393,11 @@ esac fi JAR=$ac_cv_prog_JAR if test -n "$JAR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 -printf "%s\n" "$JAR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 +printf '%s\n' "$JAR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19338,7 +20409,7 @@ else do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAR+y} then : @@ -19359,7 +20430,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAR="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19371,11 +20442,11 @@ esac fi JAR=$ac_cv_prog_JAR if test -n "$JAR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 -printf "%s\n" "$JAR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 +printf '%s\n' "$JAR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19392,7 +20463,7 @@ if test x$JAVAPREFIX = x; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVA+y} then : @@ -19413,7 +20484,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVA="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19425,11 +20496,11 @@ esac fi JAVA=$ac_cv_prog_JAVA if test -n "$JAVA"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5 -printf "%s\n" "$JAVA" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5 +printf '%s\n' "$JAVA" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19441,7 +20512,7 @@ else do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVA+y} then : @@ -19462,7 +20533,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVA="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19474,11 +20545,11 @@ esac fi JAVA=$ac_cv_prog_JAVA if test -n "$JAVA"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5 -printf "%s\n" "$JAVA" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5 +printf '%s\n' "$JAVA" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19491,7 +20562,7 @@ test x$JAVA = x && as_fn_error $? "no acceptable Java virtual machine found in \ # Extract the first word of "uudecode$EXEEXT", so it can be a program name with args. set dummy uudecode$EXEEXT; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_uudecode+y} then : @@ -19512,7 +20583,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_uudecode="yes" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19524,16 +20595,16 @@ esac fi uudecode=$ac_cv_prog_uudecode if test -n "$uudecode"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $uudecode" >&5 -printf "%s\n" "$uudecode" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $uudecode" >&5 +printf '%s\n' "$uudecode" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test x$uudecode = xyes; then -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if uudecode can decode base 64 file" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if uudecode can decode base 64 file" >&5 printf %s "checking if uudecode can decode base 64 file... " >&6; } if test ${ac_cv_prog_uudecode_base64+y} then : @@ -19554,7 +20625,7 @@ EOF if uudecode$EXEEXT Test.uue; then ac_cv_prog_uudecode_base64=yes else - echo "configure: 19557: uudecode had trouble decoding base 64 file 'Test.uue'" >&5 + echo "configure: 20628: uudecode had trouble decoding base 64 file 'Test.uue'" >&5 echo "configure: failed file was:" >&5 cat Test.uue >&5 ac_cv_prog_uudecode_base64=no @@ -19562,13 +20633,13 @@ fi rm -f Test.uue ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_uudecode_base64" >&5 -printf "%s\n" "$ac_cv_prog_uudecode_base64" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_uudecode_base64" >&5 +printf '%s\n' "$ac_cv_prog_uudecode_base64" >&6; } fi if test x$ac_cv_prog_uudecode_base64 != xyes; then rm -f Test.class - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: I have to compile Test.class from scratch" >&5 -printf "%s\n" "$as_me: WARNING: I have to compile Test.class from scratch" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: I have to compile Test.class from scratch" >&5 +printf '%s\n' "$as_me: WARNING: I have to compile Test.class from scratch" >&2;} if test x$ac_cv_prog_javac_works = xno; then as_fn_error $? "Cannot compile java source. $JAVAC does not work properly" "$LINENO" 5 fi @@ -19579,7 +20650,7 @@ if test "x$JAVAPREFIX" = x; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVAC+y} then : @@ -19600,7 +20671,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVAC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19612,11 +20683,11 @@ esac fi JAVAC=$ac_cv_prog_JAVAC if test -n "$JAVAC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 -printf "%s\n" "$JAVAC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 +printf '%s\n' "$JAVAC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19628,7 +20699,7 @@ else do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAVAC+y} then : @@ -19649,7 +20720,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAVAC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19661,11 +20732,11 @@ esac fi JAVAC=$ac_cv_prog_JAVAC if test -n "$JAVAC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 -printf "%s\n" "$JAVAC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5 +printf '%s\n' "$JAVAC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -19676,7 +20747,7 @@ test -n "$JAVAC" || JAVAC="$JAVAPREFIX" fi test "x$JAVAC" = x && as_fn_error $? "no acceptable Java compiler found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $JAVAC works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $JAVAC works" >&5 printf %s "checking if $JAVAC works... " >&6; } if test ${ac_cv_prog_javac_works+y} then : @@ -19686,7 +20757,7 @@ else case e in #( JAVA_TEST=Test.java CLASS_TEST=Test.class cat << \EOF > $JAVA_TEST -/* #line 19689 "configure" */ +/* #line 20760 "configure" */ public class Test { } EOF @@ -19694,7 +20765,7 @@ if { ac_try='$JAVAC $JAVACFLAGS $JAVA_TEST' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null 2>&1; then ac_cv_prog_javac_works=yes else @@ -19706,13 +20777,13 @@ rm -f $JAVA_TEST $CLASS_TEST ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_javac_works" >&5 -printf "%s\n" "$ac_cv_prog_javac_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_javac_works" >&5 +printf '%s\n' "$ac_cv_prog_javac_works" >&6; } fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $JAVA works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $JAVA works" >&5 printf %s "checking if $JAVA works... " >&6; } if test ${ac_cv_prog_java_works+y} then : @@ -19723,7 +20794,7 @@ JAVA_TEST=Test.java CLASS_TEST=Test.class TEST=Test cat << \EOF > $JAVA_TEST -/* [#]line 19726 "configure" */ +/* [#]line 20797 "configure" */ public class Test { public static void main (String args[]) { System.exit (0); @@ -19734,7 +20805,7 @@ if test x$ac_cv_prog_uudecode_base64 != xyes; then { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } && test -s $CLASS_TEST; then : else @@ -19747,7 +20818,7 @@ if { ac_try='$JAVA $JAVAFLAGS $TEST' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null 2>&1; then ac_cv_prog_java_works=yes else @@ -19759,8 +20830,8 @@ rm -fr $JAVA_TEST $CLASS_TEST Test.uue ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_java_works" >&5 -printf "%s\n" "$ac_cv_prog_java_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_java_works" >&5 +printf '%s\n' "$ac_cv_prog_java_works" >&6; } @@ -19771,7 +20842,7 @@ JNI_INCLUDE_DIRS="" test "x$JAVAC" = x && as_fn_error $? "'$JAVAC' undefined" "$LINENO" 5 # Extract the first word of "$JAVAC", so it can be a program name with args. set dummy $JAVAC; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path__ACJNI_JAVAC+y} then : @@ -19794,7 +20865,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path__ACJNI_JAVAC="$as_dir$ac_word$ac_exec_ext" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -19808,20 +20879,20 @@ esac fi _ACJNI_JAVAC=$ac_cv_path__ACJNI_JAVAC if test -n "$_ACJNI_JAVAC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $_ACJNI_JAVAC" >&5 -printf "%s\n" "$_ACJNI_JAVAC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $_ACJNI_JAVAC" >&5 +printf '%s\n' "$_ACJNI_JAVAC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test ! -x "$_ACJNI_JAVAC" && as_fn_error $? "$JAVAC could not be found in path" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute path of $JAVAC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute path of $JAVAC" >&5 printf %s "checking absolute path of $JAVAC... " >&6; } case "$_ACJNI_JAVAC" in -/*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $_ACJNI_JAVAC" >&5 -printf "%s\n" "$_ACJNI_JAVAC" >&6; };; +/*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $_ACJNI_JAVAC" >&5 +printf '%s\n' "$_ACJNI_JAVAC" >&6; };; *) as_fn_error $? "$_ACJNI_JAVAC is not an absolute path name" "$LINENO" 5;; esac @@ -19829,7 +20900,7 @@ esac # find the include directory relative to the javac executable _cur=""$_ACJNI_JAVAC"" while ls -ld "$_cur" 2>/dev/null | grep " -> " >/dev/null; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking symlink for $_cur" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking symlink for $_cur" >&5 printf %s "checking symlink for $_cur... " >&6; } _slink=`ls -ld "$_cur" | sed 's/.* -> //'` case "$_slink" in @@ -19837,8 +20908,8 @@ printf %s "checking symlink for $_cur... " >&6; } # 'X' avoids triggering unwanted echo options. *) _cur=`echo "X$_cur" | sed -e 's/^X//' -e 's:[^/]*$::'`"$_slink";; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $_cur" >&5 -printf "%s\n" "$_cur" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $_cur" >&5 +printf '%s\n' "$_cur" >&6; } done _ACJNI_FOLLOWED="$_cur" @@ -19892,7 +20963,7 @@ do done - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking java version" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking java version" >&5 printf %s "checking java version... " >&6; } case "$JAVA" in *kaffe* ) @@ -19901,8 +20972,8 @@ printf %s "checking java version... " >&6; } * ) JAVA_VERSION=`$JAVA -version 2>&1 | sed -e '/ version /!d' -e 's/.*"\(.*\)".*/\1/'` ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA_VERSION" >&5 -printf "%s\n" "$JAVA_VERSION" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVA_VERSION" >&5 +printf '%s\n' "$JAVA_VERSION" >&6; } case "$JAVA_VERSION" in 1.[3456789]* | 1.[1-9][0-9]* | [23456789]* ) ;; * ) @@ -19935,14 +21006,14 @@ if test "$db_cv_mingw" = "yes"; then OSDIR=os_windows PATH_SEPARATOR="\\\\/:" - printf "%s\n" "#define DB_WIN32 1" >>confdefs.h + printf '%s\n' "#define DB_WIN32 1" >>confdefs.h - printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h + printf '%s\n' "#define STDC_HEADERS 1" >>confdefs.h else OSDIR=os PATH_SEPARATOR="/" - printf "%s\n" "#define HAVE_SYSTEM_INCLUDE_FILES 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYSTEM_INCLUDE_FILES 1" >>confdefs.h fi @@ -19953,7 +21024,7 @@ if test "$db_cv_sql" = "yes"; then # Link against libdl, if found. It is only needed for the load # extension, but shouldn't hurt. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : @@ -19994,8 +21065,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : SQL_LIBS="$SQL_LIBS -ldl" @@ -20010,7 +21081,7 @@ fi save_LIBS="" LIBS="" { ac_cv_search_tgetent=; unset ac_cv_search_tgetent;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing tgetent" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing tgetent" >&5 printf %s "checking for library containing tgetent... " >&6; } if test ${ac_cv_search_tgetent+y} then : @@ -20068,8 +21139,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_tgetent" >&5 -printf "%s\n" "$ac_cv_search_tgetent" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_tgetent" >&5 +printf '%s\n' "$ac_cv_search_tgetent" >&6; } ac_res=$ac_cv_search_tgetent if test "$ac_res" != no then : @@ -20080,8 +21151,8 @@ else case e in #( esac fi - as_ac_Lib=`printf "%s\n" "ac_cv_lib_$rl_lib""_readline" | sed "$as_sed_sh"` -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for readline in -l$rl_lib" >&5 + as_ac_Lib=`printf '%s\n' "ac_cv_lib_$rl_lib""_readline" | sed "$as_sed_sh"` +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for readline in -l$rl_lib" >&5 printf %s "checking for readline in -l$rl_lib... " >&6; } if eval test \${$as_ac_Lib+y} then : @@ -20123,8 +21194,8 @@ LIBS=$ac_check_lib_save_LIBS ;; esac fi eval ac_res=\$$as_ac_Lib - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_ac_Lib"\" = x"yes" then : SQL_LIBS="$SQL_LIBS -l$rl_lib $term_LIBS" @@ -20142,7 +21213,7 @@ fi fi if test "$found" = "yes"; then - as_ac_Header=`printf "%s\n" "ac_cv_header_$header" | sed "$as_sed_sh"` + as_ac_Header=`printf '%s\n' "ac_cv_header_$header" | sed "$as_sed_sh"` ac_fn_c_check_header_compile "$LINENO" "$header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes" then : @@ -20153,8 +21224,8 @@ else case e in #( if test "$cross_compiling" != yes; then for dir in /usr /usr/local /usr/local/readline /usr/contrib /mingw; do for subdir in include include/readline; do - as_ac_File=`printf "%s\n" "ac_cv_file_$dir/$subdir/$header" | sed "$as_sed_sh"` -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $dir/$subdir/$header" >&5 + as_ac_File=`printf '%s\n' "ac_cv_file_$dir/$subdir/$header" | sed "$as_sed_sh"` +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $dir/$subdir/$header" >&5 printf %s "checking for $dir/$subdir/$header... " >&6; } if eval test \${$as_ac_File+y} then : @@ -20170,8 +21241,8 @@ fi ;; esac fi eval ac_res=\$$as_ac_File - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_ac_File"\" = x"yes" then : found=yes @@ -20250,7 +21321,7 @@ fi # Optional STL API. if test "$db_cv_stl" = "yes"; then -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports templates for STL" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports templates for STL" >&5 printf %s "checking whether the C++ compiler supports templates for STL... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -20548,8 +21619,8 @@ main (void) _ACEOF if ac_fn_cxx_try_compile "$LINENO" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else case e in #( e) as_fn_error $? "no" "$LINENO" 5 ;; esac @@ -20563,7 +21634,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C++ supports the wstring class" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C++ supports the wstring class" >&5 printf %s "checking whether C++ supports the wstring class... " >&6; } ac_ext=cpp @@ -20600,7 +21671,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for thread local storage (TLS) class" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for thread local storage (TLS) class" >&5 printf %s "checking for thread local storage (TLS) class... " >&6; } @@ -20692,8 +21763,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext TLS_defn="#define TLS_DEFN_MODIFIER $ax_tls_defn_keyword" ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_tls" >&5 -printf "%s\n" "$ac_cv_tls" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_tls" >&5 +printf '%s\n' "$ac_cv_tls" >&6; } if test "$enable_shared" = "no"; then DEFAULT_LIB_STL="\$(libstl_version)" @@ -20712,7 +21783,7 @@ printf "%s\n" "$ac_cv_tls" >&6; } fi # Checks for include files, structures, C types. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 printf %s "checking whether stat file-mode macros are broken... " >&6; } if test ${ac_cv_header_stat_broken+y} then : @@ -20750,31 +21821,31 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 -printf "%s\n" "$ac_cv_header_stat_broken" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 +printf '%s\n' "$ac_cv_header_stat_broken" >&6; } if test $ac_cv_header_stat_broken = yes; then -printf "%s\n" "#define STAT_MACROS_BROKEN 1" >>confdefs.h +printf '%s\n' "#define STAT_MACROS_BROKEN 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default" if test "x$ac_cv_header_sys_time_h" = xyes then : - printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYS_TIME_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "time.h" "ac_cv_header_time_h" "$ac_includes_default" if test "x$ac_cv_header_time_h" = xyes then : - printf "%s\n" "#define HAVE_TIME_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_TIME_H 1" >>confdefs.h fi ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do - as_ac_Header=`printf "%s\n" "ac_cv_header_dirent_$ac_hdr" | sed "$as_sed_sh"` -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 + as_ac_Header=`printf '%s\n' "ac_cv_header_dirent_$ac_hdr" | sed "$as_sed_sh"` +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 printf %s "checking for $ac_hdr that defines DIR... " >&6; } if eval test \${$as_ac_Header+y} then : @@ -20805,12 +21876,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$as_ac_Header - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_ac_Header"\" = x"yes" then : cat >>confdefs.h <<_ACEOF -#define `printf "%s\n" "HAVE_$ac_hdr" | sed "$as_sed_cpp"` 1 +#define `printf '%s\n' "HAVE_$ac_hdr" | sed "$as_sed_cpp"` 1 _ACEOF ac_header_dirent=$ac_hdr; break @@ -20819,7 +21890,7 @@ fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 printf %s "checking for library containing opendir... " >&6; } if test ${ac_cv_search_opendir+y} then : @@ -20877,8 +21948,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -printf "%s\n" "$ac_cv_search_opendir" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf '%s\n' "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no then : @@ -20887,7 +21958,7 @@ then : fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 printf %s "checking for library containing opendir... " >&6; } if test ${ac_cv_search_opendir+y} then : @@ -20945,8 +22016,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -printf "%s\n" "$ac_cv_search_opendir" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf '%s\n' "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no then : @@ -20959,25 +22030,25 @@ fi ac_fn_c_check_header_compile "$LINENO" "execinfo.h" "ac_cv_header_execinfo_h" "$ac_includes_default" if test "x$ac_cv_header_execinfo_h" = xyes then : - printf "%s\n" "#define HAVE_EXECINFO_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_EXECINFO_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/select.h" "ac_cv_header_sys_select_h" "$ac_includes_default" if test "x$ac_cv_header_sys_select_h" = xyes then : - printf "%s\n" "#define HAVE_SYS_SELECT_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYS_SELECT_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default" if test "x$ac_cv_header_sys_socket_h" = xyes then : - printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default" if test "x$ac_cv_header_sys_time_h" = xyes then : - printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYS_TIME_H 1" >>confdefs.h fi @@ -20985,7 +22056,7 @@ ac_fn_c_check_member "$LINENO" "struct stat" "st_blksize" "ac_cv_member_struct_s if test "x$ac_cv_member_struct_stat_st_blksize" = xyes then : -printf "%s\n" "#define HAVE_STRUCT_STAT_ST_BLKSIZE 1" >>confdefs.h +printf '%s\n' "#define HAVE_STRUCT_STAT_ST_BLKSIZE 1" >>confdefs.h fi @@ -21021,7 +22092,7 @@ fi # IRIX compiler does not exit with a non-zero exit code when it sees # #error, so we actually need to use the header for the compiler to fail. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for stdint.h" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for stdint.h" >&5 printf %s "checking for stdint.h... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -21034,10 +22105,10 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext _ACEOF if ac_fn_c_try_compile "$LINENO" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } if test "$db_cv_cxx" = "yes"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stdint.h can be used by C++" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if stdint.h can be used by C++" >&5 printf %s "checking if stdint.h can be used by C++... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -21055,15 +22126,15 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu _ACEOF if ac_fn_cxx_try_compile "$LINENO" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } stdint_h_decl="#include " db_includes="$db_includes #include " else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } stdint_h_decl="#ifndef __cplusplus #include #endif" @@ -21087,8 +22158,8 @@ else #include " fi else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } ;; + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext @@ -21121,7 +22192,7 @@ db_includes="$db_includes # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of char" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of char" >&5 printf %s "checking size of char... " >&6; } if test ${ac_cv_sizeof_char+y} then : @@ -21132,32 +22203,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_char" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (char) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_char=0 - fi ;; + e) ac_cv_sizeof_char=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_char" >&5 -printf "%s\n" "$ac_cv_sizeof_char" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_char" >&5 +printf '%s\n' "$ac_cv_sizeof_char" >&6; } -printf "%s\n" "#define SIZEOF_CHAR $ac_cv_sizeof_char" >>confdefs.h +printf '%s\n' "#define SIZEOF_CHAR $ac_cv_sizeof_char" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of unsigned char" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of unsigned char" >&5 printf %s "checking size of unsigned char... " >&6; } if test ${ac_cv_sizeof_unsigned_char+y} then : @@ -21168,32 +22232,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_unsigned_char" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (unsigned char) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_unsigned_char=0 - fi ;; + e) ac_cv_sizeof_unsigned_char=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_char" >&5 -printf "%s\n" "$ac_cv_sizeof_unsigned_char" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_char" >&5 +printf '%s\n' "$ac_cv_sizeof_unsigned_char" >&6; } -printf "%s\n" "#define SIZEOF_UNSIGNED_CHAR $ac_cv_sizeof_unsigned_char" >>confdefs.h +printf '%s\n' "#define SIZEOF_UNSIGNED_CHAR $ac_cv_sizeof_unsigned_char" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of short" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of short" >&5 printf %s "checking size of short... " >&6; } if test ${ac_cv_sizeof_short+y} then : @@ -21204,32 +22261,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_short" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (short) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_short=0 - fi ;; + e) ac_cv_sizeof_short=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5 -printf "%s\n" "$ac_cv_sizeof_short" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5 +printf '%s\n' "$ac_cv_sizeof_short" >&6; } -printf "%s\n" "#define SIZEOF_SHORT $ac_cv_sizeof_short" >>confdefs.h +printf '%s\n' "#define SIZEOF_SHORT $ac_cv_sizeof_short" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of unsigned short" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of unsigned short" >&5 printf %s "checking size of unsigned short... " >&6; } if test ${ac_cv_sizeof_unsigned_short+y} then : @@ -21240,32 +22290,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_unsigned_short" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (unsigned short) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_unsigned_short=0 - fi ;; + e) ac_cv_sizeof_unsigned_short=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_short" >&5 -printf "%s\n" "$ac_cv_sizeof_unsigned_short" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_short" >&5 +printf '%s\n' "$ac_cv_sizeof_unsigned_short" >&6; } -printf "%s\n" "#define SIZEOF_UNSIGNED_SHORT $ac_cv_sizeof_unsigned_short" >>confdefs.h +printf '%s\n' "#define SIZEOF_UNSIGNED_SHORT $ac_cv_sizeof_unsigned_short" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of int" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of int" >&5 printf %s "checking size of int... " >&6; } if test ${ac_cv_sizeof_int+y} then : @@ -21276,32 +22319,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_int" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (int) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_int=0 - fi ;; + e) ac_cv_sizeof_int=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5 -printf "%s\n" "$ac_cv_sizeof_int" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5 +printf '%s\n' "$ac_cv_sizeof_int" >&6; } -printf "%s\n" "#define SIZEOF_INT $ac_cv_sizeof_int" >>confdefs.h +printf '%s\n' "#define SIZEOF_INT $ac_cv_sizeof_int" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of unsigned int" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of unsigned int" >&5 printf %s "checking size of unsigned int... " >&6; } if test ${ac_cv_sizeof_unsigned_int+y} then : @@ -21312,32 +22348,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_unsigned_int" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (unsigned int) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_unsigned_int=0 - fi ;; + e) ac_cv_sizeof_unsigned_int=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_int" >&5 -printf "%s\n" "$ac_cv_sizeof_unsigned_int" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_int" >&5 +printf '%s\n' "$ac_cv_sizeof_unsigned_int" >&6; } -printf "%s\n" "#define SIZEOF_UNSIGNED_INT $ac_cv_sizeof_unsigned_int" >>confdefs.h +printf '%s\n' "#define SIZEOF_UNSIGNED_INT $ac_cv_sizeof_unsigned_int" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of long" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of long" >&5 printf %s "checking size of long... " >&6; } if test ${ac_cv_sizeof_long+y} then : @@ -21348,32 +22377,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_long" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (long) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_long=0 - fi ;; + e) ac_cv_sizeof_long=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5 -printf "%s\n" "$ac_cv_sizeof_long" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5 +printf '%s\n' "$ac_cv_sizeof_long" >&6; } -printf "%s\n" "#define SIZEOF_LONG $ac_cv_sizeof_long" >>confdefs.h +printf '%s\n' "#define SIZEOF_LONG $ac_cv_sizeof_long" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of unsigned long" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of unsigned long" >&5 printf %s "checking size of unsigned long... " >&6; } if test ${ac_cv_sizeof_unsigned_long+y} then : @@ -21384,32 +22406,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_unsigned_long" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (unsigned long) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_unsigned_long=0 - fi ;; + e) ac_cv_sizeof_unsigned_long=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_long" >&5 -printf "%s\n" "$ac_cv_sizeof_unsigned_long" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_long" >&5 +printf '%s\n' "$ac_cv_sizeof_unsigned_long" >&6; } -printf "%s\n" "#define SIZEOF_UNSIGNED_LONG $ac_cv_sizeof_unsigned_long" >>confdefs.h +printf '%s\n' "#define SIZEOF_UNSIGNED_LONG $ac_cv_sizeof_unsigned_long" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5 printf %s "checking size of long long... " >&6; } if test ${ac_cv_sizeof_long_long+y} then : @@ -21420,32 +22435,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_long_long" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (long long) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_long_long=0 - fi ;; + e) ac_cv_sizeof_long_long=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long" >&5 -printf "%s\n" "$ac_cv_sizeof_long_long" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long" >&5 +printf '%s\n' "$ac_cv_sizeof_long_long" >&6; } -printf "%s\n" "#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long" >>confdefs.h +printf '%s\n' "#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of unsigned long long" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of unsigned long long" >&5 printf %s "checking size of unsigned long long... " >&6; } if test ${ac_cv_sizeof_unsigned_long_long+y} then : @@ -21456,32 +22464,25 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_unsigned_long_long" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (unsigned long long) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_unsigned_long_long=0 - fi ;; + e) ac_cv_sizeof_unsigned_long_long=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_long_long" >&5 -printf "%s\n" "$ac_cv_sizeof_unsigned_long_long" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_unsigned_long_long" >&5 +printf '%s\n' "$ac_cv_sizeof_unsigned_long_long" >&6; } -printf "%s\n" "#define SIZEOF_UNSIGNED_LONG_LONG $ac_cv_sizeof_unsigned_long_long" >>confdefs.h +printf '%s\n' "#define SIZEOF_UNSIGNED_LONG_LONG $ac_cv_sizeof_unsigned_long_long" >>confdefs.h # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of char *" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of char *" >&5 printf %s "checking size of char *... " >&6; } if test ${ac_cv_sizeof_char_p+y} then : @@ -21492,25 +22493,18 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_char_p" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (char *) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_char_p=0 - fi ;; + e) ac_cv_sizeof_char_p=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_char_p" >&5 -printf "%s\n" "$ac_cv_sizeof_char_p" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_char_p" >&5 +printf '%s\n' "$ac_cv_sizeof_char_p" >&6; } -printf "%s\n" "#define SIZEOF_CHAR_P $ac_cv_sizeof_char_p" >>confdefs.h +printf '%s\n' "#define SIZEOF_CHAR_P $ac_cv_sizeof_char_p" >>confdefs.h @@ -21765,7 +22759,7 @@ fi # # We require them, we don't try to substitute our own if we can't find them. -as_ac_Type=`printf "%s\n" "ac_cv_type_FILE *" | sed "$as_sed_sh"` +as_ac_Type=`printf '%s\n' "ac_cv_type_FILE *" | sed "$as_sed_sh"` ac_fn_c_check_type "$LINENO" "FILE *" "$as_ac_Type" "$db_includes " if eval test \"x\$"$as_ac_Type"\" = x"yes" @@ -21827,7 +22821,7 @@ fi # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of size_t" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of size_t" >&5 printf %s "checking size of size_t... " >&6; } if test ${ac_cv_sizeof_size_t+y} then : @@ -21838,25 +22832,18 @@ else case e in #( then : else case e in #( - e) if test "$ac_cv_type_size_t" = yes; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (size_t) -See 'config.log' for more details" "$LINENO" 5; } - else - ac_cv_sizeof_size_t=0 - fi ;; + e) ac_cv_sizeof_size_t=0 ;; esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_size_t" >&5 -printf "%s\n" "$ac_cv_sizeof_size_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_size_t" >&5 +printf '%s\n' "$ac_cv_sizeof_size_t" >&6; } -printf "%s\n" "#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t" >>confdefs.h +printf '%s\n' "#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t" >>confdefs.h @@ -21948,7 +22935,7 @@ if test "x$ac_cv_type_socklen_t" = xyes then : else case e in #( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socklen_t equivalent" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for socklen_t equivalent" >&5 printf %s "checking for socklen_t equivalent... " >&6; } if test ${db_cv_socklen_t_equiv+y} then : @@ -21991,17 +22978,17 @@ fi if test "$db_cv_socklen_t_equiv" = ""; then as_fn_error $? "Cannot find a type to use in place of socklen_t" "$LINENO" 5 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_socklen_t_equiv" >&5 -printf "%s\n" "$db_cv_socklen_t_equiv" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_socklen_t_equiv" >&5 +printf '%s\n' "$db_cv_socklen_t_equiv" >&6; } -printf "%s\n" "#define socklen_t $db_cv_socklen_t_equiv" >>confdefs.h +printf '%s\n' "#define socklen_t $db_cv_socklen_t_equiv" >>confdefs.h ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ANSI C exit success/failure values" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ANSI C exit success/failure values" >&5 printf %s "checking for ANSI C exit success/failure values... " >&6; } if test ${db_cv_exit_defines+y} then : @@ -22029,15 +23016,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_exit_defines" >&5 -printf "%s\n" "$db_cv_exit_defines" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_exit_defines" >&5 +printf '%s\n' "$db_cv_exit_defines" >&6; } if test "$db_cv_exit_defines" = "yes"; then - printf "%s\n" "#define HAVE_EXIT_SUCCESS 1" >>confdefs.h + printf '%s\n' "#define HAVE_EXIT_SUCCESS 1" >>confdefs.h fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for getopt optreset variable" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for getopt optreset variable" >&5 printf %s "checking for getopt optreset variable... " >&6; } if test ${db_cv_optreset+y} then : @@ -22066,10 +23053,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_optreset" >&5 -printf "%s\n" "$db_cv_optreset" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_optreset" >&5 +printf '%s\n' "$db_cv_optreset" >&6; } if test "$db_cv_optreset" = "yes"; then - printf "%s\n" "#define HAVE_GETOPT_OPTRESET 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETOPT_OPTRESET 1" >>confdefs.h fi @@ -22082,7 +23069,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for mutexes" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for mutexes" >&5 printf %s "checking for mutexes... " >&6; } if test ${db_cv_mutex+y} then : @@ -22109,7 +23096,7 @@ fi if test "$db_cv_mutex" = no; then case "$host_os" in darwin*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread mutex support on Darwin" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread mutex support on Darwin" >&5 printf %s "checking for pthread mutex support on Darwin... " >&6; } # First try with -lpthread LIBS="$LIBS -lpthread" @@ -22140,8 +23127,8 @@ if ac_fn_c_try_link "$LINENO" then : db_cv_mutex=POSIX/pthreads/library - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, with -lpthread" >&5 -printf "%s\n" "yes, with -lpthread" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes, with -lpthread" >&5 +printf '%s\n' "yes, with -lpthread" >&6; } else case e in #( e) @@ -22174,13 +23161,13 @@ if ac_fn_c_try_link "$LINENO" then : db_cv_mutex=POSIX/pthreads - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, built-in" >&5 -printf "%s\n" "yes, built-in" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes, built-in" >&5 +printf '%s\n' "yes, built-in" >&6; } else case e in #( e) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } ;; esac fi @@ -24356,75 +25343,75 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_mutex" >&5 -printf "%s\n" "$db_cv_mutex" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_mutex" >&5 +printf '%s\n' "$db_cv_mutex" >&6; } # Configure a pthreads-style mutex implementation. hybrid=pthread case "$db_cv_mutex" in POSIX/pthreads/private*)ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h if test "$db_cv_pthread_condinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h fi if test "$db_cv_pthread_rwlockinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h fi - printf "%s\n" "#define HAVE_MUTEX_THREAD_ONLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_THREAD_ONLY 1" >>confdefs.h ;; POSIX/pthreads/library/private*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h if test "$db_cv_pthread_condinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h fi if test "$db_cv_pthread_rwlockinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h fi - printf "%s\n" "#define HAVE_MUTEX_THREAD_ONLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_THREAD_ONLY 1" >>confdefs.h ;; POSIX/pthreads/library*)ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h if test "$db_cv_pthread_condinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h fi if test "$db_cv_pthread_rwlockinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h fi;; POSIX/pthreads*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_PTHREADS 1" >>confdefs.h if test "$db_cv_pthread_condinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_COND_REINIT_OKAY 1" >>confdefs.h fi if test "$db_cv_pthread_rwlockinit_dupgood" = "yes"; then - printf "%s\n" "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_RWLOCK_REINIT_OKAY 1" >>confdefs.h fi ;; Solaris/lwp*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SOLARIS_LWP 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SOLARIS_LWP 1" >>confdefs.h ;; UI/threads/library*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_UI_THREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_UI_THREADS 1" >>confdefs.h ;; *) hybrid=no;; UI/threads*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_UI_THREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_UI_THREADS 1" >>confdefs.h ;; esac @@ -24432,126 +25419,126 @@ esac # Configure a test-and-set mutex implementation. case "$db_cv_mutex" in 68K/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_68K_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_68K_GCC_ASSEMBLY 1" >>confdefs.h ;; AIX/_check_lock) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_AIX_CHECK_LOCK 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_AIX_CHECK_LOCK 1" >>confdefs.h ;; Darwin/_spin_lock_try) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_DARWIN_SPIN_LOCK_TRY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_DARWIN_SPIN_LOCK_TRY 1" >>confdefs.h ;; ALPHA/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_ALPHA_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_ALPHA_GCC_ASSEMBLY 1" >>confdefs.h ;; ARM64/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_ARM64_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_ARM64_GCC_ASSEMBLY 1" >>confdefs.h ;; ARM32/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_ARM32_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_ARM32_GCC_ASSEMBLY 1" >>confdefs.h ;; ARM/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_ARM_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_ARM_GCC_ASSEMBLY 1" >>confdefs.h ;; HP/msem_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_HPPA_MSEM_INIT 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_HPPA_MSEM_INIT 1" >>confdefs.h ;; HPPA/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_HPPA_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_HPPA_GCC_ASSEMBLY 1" >>confdefs.h ;; ia64/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_IA64_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_IA64_GCC_ASSEMBLY 1" >>confdefs.h ;; MIPS/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_MIPS_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_MIPS_GCC_ASSEMBLY 1" >>confdefs.h ;; PPC/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_PPC_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_PPC_GCC_ASSEMBLY 1" >>confdefs.h ;; ReliantUNIX/initspin) LIBSO_LIBS="$LIBSO_LIBS -lmproc" ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_RELIANTUNIX_INITSPIN 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_RELIANTUNIX_INITSPIN 1" >>confdefs.h ;; S390/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_S390_CC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_S390_CC_ASSEMBLY 1" >>confdefs.h ;; S390/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_S390_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_S390_GCC_ASSEMBLY 1" >>confdefs.h ;; SCO/x86/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SCO_X86_CC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SCO_X86_CC_ASSEMBLY 1" >>confdefs.h ;; SGI/init_lock) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SGI_INIT_LOCK 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SGI_INIT_LOCK 1" >>confdefs.h ;; Solaris/_lock_try) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SOLARIS_LOCK_TRY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SOLARIS_LOCK_TRY 1" >>confdefs.h ;; *Solaris/_lock_try/membar) hybrid="$hybrid/tas" ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SOLARIS_LOCK_TRY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SOLARIS_LOCK_TRY 1" >>confdefs.h ;; *Sparc/gcc-assembly) hybrid="$hybrid/tas" ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SPARC_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SPARC_GCC_ASSEMBLY 1" >>confdefs.h ;; Tru64/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_TRU64_CC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_TRU64_CC_ASSEMBLY 1" >>confdefs.h ;; UNIX/msem_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_MSEM_INIT 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_MSEM_INIT 1" >>confdefs.h ;; UNIX/sema_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_SEMA_INIT 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SEMA_INIT 1" >>confdefs.h ;; UTS/cc-assembly) ADDITIONAL_OBJS="uts4.cc${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_UTS_CC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_UTS_CC_ASSEMBLY 1" >>confdefs.h ;; *x86/gcc-assembly) hybrid="$hybrid/tas" ;; *arm64/gcc-assembly) - printf "%s\n" "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h - printf "%s\n" "#define HAVE_ATOMIC_ARM64_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_ARM64_ASSEMBLY 1" >>confdefs.h ;; *arm32/gcc-assembly) - printf "%s\n" "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h - printf "%s\n" "#define HAVE_ATOMIC_ARM32_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_ARM32_ASSEMBLY 1" >>confdefs.h ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_X86_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_X86_GCC_ASSEMBLY 1" >>confdefs.h ;; *x86_64/gcc-assembly) hybrid="$hybrid/tas" ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_X86_64_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_X86_64_GCC_ASSEMBLY 1" >>confdefs.h ;; esac @@ -24560,15 +25547,15 @@ esac case "$db_cv_mutex" in UNIX/fcntl) as_fn_error $? "Support for FCNTL mutexes was removed in BDB 4.8." "$LINENO" 5 ADDITIONAL_OBJS="mut_fcntl${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_FCNTL 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_FCNTL 1" >>confdefs.h ;; win32) ADDITIONAL_OBJS="mut_win32${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_WIN32 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_WIN32 1" >>confdefs.h ;; win32/gcc) ADDITIONAL_OBJS="mut_win32${o} $ADDITIONAL_OBJS" - printf "%s\n" "#define HAVE_MUTEX_WIN32_GCC 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_WIN32_GCC 1" >>confdefs.h ;; esac @@ -24582,7 +25569,7 @@ disabled) # additional objects for a mutex implementation. case "$ADDITIONAL_OBJS" in *mut_pthread*|*mut_tas*|*mut_win32*) - printf "%s\n" "#define HAVE_MUTEX_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SUPPORT 1" >>confdefs.h @@ -24590,7 +25577,7 @@ disabled) # mutexes if we don't have a native implementation. # This macro may be removed in a future release. - printf "%s\n" "#define HAVE_SHARED_LATCHES 1" >>confdefs.h + printf '%s\n' "#define HAVE_SHARED_LATCHES 1" >>confdefs.h ;; *) as_fn_error $? "Unable to find a mutex implementation" "$LINENO" 5;; @@ -24600,7 +25587,7 @@ esac # We may have found both a pthreads-style mutex implementation as well as a # test-and-set, in which case configure for the hybrid. if test "$hybrid" = pthread/tas; then - printf "%s\n" "#define HAVE_MUTEX_HYBRID 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_HYBRID 1" >>confdefs.h fi @@ -24633,7 +25620,7 @@ case "$db_cv_mutex" in UI/threads*) thread_h_decl="#include " db_threadid_t_decl="typedef thread_t db_threadid_t;" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for thr_create in -lthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for thr_create in -lthread" >&5 printf %s "checking for thr_create in -lthread... " >&6; } if test ${ac_cv_lib_thread_thr_create+y} then : @@ -24674,8 +25661,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thread_thr_create" >&5 -printf "%s\n" "$ac_cv_lib_thread_thr_create" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thread_thr_create" >&5 +printf '%s\n' "$ac_cv_lib_thread_thr_create" >&6; } if test "x$ac_cv_lib_thread_thr_create" = xyes then : LIBSO_LIBS="$LIBSO_LIBS -lthread" @@ -24692,7 +25679,7 @@ fi thread_h_decl="#include " db_threadid_t_decl="typedef pthread_t db_threadid_t;" fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_create in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_create in -lpthread" >&5 printf %s "checking for pthread_create in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_create+y} then : @@ -24733,8 +25720,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_create" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_create" >&6; } if test "x$ac_cv_lib_pthread_pthread_create" = xyes then : LIBSO_LIBS="$LIBSO_LIBS -lpthread" @@ -24749,7 +25736,7 @@ esac if test "$db_threadid_t_decl" = notset; then db_threadid_t_decl="typedef uintmax_t db_threadid_t;" - printf "%s\n" "#define HAVE_SIMPLE_THREAD_TYPE 1" >>confdefs.h + printf '%s\n' "#define HAVE_SIMPLE_THREAD_TYPE 1" >>confdefs.h else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -24771,7 +25758,7 @@ main (void) _ACEOF if ac_fn_c_try_compile "$LINENO" then : - printf "%s\n" "#define HAVE_SIMPLE_THREAD_TYPE 1" >>confdefs.h + printf '%s\n' "#define HAVE_SIMPLE_THREAD_TYPE 1" >>confdefs.h fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext @@ -24798,7 +25785,7 @@ fi case "$host_os$db_cv_mutex" in *qnx*POSIX/pthread*|openedition*POSIX/pthread*) - printf "%s\n" "#define HAVE_MUTEX_SYSTEM_RESOURCES 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUTEX_SYSTEM_RESOURCES 1" >>confdefs.h ;; esac @@ -24822,7 +25809,7 @@ esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for atomic operations" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for atomic operations" >&5 printf %s "checking for atomic operations... " >&6; } if test ${db_cv_atomic+y} then : @@ -24895,31 +25882,31 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomic" >&5 -printf "%s\n" "$db_cv_atomic" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomic" >&5 +printf '%s\n' "$db_cv_atomic" >&6; } case "$db_cv_atomic" in x86/gcc-assembly) - printf "%s\n" "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h - printf "%s\n" "#define HAVE_ATOMIC_X86_GCC_ASSEMBLY 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_X86_GCC_ASSEMBLY 1" >>confdefs.h ;; solaris/atomic) - printf "%s\n" "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h - printf "%s\n" "#define HAVE_ATOMIC_SOLARIS 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SOLARIS 1" >>confdefs.h ;; mingw) - printf "%s\n" "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_SUPPORT 1" >>confdefs.h ;; esac # Check for ARM64/AArch64 architecture. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AArch64 architecture" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for AArch64 architecture" >&5 printf %s "checking for AArch64 architecture... " >&6; } if test ${db_cv_aarch64+y} then : @@ -24954,15 +25941,15 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_aarch64" >&5 -printf "%s\n" "$db_cv_aarch64" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_aarch64" >&5 +printf '%s\n' "$db_cv_aarch64" >&6; } if test "$db_cv_aarch64" = yes; then - printf "%s\n" "#define HAVE_ATOMIC_AARCH64 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_AARCH64 1" >>confdefs.h fi # Check for 64-bit atomic operation support. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 64-bit atomic operations" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for 64-bit atomic operations" >&5 printf %s "checking for 64-bit atomic operations... " >&6; } if test ${db_cv_atomic_64bit+y} then : @@ -25025,10 +26012,10 @@ esac ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomic_64bit" >&5 -printf "%s\n" "$db_cv_atomic_64bit" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_atomic_64bit" >&5 +printf '%s\n' "$db_cv_atomic_64bit" >&6; } if test "$db_cv_atomic_64bit" = yes; then - printf "%s\n" "#define HAVE_ATOMIC_64BIT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOMIC_64BIT 1" >>confdefs.h fi @@ -25058,7 +26045,7 @@ if test "$db_cv_perfmon" = "yes" ; then ac_fn_c_check_header_compile "$LINENO" "sys/sdt.h" "ac_cv_header_sys_sdt_h" "$ac_includes_default" if test "x$ac_cv_header_sys_sdt_h" = xyes then : - printf "%s\n" "#define HAVE_SYS_SDT_H 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYS_SDT_H 1" >>confdefs.h fi @@ -25100,15 +26087,15 @@ db_provider.h.tmp > db_provider.h ; then rm -f db_provider.c echo "" > db_provider.c fi - printf "%s\n" "#define HAVE_DTRACE 1" >>confdefs.h + printf '%s\n' "#define HAVE_DTRACE 1" >>confdefs.h else as_fn_error $? "No supported performance utility found." "$LINENO" 5 fi - printf "%s\n" "#define HAVE_PERFMON 1" >>confdefs.h + printf '%s\n' "#define HAVE_PERFMON 1" >>confdefs.h if test "$db_cv_perfmon_statistics" != "no" ; then - printf "%s\n" "#define HAVE_PERFMON_STATISTICS 1" >>confdefs.h + printf '%s\n' "#define HAVE_PERFMON_STATISTICS 1" >>confdefs.h fi # The method by which probes are listed depends on the underlying @@ -25138,7 +26125,7 @@ LIBS="$LIBSO_LIBS" # The yield function on Solaris is almost certainly pthread_yield (LWP threads # or POSIX pthreads), or thr_yield (UI threads). There's an outside chance it # is sched_yield() though, only available in -lrt on Solaris. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing sched_yield" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing sched_yield" >&5 printf %s "checking for library containing sched_yield... " >&6; } if test ${ac_cv_search_sched_yield+y} then : @@ -25196,8 +26183,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_sched_yield" >&5 -printf "%s\n" "$ac_cv_search_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_sched_yield" >&5 +printf '%s\n' "$ac_cv_search_sched_yield" >&6; } ac_res=$ac_cv_search_sched_yield if test "$ac_res" != no then : @@ -25207,7 +26194,7 @@ fi # The Berkeley DB library calls fdatasync, only available in -lrt on Solaris. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing fdatasync" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing fdatasync" >&5 printf %s "checking for library containing fdatasync... " >&6; } if test ${ac_cv_search_fdatasync+y} then : @@ -25265,8 +26252,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_fdatasync" >&5 -printf "%s\n" "$ac_cv_search_fdatasync" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_fdatasync" >&5 +printf '%s\n' "$ac_cv_search_fdatasync" >&6; } ac_res=$ac_cv_search_fdatasync if test "$ac_res" != no then : @@ -25275,7 +26262,7 @@ then : fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing getaddrinfo" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing getaddrinfo" >&5 printf %s "checking for library containing getaddrinfo... " >&6; } if test ${ac_cv_search_getaddrinfo+y} then : @@ -25333,8 +26320,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getaddrinfo" >&5 -printf "%s\n" "$ac_cv_search_getaddrinfo" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getaddrinfo" >&5 +printf '%s\n' "$ac_cv_search_getaddrinfo" >&6; } ac_res=$ac_cv_search_getaddrinfo if test "$ac_res" != no then : @@ -25342,7 +26329,7 @@ then : fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing hstrerror" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing hstrerror" >&5 printf %s "checking for library containing hstrerror... " >&6; } if test ${ac_cv_search_hstrerror+y} then : @@ -25400,8 +26387,8 @@ rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_hstrerror" >&5 -printf "%s\n" "$ac_cv_search_hstrerror" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_hstrerror" >&5 +printf '%s\n' "$ac_cv_search_hstrerror" >&6; } ac_res=$ac_cv_search_hstrerror if test "$ac_res" != no then : @@ -25416,7 +26403,7 @@ LIBSO_LIBS="$LIBS" # !!! # We could be more exact about whether these libraries are needed, but don't # bother -- if they exist, we load them, it's only the test programs anyway. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sin in -lm" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sin in -lm" >&5 printf %s "checking for sin in -lm... " >&6; } if test ${ac_cv_lib_m_sin+y} then : @@ -25457,14 +26444,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_sin" >&5 -printf "%s\n" "$ac_cv_lib_m_sin" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_sin" >&5 +printf '%s\n' "$ac_cv_lib_m_sin" >&6; } if test "x$ac_cv_lib_m_sin" = xyes then : TEST_LIBS="$TEST_LIBS -lm" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 printf %s "checking for gethostbyname in -lnsl... " >&6; } if test ${ac_cv_lib_nsl_gethostbyname+y} then : @@ -25505,14 +26492,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 -printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 +printf '%s\n' "$ac_cv_lib_nsl_gethostbyname" >&6; } if test "x$ac_cv_lib_nsl_gethostbyname" = xyes then : TEST_LIBS="$TEST_LIBS -lnsl" fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 printf %s "checking for socket in -lsocket... " >&6; } if test ${ac_cv_lib_socket_socket+y} then : @@ -25553,8 +26540,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 -printf "%s\n" "$ac_cv_lib_socket_socket" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 +printf '%s\n' "$ac_cv_lib_socket_socket" >&6; } if test "x$ac_cv_lib_socket_socket" = xyes then : TEST_LIBS="$TEST_LIBS -lsocket" @@ -25569,7 +26556,7 @@ fi ac_fn_c_check_func "$LINENO" "abort" "ac_cv_func_abort" if test "x$ac_cv_func_abort" = xyes then : - printf "%s\n" "#define HAVE_ABORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ABORT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25583,7 +26570,7 @@ fi ac_fn_c_check_func "$LINENO" "atoi" "ac_cv_func_atoi" if test "x$ac_cv_func_atoi" = xyes then : - printf "%s\n" "#define HAVE_ATOI 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOI 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25597,7 +26584,7 @@ fi ac_fn_c_check_func "$LINENO" "atol" "ac_cv_func_atol" if test "x$ac_cv_func_atol" = xyes then : - printf "%s\n" "#define HAVE_ATOL 1" >>confdefs.h + printf '%s\n' "#define HAVE_ATOL 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25611,7 +26598,7 @@ fi ac_fn_c_check_func "$LINENO" "bsearch" "ac_cv_func_bsearch" if test "x$ac_cv_func_bsearch" = xyes then : - printf "%s\n" "#define HAVE_BSEARCH 1" >>confdefs.h + printf '%s\n' "#define HAVE_BSEARCH 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25625,7 +26612,7 @@ fi ac_fn_c_check_func "$LINENO" "getcwd" "ac_cv_func_getcwd" if test "x$ac_cv_func_getcwd" = xyes then : - printf "%s\n" "#define HAVE_GETCWD 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETCWD 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25639,7 +26626,7 @@ fi ac_fn_c_check_func "$LINENO" "getenv" "ac_cv_func_getenv" if test "x$ac_cv_func_getenv" = xyes then : - printf "%s\n" "#define HAVE_GETENV 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETENV 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25653,7 +26640,7 @@ fi ac_fn_c_check_func "$LINENO" "getopt" "ac_cv_func_getopt" if test "x$ac_cv_func_getopt" = xyes then : - printf "%s\n" "#define HAVE_GETOPT 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETOPT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25667,7 +26654,7 @@ fi ac_fn_c_check_func "$LINENO" "isalpha" "ac_cv_func_isalpha" if test "x$ac_cv_func_isalpha" = xyes then : - printf "%s\n" "#define HAVE_ISALPHA 1" >>confdefs.h + printf '%s\n' "#define HAVE_ISALPHA 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25681,7 +26668,7 @@ fi ac_fn_c_check_func "$LINENO" "isdigit" "ac_cv_func_isdigit" if test "x$ac_cv_func_isdigit" = xyes then : - printf "%s\n" "#define HAVE_ISDIGIT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ISDIGIT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25695,7 +26682,7 @@ fi ac_fn_c_check_func "$LINENO" "isprint" "ac_cv_func_isprint" if test "x$ac_cv_func_isprint" = xyes then : - printf "%s\n" "#define HAVE_ISPRINT 1" >>confdefs.h + printf '%s\n' "#define HAVE_ISPRINT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25709,7 +26696,7 @@ fi ac_fn_c_check_func "$LINENO" "isspace" "ac_cv_func_isspace" if test "x$ac_cv_func_isspace" = xyes then : - printf "%s\n" "#define HAVE_ISSPACE 1" >>confdefs.h + printf '%s\n' "#define HAVE_ISSPACE 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25723,7 +26710,7 @@ fi ac_fn_c_check_func "$LINENO" "memcmp" "ac_cv_func_memcmp" if test "x$ac_cv_func_memcmp" = xyes then : - printf "%s\n" "#define HAVE_MEMCMP 1" >>confdefs.h + printf '%s\n' "#define HAVE_MEMCMP 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25737,7 +26724,7 @@ fi ac_fn_c_check_func "$LINENO" "memcpy" "ac_cv_func_memcpy" if test "x$ac_cv_func_memcpy" = xyes then : - printf "%s\n" "#define HAVE_MEMCPY 1" >>confdefs.h + printf '%s\n' "#define HAVE_MEMCPY 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25751,7 +26738,7 @@ fi ac_fn_c_check_func "$LINENO" "memmove" "ac_cv_func_memmove" if test "x$ac_cv_func_memmove" = xyes then : - printf "%s\n" "#define HAVE_MEMMOVE 1" >>confdefs.h + printf '%s\n' "#define HAVE_MEMMOVE 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25765,7 +26752,7 @@ fi ac_fn_c_check_func "$LINENO" "printf" "ac_cv_func_printf" if test "x$ac_cv_func_printf" = xyes then : - printf "%s\n" "#define HAVE_PRINTF 1" >>confdefs.h + printf '%s\n' "#define HAVE_PRINTF 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25779,7 +26766,7 @@ fi ac_fn_c_check_func "$LINENO" "qsort" "ac_cv_func_qsort" if test "x$ac_cv_func_qsort" = xyes then : - printf "%s\n" "#define HAVE_QSORT 1" >>confdefs.h + printf '%s\n' "#define HAVE_QSORT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25793,7 +26780,7 @@ fi ac_fn_c_check_func "$LINENO" "raise" "ac_cv_func_raise" if test "x$ac_cv_func_raise" = xyes then : - printf "%s\n" "#define HAVE_RAISE 1" >>confdefs.h + printf '%s\n' "#define HAVE_RAISE 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25807,7 +26794,7 @@ fi ac_fn_c_check_func "$LINENO" "rand" "ac_cv_func_rand" if test "x$ac_cv_func_rand" = xyes then : - printf "%s\n" "#define HAVE_RAND 1" >>confdefs.h + printf '%s\n' "#define HAVE_RAND 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25821,7 +26808,7 @@ fi ac_fn_c_check_func "$LINENO" "strcasecmp" "ac_cv_func_strcasecmp" if test "x$ac_cv_func_strcasecmp" = xyes then : - printf "%s\n" "#define HAVE_STRCASECMP 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRCASECMP 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25835,7 +26822,7 @@ fi ac_fn_c_check_func "$LINENO" "strcat" "ac_cv_func_strcat" if test "x$ac_cv_func_strcat" = xyes then : - printf "%s\n" "#define HAVE_STRCAT 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRCAT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25849,7 +26836,7 @@ fi ac_fn_c_check_func "$LINENO" "strchr" "ac_cv_func_strchr" if test "x$ac_cv_func_strchr" = xyes then : - printf "%s\n" "#define HAVE_STRCHR 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRCHR 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25863,7 +26850,7 @@ fi ac_fn_c_check_func "$LINENO" "strdup" "ac_cv_func_strdup" if test "x$ac_cv_func_strdup" = xyes then : - printf "%s\n" "#define HAVE_STRDUP 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRDUP 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25877,7 +26864,7 @@ fi ac_fn_c_check_func "$LINENO" "strerror" "ac_cv_func_strerror" if test "x$ac_cv_func_strerror" = xyes then : - printf "%s\n" "#define HAVE_STRERROR 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRERROR 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25891,7 +26878,7 @@ fi ac_fn_c_check_func "$LINENO" "strncat" "ac_cv_func_strncat" if test "x$ac_cv_func_strncat" = xyes then : - printf "%s\n" "#define HAVE_STRNCAT 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRNCAT 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25905,7 +26892,7 @@ fi ac_fn_c_check_func "$LINENO" "strncmp" "ac_cv_func_strncmp" if test "x$ac_cv_func_strncmp" = xyes then : - printf "%s\n" "#define HAVE_STRNCMP 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRNCMP 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25919,7 +26906,7 @@ fi ac_fn_c_check_func "$LINENO" "strrchr" "ac_cv_func_strrchr" if test "x$ac_cv_func_strrchr" = xyes then : - printf "%s\n" "#define HAVE_STRRCHR 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRRCHR 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25933,7 +26920,7 @@ fi ac_fn_c_check_func "$LINENO" "strsep" "ac_cv_func_strsep" if test "x$ac_cv_func_strsep" = xyes then : - printf "%s\n" "#define HAVE_STRSEP 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRSEP 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25947,7 +26934,7 @@ fi ac_fn_c_check_func "$LINENO" "strtol" "ac_cv_func_strtol" if test "x$ac_cv_func_strtol" = xyes then : - printf "%s\n" "#define HAVE_STRTOL 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRTOL 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25961,7 +26948,7 @@ fi ac_fn_c_check_func "$LINENO" "strtoul" "ac_cv_func_strtoul" if test "x$ac_cv_func_strtoul" = xyes then : - printf "%s\n" "#define HAVE_STRTOUL 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRTOUL 1" >>confdefs.h else case e in #( e) case " $LIBOBJS " in @@ -25978,187 +26965,187 @@ fi ac_fn_c_check_func "$LINENO" "_fstati64" "ac_cv_func__fstati64" if test "x$ac_cv_func__fstati64" = xyes then : - printf "%s\n" "#define HAVE__FSTATI64 1" >>confdefs.h + printf '%s\n' "#define HAVE__FSTATI64 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "backtrace" "ac_cv_func_backtrace" if test "x$ac_cv_func_backtrace" = xyes then : - printf "%s\n" "#define HAVE_BACKTRACE 1" >>confdefs.h + printf '%s\n' "#define HAVE_BACKTRACE 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "backtrace_symbols" "ac_cv_func_backtrace_symbols" if test "x$ac_cv_func_backtrace_symbols" = xyes then : - printf "%s\n" "#define HAVE_BACKTRACE_SYMBOLS 1" >>confdefs.h + printf '%s\n' "#define HAVE_BACKTRACE_SYMBOLS 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "directio" "ac_cv_func_directio" if test "x$ac_cv_func_directio" = xyes then : - printf "%s\n" "#define HAVE_DIRECTIO 1" >>confdefs.h + printf '%s\n' "#define HAVE_DIRECTIO 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fchmod" "ac_cv_func_fchmod" if test "x$ac_cv_func_fchmod" = xyes then : - printf "%s\n" "#define HAVE_FCHMOD 1" >>confdefs.h + printf '%s\n' "#define HAVE_FCHMOD 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fclose" "ac_cv_func_fclose" if test "x$ac_cv_func_fclose" = xyes then : - printf "%s\n" "#define HAVE_FCLOSE 1" >>confdefs.h + printf '%s\n' "#define HAVE_FCLOSE 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fcntl" "ac_cv_func_fcntl" if test "x$ac_cv_func_fcntl" = xyes then : - printf "%s\n" "#define HAVE_FCNTL 1" >>confdefs.h + printf '%s\n' "#define HAVE_FCNTL 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fdatasync" "ac_cv_func_fdatasync" if test "x$ac_cv_func_fdatasync" = xyes then : - printf "%s\n" "#define HAVE_FDATASYNC 1" >>confdefs.h + printf '%s\n' "#define HAVE_FDATASYNC 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fgetc" "ac_cv_func_fgetc" if test "x$ac_cv_func_fgetc" = xyes then : - printf "%s\n" "#define HAVE_FGETC 1" >>confdefs.h + printf '%s\n' "#define HAVE_FGETC 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fgets" "ac_cv_func_fgets" if test "x$ac_cv_func_fgets" = xyes then : - printf "%s\n" "#define HAVE_FGETS 1" >>confdefs.h + printf '%s\n' "#define HAVE_FGETS 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fopen" "ac_cv_func_fopen" if test "x$ac_cv_func_fopen" = xyes then : - printf "%s\n" "#define HAVE_FOPEN 1" >>confdefs.h + printf '%s\n' "#define HAVE_FOPEN 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "fwrite" "ac_cv_func_fwrite" if test "x$ac_cv_func_fwrite" = xyes then : - printf "%s\n" "#define HAVE_FWRITE 1" >>confdefs.h + printf '%s\n' "#define HAVE_FWRITE 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "getgid" "ac_cv_func_getgid" if test "x$ac_cv_func_getgid" = xyes then : - printf "%s\n" "#define HAVE_GETGID 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETGID 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "getrusage" "ac_cv_func_getrusage" if test "x$ac_cv_func_getrusage" = xyes then : - printf "%s\n" "#define HAVE_GETRUSAGE 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETRUSAGE 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "getuid" "ac_cv_func_getuid" if test "x$ac_cv_func_getuid" = xyes then : - printf "%s\n" "#define HAVE_GETUID 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETUID 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "hstrerror" "ac_cv_func_hstrerror" if test "x$ac_cv_func_hstrerror" = xyes then : - printf "%s\n" "#define HAVE_HSTRERROR 1" >>confdefs.h + printf '%s\n' "#define HAVE_HSTRERROR 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "mprotect" "ac_cv_func_mprotect" if test "x$ac_cv_func_mprotect" = xyes then : - printf "%s\n" "#define HAVE_MPROTECT 1" >>confdefs.h + printf '%s\n' "#define HAVE_MPROTECT 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "pstat_getdynamic" "ac_cv_func_pstat_getdynamic" if test "x$ac_cv_func_pstat_getdynamic" = xyes then : - printf "%s\n" "#define HAVE_PSTAT_GETDYNAMIC 1" >>confdefs.h + printf '%s\n' "#define HAVE_PSTAT_GETDYNAMIC 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "pthread_self" "ac_cv_func_pthread_self" if test "x$ac_cv_func_pthread_self" = xyes then : - printf "%s\n" "#define HAVE_PTHREAD_SELF 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_SELF 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "pthread_yield" "ac_cv_func_pthread_yield" if test "x$ac_cv_func_pthread_yield" = xyes then : - printf "%s\n" "#define HAVE_PTHREAD_YIELD 1" >>confdefs.h + printf '%s\n' "#define HAVE_PTHREAD_YIELD 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "random" "ac_cv_func_random" if test "x$ac_cv_func_random" = xyes then : - printf "%s\n" "#define HAVE_RANDOM 1" >>confdefs.h + printf '%s\n' "#define HAVE_RANDOM 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "sched_yield" "ac_cv_func_sched_yield" if test "x$ac_cv_func_sched_yield" = xyes then : - printf "%s\n" "#define HAVE_SCHED_YIELD 1" >>confdefs.h + printf '%s\n' "#define HAVE_SCHED_YIELD 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "select" "ac_cv_func_select" if test "x$ac_cv_func_select" = xyes then : - printf "%s\n" "#define HAVE_SELECT 1" >>confdefs.h + printf '%s\n' "#define HAVE_SELECT 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "setgid" "ac_cv_func_setgid" if test "x$ac_cv_func_setgid" = xyes then : - printf "%s\n" "#define HAVE_SETGID 1" >>confdefs.h + printf '%s\n' "#define HAVE_SETGID 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "setuid" "ac_cv_func_setuid" if test "x$ac_cv_func_setuid" = xyes then : - printf "%s\n" "#define HAVE_SETUID 1" >>confdefs.h + printf '%s\n' "#define HAVE_SETUID 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "sigaction" "ac_cv_func_sigaction" if test "x$ac_cv_func_sigaction" = xyes then : - printf "%s\n" "#define HAVE_SIGACTION 1" >>confdefs.h + printf '%s\n' "#define HAVE_SIGACTION 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "snprintf" "ac_cv_func_snprintf" if test "x$ac_cv_func_snprintf" = xyes then : - printf "%s\n" "#define HAVE_SNPRINTF 1" >>confdefs.h + printf '%s\n' "#define HAVE_SNPRINTF 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "stat" "ac_cv_func_stat" if test "x$ac_cv_func_stat" = xyes then : - printf "%s\n" "#define HAVE_STAT 1" >>confdefs.h + printf '%s\n' "#define HAVE_STAT 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "sysconf" "ac_cv_func_sysconf" if test "x$ac_cv_func_sysconf" = xyes then : - printf "%s\n" "#define HAVE_SYSCONF 1" >>confdefs.h + printf '%s\n' "#define HAVE_SYSCONF 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "vsnprintf" "ac_cv_func_vsnprintf" if test "x$ac_cv_func_vsnprintf" = xyes then : - printf "%s\n" "#define HAVE_VSNPRINTF 1" >>confdefs.h + printf '%s\n' "#define HAVE_VSNPRINTF 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "yield" "ac_cv_func_yield" if test "x$ac_cv_func_yield" = xyes then : - printf "%s\n" "#define HAVE_YIELD 1" >>confdefs.h + printf '%s\n' "#define HAVE_YIELD 1" >>confdefs.h fi @@ -26168,25 +27155,25 @@ fi ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday" if test "x$ac_cv_func_gettimeofday" = xyes then : - printf "%s\n" "#define HAVE_GETTIMEOFDAY 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETTIMEOFDAY 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "localtime" "ac_cv_func_localtime" if test "x$ac_cv_func_localtime" = xyes then : - printf "%s\n" "#define HAVE_LOCALTIME 1" >>confdefs.h + printf '%s\n' "#define HAVE_LOCALTIME 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "time" "ac_cv_func_time" if test "x$ac_cv_func_time" = xyes then : - printf "%s\n" "#define HAVE_TIME 1" >>confdefs.h + printf '%s\n' "#define HAVE_TIME 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "strftime" "ac_cv_func_strftime" if test "x$ac_cv_func_strftime" = xyes then : - printf "%s\n" "#define HAVE_STRFTIME 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRFTIME 1" >>confdefs.h fi @@ -26200,7 +27187,7 @@ aix4.3.*) ac_fn_c_check_func "$LINENO" "clock_gettime" "ac_cv_func_clock_gettime" if test "x$ac_cv_func_clock_gettime" = xyes then : - printf "%s\n" "#define HAVE_CLOCK_GETTIME 1" >>confdefs.h + printf '%s\n' "#define HAVE_CLOCK_GETTIME 1" >>confdefs.h fi ;; @@ -26210,7 +27197,7 @@ esac # Check to see if we can get a monotonic clock. We actually try and # run the program if possible, because we don't trust the #define's # existence to mean the clock really exists. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for clock_gettime monotonic clock" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for clock_gettime monotonic clock" >&5 printf %s "checking for clock_gettime monotonic clock... " >&6; } if test ${db_cv_clock_monotonic+y} then : @@ -26272,10 +27259,10 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_clock_monotonic" >&5 -printf "%s\n" "$db_cv_clock_monotonic" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_clock_monotonic" >&5 +printf '%s\n' "$db_cv_clock_monotonic" >&6; } if test "$db_cv_clock_monotonic" = "yes"; then - printf "%s\n" "#define HAVE_CLOCK_MONOTONIC 1" >>confdefs.h + printf '%s\n' "#define HAVE_CLOCK_MONOTONIC 1" >>confdefs.h fi @@ -26289,12 +27276,12 @@ fi ac_fn_c_check_func "$LINENO" "ctime_r" "ac_cv_func_ctime_r" if test "x$ac_cv_func_ctime_r" = xyes then : - printf "%s\n" "#define HAVE_CTIME_R 1" >>confdefs.h + printf '%s\n' "#define HAVE_CTIME_R 1" >>confdefs.h fi if test "$ac_cv_func_ctime_r" = "yes"; then -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 2 or 3 argument version of ctime_r" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for 2 or 3 argument version of ctime_r" >&5 printf %s "checking for 2 or 3 argument version of ctime_r... " >&6; } if test ${db_cv_ctime_r_3arg+y} then : @@ -26326,11 +27313,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_ctime_r_3arg" >&5 -printf "%s\n" "$db_cv_ctime_r_3arg" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_ctime_r_3arg" >&5 +printf '%s\n' "$db_cv_ctime_r_3arg" >&6; } fi if test "$db_cv_ctime_r_3arg" = "3-argument"; then - printf "%s\n" "#define HAVE_CTIME_R_3ARG 1" >>confdefs.h + printf '%s\n' "#define HAVE_CTIME_R_3ARG 1" >>confdefs.h fi @@ -26342,13 +27329,13 @@ fi # use ftruncate. case "$host_os" in osf*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: ftruncate ignored on $host_os-$host_vendor." >&5 -printf "%s\n" "$as_me: WARNING: ftruncate ignored on $host_os-$host_vendor." >&2;};; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: ftruncate ignored on $host_os-$host_vendor." >&5 +printf '%s\n' "$as_me: WARNING: ftruncate ignored on $host_os-$host_vendor." >&2;};; *) ac_fn_c_check_func "$LINENO" "ftruncate" "ac_cv_func_ftruncate" if test "x$ac_cv_func_ftruncate" = xyes then : - printf "%s\n" "#define HAVE_FTRUNCATE 1" >>confdefs.h + printf '%s\n' "#define HAVE_FTRUNCATE 1" >>confdefs.h fi ;; @@ -26359,19 +27346,19 @@ esac # NCR's version of System V R 4.3 has pread/pwrite symbols, but no support. case "$host_os-$host_vendor" in hpux*|sysv4.3*-ncr) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: pread/pwrite interfaces ignored on $host_os-$host_vendor." >&5 -printf "%s\n" "$as_me: WARNING: pread/pwrite interfaces ignored on $host_os-$host_vendor." >&2;};; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: pread/pwrite interfaces ignored on $host_os-$host_vendor." >&5 +printf '%s\n' "$as_me: WARNING: pread/pwrite interfaces ignored on $host_os-$host_vendor." >&2;};; *) ac_fn_c_check_func "$LINENO" "pread" "ac_cv_func_pread" if test "x$ac_cv_func_pread" = xyes then : - printf "%s\n" "#define HAVE_PREAD 1" >>confdefs.h + printf '%s\n' "#define HAVE_PREAD 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "pwrite" "ac_cv_func_pwrite" if test "x$ac_cv_func_pwrite" = xyes then : - printf "%s\n" "#define HAVE_PWRITE 1" >>confdefs.h + printf '%s\n' "#define HAVE_PWRITE 1" >>confdefs.h fi ;; @@ -26379,7 +27366,7 @@ esac # Check for getaddrinfo; do the test explicitly instead of using AC_CHECK_FUNCS # because isn't a standard include file. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for getaddrinfo" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for getaddrinfo" >&5 printf %s "checking for getaddrinfo... " >&6; } if test ${db_cv_getaddrinfo+y} then : @@ -26412,17 +27399,17 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_getaddrinfo" >&5 -printf "%s\n" "$db_cv_getaddrinfo" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_getaddrinfo" >&5 +printf '%s\n' "$db_cv_getaddrinfo" >&6; } if test "$db_cv_getaddrinfo" = "yes"; then - printf "%s\n" "#define HAVE_GETADDRINFO 1" >>confdefs.h + printf '%s\n' "#define HAVE_GETADDRINFO 1" >>confdefs.h fi # Check for the fcntl F_SETFD flag to deny child process access to file # descriptors. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fcntl/F_SETFD" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for fcntl/F_SETFD" >&5 printf %s "checking for fcntl/F_SETFD... " >&6; } if test ${db_cv_fcntl_f_setfd+y} then : @@ -26455,10 +27442,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_fcntl_f_setfd" >&5 -printf "%s\n" "$db_cv_fcntl_f_setfd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_fcntl_f_setfd" >&5 +printf '%s\n' "$db_cv_fcntl_f_setfd" >&6; } if test "$db_cv_fcntl_f_setfd" = "yes"; then - printf "%s\n" "#define HAVE_FCNTL_F_SETFD 1" >>confdefs.h + printf '%s\n' "#define HAVE_FCNTL_F_SETFD 1" >>confdefs.h fi @@ -26477,7 +27464,7 @@ esac # Linux and SGI require buffer alignment we may not match, otherwise writes # will fail. Default to not using the O_DIRECT flag. if test "$db_cv_o_direct" = "yes"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for open/O_DIRECT" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for open/O_DIRECT" >&5 printf %s "checking for open/O_DIRECT... " >&6; } if test ${db_cv_open_o_direct+y} then : @@ -26510,11 +27497,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_open_o_direct" >&5 -printf "%s\n" "$db_cv_open_o_direct" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_open_o_direct" >&5 +printf '%s\n' "$db_cv_open_o_direct" >&6; } if test \ "$db_cv_o_direct" = "yes" -a "$db_cv_open_o_direct" = "yes"; then - printf "%s\n" "#define HAVE_O_DIRECT 1" >>confdefs.h + printf '%s\n' "#define HAVE_O_DIRECT 1" >>confdefs.h fi @@ -26528,18 +27515,18 @@ then : fi if test "$enable_largefile,$enable_year2038" != no,no then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable large file support" >&5 -printf %s "checking for $CC option to enable large file support... " >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support large files" >&5 +printf %s "checking for $CC option to support large files... " >&6; } if test ${ac_cv_sys_largefile_opts+y} then : printf %s "(cached) " >&6 else case e in #( - e) ac_save_CC="$CC" + e) ac_save_CPPFLAGS=$CPPFLAGS ac_opt_found=no - for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1" "-n32"; do + for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1"; do if test x"$ac_opt" != x"none needed" then : - CC="$ac_save_CC $ac_opt" + CPPFLAGS="$ac_save_CPPFLAGS $ac_opt" fi cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -26568,12 +27555,12 @@ then : if test x"$ac_opt" = x"none needed" then : # GNU/Linux s390x and alpha need _FILE_OFFSET_BITS=64 for wide ino_t. - CC="$CC -DFTYPE=ino_t" + CPPFLAGS="$CPPFLAGS -DFTYPE=ino_t" if ac_fn_c_try_compile "$LINENO" then : else case e in #( - e) CC="$CC -D_FILE_OFFSET_BITS=64" + e) CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64" if ac_fn_c_try_compile "$LINENO" then : ac_opt='-D_FILE_OFFSET_BITS=64' @@ -26589,13 +27576,13 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext test $ac_opt_found = no || break done - CC="$ac_save_CC" + CPPFLAGS=$ac_save_CPPFLAGS test $ac_opt_found = yes || ac_cv_sys_largefile_opts="support not detected" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5 -printf "%s\n" "$ac_cv_sys_largefile_opts" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5 +printf '%s\n' "$ac_cv_sys_largefile_opts" >&6; } ac_have_largefile=yes case $ac_cv_sys_largefile_opts in #( @@ -26607,22 +27594,20 @@ case $ac_cv_sys_largefile_opts in #( ac_have_largefile=no ;; #( "-D_FILE_OFFSET_BITS=64") : -printf "%s\n" "#define _FILE_OFFSET_BITS 64" >>confdefs.h +printf '%s\n' "#define _FILE_OFFSET_BITS 64" >>confdefs.h ;; #( "-D_LARGE_FILES=1") : -printf "%s\n" "#define _LARGE_FILES 1" >>confdefs.h +printf '%s\n' "#define _LARGE_FILES 1" >>confdefs.h ;; #( - "-n32") : - CC="$CC -n32" ;; #( *) : as_fn_error $? "internal error: bad value for \$ac_cv_sys_largefile_opts" "$LINENO" 5 ;; esac if test "$enable_year2038" != no then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option for timestamps after 2038" >&5 -printf %s "checking for $CC option for timestamps after 2038... " >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support timestamps after 2038" >&5 +printf %s "checking for $CC option to support timestamps after 2038... " >&6; } if test ${ac_cv_sys_year2038_opts+y} then : printf %s "(cached) " >&6 @@ -26665,8 +27650,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext test $ac_opt_found = yes || ac_cv_sys_year2038_opts="support not detected" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5 -printf "%s\n" "$ac_cv_sys_year2038_opts" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5 +printf '%s\n' "$ac_cv_sys_year2038_opts" >&6; } ac_have_year2038=yes case $ac_cv_sys_year2038_opts in #( @@ -26676,15 +27661,15 @@ case $ac_cv_sys_year2038_opts in #( ac_have_year2038=no ;; #( "-D_TIME_BITS=64") : -printf "%s\n" "#define _TIME_BITS 64" >>confdefs.h +printf '%s\n' "#define _TIME_BITS 64" >>confdefs.h ;; #( "-D__MINGW_USE_VC2005_COMPAT") : -printf "%s\n" "#define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h +printf '%s\n' "#define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h ;; #( "-U_USE_32_BIT_TIME_T"*) : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "the 'time_t' type is currently forced to be 32-bit. It will stop working after mid-January 2038. Remove _USE_32BIT_TIME_T from the compiler flags. @@ -26711,18 +27696,18 @@ fi mmap_ok=no case "$host_os" in bsdi3*|bsdi4.0) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: mlock(2) interface ignored on $host_os-$host_vendor." >&5 -printf "%s\n" "$as_me: WARNING: mlock(2) interface ignored on $host_os-$host_vendor." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: mlock(2) interface ignored on $host_os-$host_vendor." >&5 +printf '%s\n' "$as_me: WARNING: mlock(2) interface ignored on $host_os-$host_vendor." >&2;} mmap_ok=yes for ac_func in mmap munmap do : - as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | sed "$as_sed_sh"` + as_ac_var=`printf '%s\n' "ac_cv_func_$ac_func" | sed "$as_sed_sh"` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes" then : cat >>confdefs.h <<_ACEOF -#define `printf "%s\n" "HAVE_$ac_func" | sed "$as_sed_cpp"` 1 +#define `printf '%s\n' "HAVE_$ac_func" | sed "$as_sed_cpp"` 1 _ACEOF else case e in #( @@ -26732,32 +27717,32 @@ fi done;; ultrix*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: mmap(2) interface ignored on $host_os-$host_vendor." >&5 -printf "%s\n" "$as_me: WARNING: mmap(2) interface ignored on $host_os-$host_vendor." >&2;};; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: mmap(2) interface ignored on $host_os-$host_vendor." >&5 +printf '%s\n' "$as_me: WARNING: mmap(2) interface ignored on $host_os-$host_vendor." >&2;};; *) mmap_ok=yes ac_fn_c_check_func "$LINENO" "mlock" "ac_cv_func_mlock" if test "x$ac_cv_func_mlock" = xyes then : - printf "%s\n" "#define HAVE_MLOCK 1" >>confdefs.h + printf '%s\n' "#define HAVE_MLOCK 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "munlock" "ac_cv_func_munlock" if test "x$ac_cv_func_munlock" = xyes then : - printf "%s\n" "#define HAVE_MUNLOCK 1" >>confdefs.h + printf '%s\n' "#define HAVE_MUNLOCK 1" >>confdefs.h fi for ac_func in mmap munmap do : - as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | sed "$as_sed_sh"` + as_ac_var=`printf '%s\n' "ac_cv_func_$ac_func" | sed "$as_sed_sh"` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes" then : cat >>confdefs.h <<_ACEOF -#define `printf "%s\n" "HAVE_$ac_func" | sed "$as_sed_cpp"` 1 +#define `printf '%s\n' "HAVE_$ac_func" | sed "$as_sed_cpp"` 1 _ACEOF else case e in #( @@ -26775,8 +27760,8 @@ esac shmget_ok=no case "$host_os" in sunos*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: shmget(2) interface ignored on $host_os-$host_vendor." >&5 -printf "%s\n" "$as_me: WARNING: shmget(2) interface ignored on $host_os-$host_vendor." >&2;};; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: shmget(2) interface ignored on $host_os-$host_vendor." >&5 +printf '%s\n' "$as_me: WARNING: shmget(2) interface ignored on $host_os-$host_vendor." >&2;};; *) shmget_ok=yes @@ -26785,7 +27770,7 @@ do : ac_fn_c_check_func "$LINENO" "shmget" "ac_cv_func_shmget" if test "x$ac_cv_func_shmget" = xyes then : - printf "%s\n" "#define HAVE_SHMGET 1" >>confdefs.h + printf '%s\n' "#define HAVE_SHMGET 1" >>confdefs.h else case e in #( e) shmget_ok=no ;; @@ -26795,7 +27780,7 @@ fi done # Check for shmctl to lock down shared memory segments. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shmctl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shmctl" >&5 printf %s "checking for shmctl... " >&6; } if test ${db_cv_shmctl_shm_lock+y} then : @@ -26830,10 +27815,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_shmctl_shm_lock" >&5 -printf "%s\n" "$db_cv_shmctl_shm_lock" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_shmctl_shm_lock" >&5 +printf '%s\n' "$db_cv_shmctl_shm_lock" >&6; } if test "$db_cv_shmctl_shm_lock" = "yes"; then - printf "%s\n" "#define HAVE_SHMCTL_SHM_LOCK 1" >>confdefs.h + printf '%s\n' "#define HAVE_SHMCTL_SHM_LOCK 1" >>confdefs.h fi;; @@ -26841,8 +27826,8 @@ esac # We require either mmap/munmap(2) or shmget(2). if test "$mmap_ok" = "no" -a "$shmget_ok" = "no"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Neither mmap/munmap(2) or shmget(2) library functions." >&5 -printf "%s\n" "$as_me: WARNING: Neither mmap/munmap(2) or shmget(2) library functions." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Neither mmap/munmap(2) or shmget(2) library functions." >&5 +printf '%s\n' "$as_me: WARNING: Neither mmap/munmap(2) or shmget(2) library functions." >&2;} fi # Optional Tcl support. @@ -26887,16 +27872,16 @@ fi fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for existence of $TCL_BIN_DIR/tclConfig.sh" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for existence of $TCL_BIN_DIR/tclConfig.sh" >&5 printf %s "checking for existence of $TCL_BIN_DIR/tclConfig.sh... " >&6; } if test -f "$TCL_BIN_DIR/tclConfig.sh" ; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: loading" >&5 -printf "%s\n" "loading" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: loading" >&5 +printf '%s\n' "loading" >&6; } . $TCL_BIN_DIR/tclConfig.sh else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: file not found" >&5 -printf "%s\n" "file not found" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: file not found" >&5 +printf '%s\n' "file not found" >&6; } fi # DB requires at least version 8.5. @@ -26947,7 +27932,7 @@ fi # Optional sequence code. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 64-bit integral type support for sequences" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for 64-bit integral type support for sequences" >&5 printf %s "checking for 64-bit integral type support for sequences... " >&6; } db_cv_build_sequence="yes" @@ -27075,15 +28060,15 @@ fi db_seq_decl="typedef $db_cv_seq_type db_seq_t;"; - printf "%s\n" "#define HAVE_64BIT_TYPES 1" >>confdefs.h + printf '%s\n' "#define HAVE_64BIT_TYPES 1" >>confdefs.h else # It still has to compile, but it won't run. db_seq_decl="typedef int db_seq_t;"; fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_build_sequence" >&5 -printf "%s\n" "$db_cv_build_sequence" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_build_sequence" >&5 +printf '%s\n' "$db_cv_build_sequence" >&6; } # Detect whether a large mmap() supports automatically extending the accessible @@ -27094,7 +28079,7 @@ printf "%s\n" "$db_cv_build_sequence" >&6; } if test "$mmap_ok" = "yes" ; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for growing a file under an mmap region" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for growing a file under an mmap region" >&5 printf %s "checking for growing a file under an mmap region... " >&6; } db_cv_mmap_extend="no" @@ -27214,11 +28199,11 @@ fi if test "$db_cv_mmap_extend" = yes; then - printf "%s\n" "#define HAVE_MMAP_EXTEND 1" >>confdefs.h + printf '%s\n' "#define HAVE_MMAP_EXTEND 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $db_cv_mmap_extend" >&5 -printf "%s\n" "$db_cv_mmap_extend" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $db_cv_mmap_extend" >&5 +printf '%s\n' "$db_cv_mmap_extend" >&6; } fi @@ -27236,7 +28221,7 @@ fi # Log checksums can be disabled to increase performance if test "$db_cv_log_checksum" = "yes"; then - printf "%s\n" "#define HAVE_LOG_CHECKSUM 1" >>confdefs.h + printf '%s\n' "#define HAVE_LOG_CHECKSUM 1" >>confdefs.h fi @@ -27249,21 +28234,21 @@ ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(BTREE_OBJS)" # Compression can be disabled. if test "$db_cv_build_compression" = "yes"; then - printf "%s\n" "#define HAVE_COMPRESSION 1" >>confdefs.h + printf '%s\n' "#define HAVE_COMPRESSION 1" >>confdefs.h fi # Partitioning can be disabled. if test "$db_cv_build_partition" = "yes"; then - printf "%s\n" "#define HAVE_PARTITION 1" >>confdefs.h + printf '%s\n' "#define HAVE_PARTITION 1" >>confdefs.h fi # Hash can be disabled. if test "$db_cv_build_hash" = "yes"; then - printf "%s\n" "#define HAVE_HASH 1" >>confdefs.h + printf '%s\n' "#define HAVE_HASH 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(HASH_OBJS)" @@ -27276,7 +28261,7 @@ fi # Heap can be disabled. if test "$db_cv_build_heap" = "yes"; then - printf "%s\n" "#define HAVE_HEAP 1" >>confdefs.h + printf '%s\n' "#define HAVE_HEAP 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(HEAP_OBJS)" @@ -27289,7 +28274,7 @@ fi # Queue can be disabled. if test "$db_cv_build_queue" = "yes"; then - printf "%s\n" "#define HAVE_QUEUE 1" >>confdefs.h + printf '%s\n' "#define HAVE_QUEUE 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(QUEUE_OBJS)" @@ -27302,7 +28287,7 @@ fi # Replication can be disabled. if test "$db_cv_build_replication" = "yes"; then - printf "%s\n" "#define HAVE_REPLICATION 1" >>confdefs.h + printf '%s\n' "#define HAVE_REPLICATION 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(REP_OBJS)" @@ -27312,12 +28297,12 @@ if test "$db_cv_build_replication" = "yes"; then if test "$ac_cv_header_pthread_h" = yes -a "$db_cv_mingw" != "yes"; then - printf "%s\n" "#define HAVE_REPLICATION_THREADS 1" >>confdefs.h + printf '%s\n' "#define HAVE_REPLICATION_THREADS 1" >>confdefs.h if test "$with_stacksize" != "no"; then -printf "%s\n" "#define DB_STACKSIZE $with_stacksize" >>confdefs.h +printf '%s\n' "#define DB_STACKSIZE $with_stacksize" >>confdefs.h fi @@ -27326,7 +28311,7 @@ printf "%s\n" "#define DB_STACKSIZE $with_stacksize" >>confdefs.h # it causes RPC to fail on AIX 4.3.3. case "$host_os" in solaris*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 printf %s "checking for gethostbyname in -lnsl... " >&6; } if test ${ac_cv_lib_nsl_gethostbyname+y} then : @@ -27367,14 +28352,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 -printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 +printf '%s\n' "$ac_cv_lib_nsl_gethostbyname" >&6; } if test "x$ac_cv_lib_nsl_gethostbyname" = xyes then : LIBSO_LIBS="$LIBSO_LIBS -lnsl" fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 printf %s "checking for socket in -lsocket... " >&6; } if test ${ac_cv_lib_socket_socket+y} then : @@ -27415,8 +28400,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 -printf "%s\n" "$ac_cv_lib_socket_socket" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 +printf '%s\n' "$ac_cv_lib_socket_socket" >&6; } if test "x$ac_cv_lib_socket_socket" = xyes then : LIBSO_LIBS="$LIBSO_LIBS -lsocket" @@ -27425,8 +28410,8 @@ fi esac ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(REPMGR_OBJS)" else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Replication manager is not supported." >&5 -printf "%s\n" "$as_me: WARNING: Replication manager is not supported." >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Replication manager is not supported." >&5 +printf '%s\n' "$as_me: WARNING: Replication manager is not supported." >&2;} ADDITIONAL_OBJS="$ADDITIONAL_OBJS repmgr_stub${o}" fi else @@ -27435,14 +28420,14 @@ fi # The statistics code can be disabled. if test "$db_cv_build_statistics" = "yes"; then - printf "%s\n" "#define HAVE_STATISTICS 1" >>confdefs.h + printf '%s\n' "#define HAVE_STATISTICS 1" >>confdefs.h fi # The verification code can be disabled. if test "$db_cv_build_verify" = "yes"; then - printf "%s\n" "#define HAVE_VERIFY 1" >>confdefs.h + printf '%s\n' "#define HAVE_VERIFY 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS \$(BTREE_VRFY_OBJS) \$(LOG_VRFY_OBJS)" @@ -27452,7 +28437,7 @@ fi # The crypto code can be disabled. if test -d "$topdir/src/crypto" -a "$db_cv_build_cryptography" != "no"; then - printf "%s\n" "#define HAVE_CRYPTO 1" >>confdefs.h + printf '%s\n' "#define HAVE_CRYPTO 1" >>confdefs.h @@ -27470,7 +28455,7 @@ in the configured include path." "$LINENO" 5 ;; esac fi - printf "%s\n" "#define HAVE_CRYPTO_IPP 1" >>confdefs.h + printf '%s\n' "#define HAVE_CRYPTO_IPP 1" >>confdefs.h fi @@ -27508,7 +28493,7 @@ fi # The DBM API can be disabled. if test "$db_cv_dbm" = "yes"; then - printf "%s\n" "#define HAVE_DBM 1" >>confdefs.h + printf '%s\n' "#define HAVE_DBM 1" >>confdefs.h ADDITIONAL_OBJS="$ADDITIONAL_OBJS dbm${o} hsearch${o}" @@ -27516,14 +28501,14 @@ fi # The output and error messages can be stripped. if test "$db_cv_stripped_messages" = "yes"; then - printf "%s\n" "#define HAVE_STRIPPED_MESSAGES 1" >>confdefs.h + printf '%s\n' "#define HAVE_STRIPPED_MESSAGES 1" >>confdefs.h fi # The output and error messages can be localized. if test "$db_cv_localization" = "yes"; then - printf "%s\n" "#define HAVE_LOCALIZATION 1" >>confdefs.h + printf '%s\n' "#define HAVE_LOCALIZATION 1" >>confdefs.h fi @@ -27614,44 +28599,7 @@ cat >confcache <<\_ACEOF _ACEOF -# The following way of writing the cache mishandles newlines in values, -# but we know of no workaround that is simple, portable, and efficient. -# So, we kill variables containing newlines. -# Ultrix sh set writes to stderr and can't be redirected directly, -# and sets the high bit in the cache file unless we assign to the vars. -( - for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( - *) { eval $ac_var=; unset $ac_var;} ;; - esac ;; - esac - done - - (set) 2>&1 | - case $as_nl`(ac_space=' '; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - # 'set' does not quote correctly, so add quotes: double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \. - sed -n \ - "s/'/'\\\\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" - ;; #( - *) - # 'set' quotes correctly as required by POSIX, so do not add quotes. - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) | +ac_cache_dump | sed ' /^ac_cv_env_/b end t clear @@ -27663,8 +28611,8 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 -printf "%s\n" "$as_me: updating cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +printf '%s\n' "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else @@ -27678,8 +28626,8 @@ printf "%s\n" "$as_me: updating cache $cache_file" >&6;} fi fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 -printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +printf '%s\n' "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache @@ -27696,7 +28644,7 @@ U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"` + ac_i=`printf '%s\n' "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" @@ -27715,13 +28663,21 @@ fi : "${CONFIG_STATUS=./config.status}" +case $CONFIG_STATUS in #( + -*) : + CONFIG_STATUS=./$CONFIG_STATUS ;; #( + */*) : + ;; #( + *) : + CONFIG_STATUS=./$CONFIG_STATUS ;; +esac + ac_write_fail=0 -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 -printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;} +ac_clean_CONFIG_STATUS='"$CONFIG_STATUS"' +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +printf '%s\n' "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 -cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +cat >"$CONFIG_STATUS" <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. @@ -27735,7 +28691,7 @@ ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF -cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## @@ -27747,7 +28703,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in #( @@ -27834,7 +28790,7 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi @@ -27850,9 +28806,9 @@ as_fn_error () as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - printf "%s\n" "$as_me: error: $2" >&2 + printf '%s\n' "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error @@ -27947,7 +28903,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X/"$0" | +printf '%s\n' X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -27969,29 +28925,6 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits - -# Determine whether it's possible to make 'echo' print without a newline. -# These variables are no longer used directly by Autoconf, but are AC_SUBSTed -# for compatibility with existing Makefiles. -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in #((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -# For backward compatibility with old third-party macros, we provide -# the shell variables $as_echo and $as_echo_n. New code should use -# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. -as_echo='printf %s\n' -as_echo_n='printf %s' - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -28033,7 +28966,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" @@ -28042,7 +28975,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_dir" | +printf '%s\n' X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -28095,19 +29028,19 @@ as_tr_sh="eval sed '$as_sed_sh'" # deprecated exec 6>&1 -## ----------------------------------- ## -## Main body of $CONFIG_STATUS script. ## -## ----------------------------------- ## +## ------------------------------------- ## +## Main body of "$CONFIG_STATUS" script. ## +## ------------------------------------- ## _ASEOF -test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 +test $as_write_fail = 0 && chmod +x "$CONFIG_STATUS" || ac_write_fail=1 -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by Berkeley DB $as_me 5.3.29, which was -generated by GNU Autoconf 2.72. Invocation command line was +generated by GNU Autoconf 2.73. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -28129,7 +29062,7 @@ case $ac_config_headers in *" esac -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" @@ -28137,7 +29070,7 @@ config_commands="$ac_config_commands" _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ '$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files @@ -28169,16 +29102,16 @@ $config_commands Report bugs to ." _ACEOF -ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"` -ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config=`printf '%s\n' "$ac_configure_args" | sed "$ac_safe_unquote"` +ac_cs_config_escaped=`printf '%s\n' "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ Berkeley DB config.status 5.3.29 -configured by $0, generated by GNU Autoconf 2.72, +configured by $0, generated by GNU Autoconf 2.73, with options \\"\$ac_cs_config\\" -Copyright (C) 2023 Free Software Foundation, Inc. +Copyright (C) 2026 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -28186,10 +29119,14 @@ ac_pwd='$ac_pwd' srcdir='$srcdir' INSTALL='$INSTALL' AWK='$AWK' -test -n "\$AWK" || AWK=awk +test -n "\$AWK" || { + awk '' >$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 @@ -28217,15 +29154,15 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - printf "%s\n" "$ac_cs_version"; exit ;; + printf '%s\n' "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) - printf "%s\n" "$ac_cs_config"; exit ;; + printf '%s\n' "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" @@ -28233,7 +29170,7 @@ do --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; @@ -28242,7 +29179,7 @@ do as_fn_error $? "ambiguous option: '$1' Try '$0 --help' for more information.";; --help | --hel | -h ) - printf "%s\n" "$ac_cs_usage"; exit ;; + printf '%s\n' "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; @@ -28266,29 +29203,29 @@ if $ac_cs_silent; then fi _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift - \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 + \printf '%s\n' "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX - printf "%s\n" "$ac_log" + printf '%s\n' "$ac_log" } >&5 _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # @@ -28672,7 +29609,7 @@ fi _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets @@ -28754,13 +29691,13 @@ _ACEOF echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 -ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim_num=`echo "$ac_subst_vars" | sed -n '$='` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 - ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | sed -n '$='` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then @@ -28771,7 +29708,7 @@ for ac_last_try in false false false false false :; do done rm -f conf$$subs.sh -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' @@ -28816,9 +29753,9 @@ t delim N s/\n// } -' >>$CONFIG_STATUS || ac_write_fail=1 +' >>"$CONFIG_STATUS" || ac_write_fail=1 rm -f conf$$subs.awk -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 @@ -28847,7 +29784,7 @@ cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && _ACAWK _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else @@ -28879,7 +29816,7 @@ s/^[^=]*=[ ]*$// }' fi -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. @@ -28950,9 +29887,9 @@ s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 +"/g' >>"$CONFIG_STATUS" || ac_write_fail=1 -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } @@ -28970,8 +29907,12 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { + suffix = P[macro] D[macro] + while (suffix ~ /[\t ]$/) { + suffix = substr(suffix, 1, length(suffix) - 1) + } # Preserve the white space surrounding the "#". - print prefix "define", macro P[macro] D[macro] + print prefix "define", macro suffix next } else { # Replace #undef with comments. This is necessary, for example, @@ -28986,7 +29927,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 { print } _ACAWK _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" @@ -29030,7 +29971,7 @@ do esac || as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;; esac - case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + case $ac_f in *\'*) ac_f=`printf '%s\n' "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done @@ -29038,17 +29979,17 @@ do # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` - printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + printf '%s\n' "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 -printf "%s\n" "$as_me: creating $ac_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +printf '%s\n' "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) - ac_sed_conf_input=`printf "%s\n" "$configure_input" | + ac_sed_conf_input=`printf '%s\n' "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac @@ -29065,7 +30006,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$ac_file" | +printf '%s\n' X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -29089,9 +30030,9 @@ printf "%s\n" X"$ac_file" | case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` + ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -29131,7 +30072,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix esac _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= @@ -29148,10 +30089,10 @@ ac_sed_dataroot=' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +printf '%s\n' "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g @@ -29165,11 +30106,11 @@ _ACEOF # Neutralize VPATH when '$srcdir' = '.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t @@ -29192,9 +30133,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&5 -printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' +printf '%s\n' "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" @@ -29210,27 +30151,27 @@ which seems to be undefined. Please make sure it is defined" >&2;} # if test x"$ac_file" != x-; then { - printf "%s\n" "/* $configure_input */" >&1 \ + printf '%s\n' "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 -printf "%s\n" "$as_me: $ac_file is unchanged" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +printf '%s\n' "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else - printf "%s\n" "/* $configure_input */" >&1 \ + printf '%s\n' "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; - :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 -printf "%s\n" "$as_me: executing $ac_file commands" >&6;} + :C) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +printf '%s\n' "$as_me: executing $ac_file commands" >&6;} ;; esac @@ -29872,8 +30813,8 @@ else fi if test x"$_lt_function_replace_fail" = x":"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 -printf "%s\n" "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +printf '%s\n' "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} fi @@ -30046,7 +30987,7 @@ done # for ac_tag as_fn_exit 0 _ACEOF -ac_clean_files=$ac_clean_files_save +ac_clean_CONFIG_STATUS= test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 @@ -30062,26 +31003,33 @@ test $ac_write_fail = 0 || # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: + case $CONFIG_STATUS in #( + -*) : + ac_no_opts=-- ;; #( + *) : + ac_no_opts= ;; +esac ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null - $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + $SHELL $ac_no_opts "$CONFIG_STATUS" $ac_config_status_args || + ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 -printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi if test "$db_cv_sql" = "yes"; then # This command runs the configure script from the SQL tree. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Configuring the SQL API" >&5 -printf "%s\n" "$as_me: Configuring the SQL API" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: Configuring the SQL API" >&5 +printf '%s\n' "$as_me: Configuring the SQL API" >&6;} # Setup the SQLite debug build. mkdir -p sql @@ -30098,11 +31046,11 @@ case `pwd` in *\ * | *\ *) if cygpath -d "$PWD" > /dev/null 2>&1 ; then cd `cygpath -d "$PWD"` - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Changing current directory to $PWD to hide whitespace from libtool" >&5 -printf "%s\n" "$as_me: WARNING: Changing current directory to $PWD to hide whitespace from libtool" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Changing current directory to $PWD to hide whitespace from libtool" >&5 +printf '%s\n' "$as_me: WARNING: Changing current directory to $PWD to hide whitespace from libtool" >&2;} else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Current bugs in libtool may prevent building the SQL API in \"$PWD\"; please use another working directory" >&5 -printf "%s\n" "$as_me: WARNING: Current bugs in libtool may prevent building the SQL API in \"$PWD\"; please use another working directory" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Current bugs in libtool may prevent building the SQL API in \"$PWD\"; please use another working directory" >&5 +printf '%s\n' "$as_me: WARNING: Current bugs in libtool may prevent building the SQL API in \"$PWD\"; please use another working directory" >&2;} fi ;; esac @@ -30149,7 +31097,7 @@ esac ;; *) case $ac_arg in - *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac ac_sub_configure_args="$ac_sub_configure_args '$ac_arg'" ;; esac @@ -30159,7 +31107,7 @@ esac # in subdir configurations. ac_arg="--prefix=$prefix" case $ac_arg in - *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args" diff --git a/dist/configure.ac b/dist/configure.ac index 92e5ce9e4..68f7ad48d 100644 --- a/dist/configure.ac +++ b/dist/configure.ac @@ -175,16 +175,37 @@ fi # Respect the environment LIBS settings LIBSO_LIBS="$LIBS" -# Asynchronous I/O backends for the buffer pool (os_aio). The Linux -# io_uring backend is used when liburing is available; the portable -# thread-pool offload is used everywhere pthreads exist. Both are -# optional -- without either, os_aio falls back to synchronous I/O. +# Asynchronous I/O backends for the buffer pool (os_aio), selected at +# runtime in preference order: io_uring (Linux) > IOCP (Windows) > +# kqueue+aio (BSD) > POSIX aio (Solaris/illumos, macOS) > thread-pool +# offload (last-resort fallback). All are optional -- without any, os_aio +# falls back to synchronous I/O. AC_CHECK_HEADER(liburing.h, [ AC_CHECK_LIB(uring, io_uring_queue_init, [ AC_DEFINE(HAVE_IO_URING, 1, [Define to 1 to use the Linux io_uring AIO backend.]) LIBSO_LIBS="$LIBSO_LIBS -luring" LIBS="$LIBS -luring"])]) + +# POSIX aio: aio_read/aio_write may live in libc (BSD/macOS) or librt +# (Solaris/illumos, glibc). Record the library so os_aio_posix links. +AC_CHECK_HEADER(aio.h, [ + AC_SEARCH_LIBS(aio_read, [rt aio], [ + AC_DEFINE(HAVE_AIO_POSIX, + 1, [Define to 1 to use the POSIX aio backend.])])]) + +# kqueue+aio (BSD, notably FreeBSD): needs EVFILT_AIO and, crucially, the +# sigev_notify_kqueue member of struct sigevent so a completed aiocb posts a +# kevent. macOS has EVFILT_AIO but lacks sigev_notify_kqueue, so it is +# excluded here and uses the POSIX aio backend instead. +AC_CHECK_MEMBER([struct sigevent.sigev_notify_kqueue], + [AC_CHECK_DECL([EVFILT_AIO], [ + AC_DEFINE(HAVE_AIO_KQUEUE, + 1, [Define to 1 to use the BSD kqueue+aio backend.])], + [], [[#include ]])], + [], [[#include +#include ]]) + AC_CHECK_HEADER(pthread.h, [ AC_DEFINE(HAVE_AIO_THREADPOOL, 1, [Define to 1 to use the thread-pool AIO offload backend.])]) @@ -265,8 +286,51 @@ CXXFLAGS=${CXXFLAGS-"$CFLAGS"} # The default compiler is cc (NOT gcc), the default CFLAGS is as specified # above, NOT what is set by AC_PROG_CC, as it won't set optimization flags # for any compiler other than gcc. +# +# Berkeley DB is written in K&R (old-style) C: function definitions name +# their parameters in a list following the parenthesis, with the prototype +# supplied separately via the __P() macro. C23 (gnu23) removed old-style +# definitions from the language, so a modern Autoconf (>= 2.72) AC_PROG_CC, +# which probes -std=gnu23 first and adopts it, turns every definition in the +# tree into a hard error. Suppress that probe by pre-seeding the C11/C23 +# feature-test cache variables to "no" so AC_PROG_CC adds no -std flag, then +# pin a K&R-compatible standard (gnu99) ourselves below. +ac_cv_prog_cc_c23=no +ac_cv_prog_cc_c11=no AC_PROG_CC(cc gcc) +# A modern Autoconf may still splice -std=gnu23 (or -std=c23) directly into +# $CC despite the cache pre-seeding above. Strip it so the K&R-incompatible +# standard cannot win, then pin gnu99 in CFLAGS below. +CC=`echo "$CC" | sed -e 's/ -std=gnu23//g' -e 's/ -std=c23//g'` + +# Pin a K&R-compatible C standard. gnu99 keeps old-style definitions legal +# (and retains the GNU extensions the tree relies on) under compilers that +# would otherwise default to C23. +case " $CFLAGS " in +*" -std="*) ;; # caller already chose a standard +*) CFLAGS="$CFLAGS -std=gnu99";; +esac + +# The tree is deliberately K&R. Even under gnu99, a sufficiently new clang +# still warns on every old-style definition (-Wdeprecated-non-prototype) and +# on sub-int K&R parameters whose default-argument promotion differs from the +# ANSI prototype (-Wknr-promoted-parameter). Both are inherent to the +# intentional K&R style, so silence exactly those two warnings where the +# compiler supports the flag. Keep all other warnings. +for db_knr_flag in -Wno-deprecated-non-prototype -Wno-knr-promoted-parameter; do + AS_VAR_PUSHDEF([db_knr_cv], [db_cv_cflag$db_knr_flag]) + AC_CACHE_CHECK([whether $CC accepts $db_knr_flag], [db_knr_cv], + [save_cflags="$CFLAGS" + CFLAGS="$CFLAGS $db_knr_flag -Werror" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], + [AS_VAR_SET([db_knr_cv], [yes])], + [AS_VAR_SET([db_knr_cv], [no])]) + CFLAGS="$save_cflags"]) + AS_VAR_IF([db_knr_cv], [yes], [CFLAGS="$CFLAGS $db_knr_flag"]) + AS_VAR_POPDEF([db_knr_cv]) +done + # We know what compiler we're going to use, now. Set per-compiler flags. if test "$GCC" = "yes"; then # Use -O3 if we're using gcc, unless we're doing a small build, in @@ -280,11 +344,6 @@ if test "$GCC" = "yes"; then else CFLAGS=`echo "$CFLAGS" | sed 's/-O /-O3 /g'` fi - - # Suppress K&R function declaration warnings for legacy codebase - # Berkeley DB has many K&R style function declarations that would - # require extensive refactoring to modernize to ANSI C prototypes - CFLAGS="$CFLAGS -Wno-deprecated-non-prototype" else case "$host_os" in hpux11.0*) ;; diff --git a/dist/srcfiles.in b/dist/srcfiles.in index 05db59607..48dbe770a 100644 --- a/dist/srcfiles.in +++ b/dist/srcfiles.in @@ -255,6 +255,8 @@ src/os/os_abs.c android src/os/os_addrinfo.c vx src/os/os_aio.c android vx vxsmall src/os/os_aio_uring.c android vx vxsmall +src/os/os_aio_posix.c android vx vxsmall +src/os/os_aio_kqueue.c android vx vxsmall src/os/os_aio_pool.c android vx vxsmall src/os/os_aio_iocp.c android vx vxsmall src/os/os_alloc.c android vx vxsmall diff --git a/src/dbinc/os_aio.h b/src/dbinc/os_aio.h index 09c51f92f..8abe017dc 100644 --- a/src/dbinc/os_aio.h +++ b/src/dbinc/os_aio.h @@ -90,6 +90,21 @@ int __os_aio_ctx_available __P((DB_AIO_CONTEXT *)); /* per-context async? */ */ int __os_aio_uring_init __P((ENV *, DB_AIO_CONTEXT *)); +/* + * PUBLIC: int __os_aio_posix_init __P((ENV *, DB_AIO_CONTEXT *)); + * Install the POSIX.1b aio backend (aio_read/aio_write + aio_suspend) on + * a context (HAVE_AIO_POSIX builds only). Native async path on + * Solaris/illumos and macOS; portable fallback ahead of the thread pool. + */ +int __os_aio_posix_init __P((ENV *, DB_AIO_CONTEXT *)); + +/* + * PUBLIC: int __os_aio_kqueue_init __P((ENV *, DB_AIO_CONTEXT *)); + * Install the BSD kqueue + aio backend (EVFILT_AIO completions) on a + * context (HAVE_AIO_KQUEUE builds only; FreeBSD/BSD, not macOS). + */ +int __os_aio_kqueue_init __P((ENV *, DB_AIO_CONTEXT *)); + /* * PUBLIC: int __os_aio_pool_init __P((ENV *, DB_AIO_CONTEXT *)); * Install the portable thread-pool offload backend (HAVE_AIO_THREADPOOL diff --git a/src/os/os_aio.c b/src/os/os_aio.c index 779249e6d..452746bcc 100644 --- a/src/os/os_aio.c +++ b/src/os/os_aio.c @@ -38,9 +38,10 @@ __os_aio_create(env, depth, ctxp) /* * Probe and install a platform backend in preference order; on * failure the context stays on the synchronous fallback - * (backend == NULL). io_uring (Linux) and IOCP (Windows) are - * native file-completion engines; the thread-pool offload is the - * portable async path everywhere else. + * (backend == NULL). Native file-completion engines first + * (io_uring on Linux, IOCP on Windows, kqueue+aio on BSD), then + * POSIX aio (Solaris/illumos, macOS), then the portable thread-pool + * offload as the last-resort async path. */ #ifdef HAVE_IO_URING if (ctx->backend == NULL) @@ -50,6 +51,14 @@ __os_aio_create(env, depth, ctxp) if (ctx->backend == NULL) (void)__os_aio_iocp_init(env, ctx); #endif +#ifdef HAVE_AIO_KQUEUE + if (ctx->backend == NULL) + (void)__os_aio_kqueue_init(env, ctx); +#endif +#ifdef HAVE_AIO_POSIX + if (ctx->backend == NULL) + (void)__os_aio_posix_init(env, ctx); +#endif #ifdef HAVE_AIO_THREADPOOL if (ctx->backend == NULL) (void)__os_aio_pool_init(env, ctx); diff --git a/src/os/os_aio_kqueue.c b/src/os/os_aio_kqueue.c new file mode 100644 index 000000000..45dffd57a --- /dev/null +++ b/src/os/os_aio_kqueue.c @@ -0,0 +1,268 @@ +/*- + * See the file LICENSE for redistribution information. + * + * BSD kqueue + POSIX aio backend for the os_aio abstraction. + * + * Submits page I/O with aio_read/aio_write whose aiocb requests a kqueue + * completion (sigev_notify == SIGEV_KEVENT, sigev_notify_kqueue == our kq); + * each finished op posts an EVFILT_AIO kevent whose udata is the op record, + * so reaping is a single kevent() call rather than polling every aiocb with + * aio_error. This is the native event-driven async path on FreeBSD (and + * other BSDs that provide sigev_notify_kqueue). + * + * macOS is intentionally NOT this backend: its lacks + * sigev_notify_kqueue and its historical SIGEV_KEVENT aio support is + * unreliable, so macOS uses the POSIX-aio backend (aio_suspend) instead. + * Selection is decided at configure time via HAVE_AIO_KQUEUE. + * + * Built only when configured with kqueue-aio support (HAVE_AIO_KQUEUE); + * otherwise this file is an empty translation unit and contexts use the + * synchronous fallback in os_aio.c. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +#ifdef HAVE_AIO_KQUEUE + +#include +#include +#include +#include +#include + +/* One in-flight op: control block plus the caller's completion info. */ +typedef struct __aio_kq_op { + struct aiocb cb; /* control block (kevent udata = this). */ + void *cookie; /* caller context (BH *). */ + db_aio_done_fn done; /* completion callback. */ + u_int32_t len; /* expected transfer length. */ + int op; /* DB_IO_READ / DB_IO_WRITE. */ + int active; /* slot in use. */ +} AIO_KQ_OP; + +typedef struct __aio_kq_state { + int kq; /* kqueue descriptor. */ + AIO_KQ_OP *ops; /* in-flight table, depth entries. */ + u_int32_t depth; /* table capacity. */ +} AIO_KQ_STATE; + +static int __aio_kq_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +static int __aio_kq_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); +static int __aio_kq_destroy __P((ENV *, DB_AIO_CONTEXT *)); + +static const DB_AIO_BACKEND __aio_kq_backend = { + "kqueue-aio", + __aio_kq_submit, + __aio_kq_reap, + NULL, /* cancel: unused */ + __aio_kq_destroy +}; + +/* + * __os_aio_kqueue_init -- + * Create a kqueue and attach the backend to the context. + * + * PUBLIC: int __os_aio_kqueue_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_kqueue_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_KQ_STATE *st; + int ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + st->depth = ctx->depth == 0 ? DB_AIO_DEFAULT_DEPTH : ctx->depth; + if ((st->kq = kqueue()) < 0) { + ret = __os_get_errno(); + __os_free(env, st); + return (ret); + } + if ((ret = __os_calloc(env, + st->depth, sizeof(AIO_KQ_OP), &st->ops)) != 0) { + (void)close(st->kq); + __os_free(env, st); + return (ret); + } + ctx->priv = st; + ctx->backend = &__aio_kq_backend; + return (0); +} + +/* + * __aio_kq_submit -- + * Fill a free slot's aiocb to post an EVFILT_AIO kevent on completion, + * then submit via aio_read/aio_write. DB_OPNOTSUP if the table is full + * or the kernel refuses the op (caller writes the page synchronously). + */ +static int +__aio_kq_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + AIO_KQ_STATE *st; + AIO_KQ_OP *slot; + u_int32_t i; + int r; + + st = ctx->priv; + for (slot = NULL, i = 0; i < st->depth; i++) + if (!st->ops[i].active) { + slot = &st->ops[i]; + break; + } + if (slot == NULL) + return (DB_OPNOTSUP); + + memset(&slot->cb, 0, sizeof(slot->cb)); + slot->cb.aio_fildes = aio->fhp->fd; + slot->cb.aio_buf = aio->buf; + slot->cb.aio_nbytes = aio->pagesize; + slot->cb.aio_offset = (off_t)aio->pgno * aio->pagesize; + slot->cb.aio_sigevent.sigev_notify = SIGEV_KEVENT; + slot->cb.aio_sigevent.sigev_notify_kqueue = st->kq; + slot->cb.aio_sigevent.sigev_value.sival_ptr = slot; + slot->cookie = aio->cookie; + slot->done = aio->done; + slot->len = aio->pagesize; + slot->op = aio->op; + + r = aio->op == DB_IO_WRITE ? + aio_write(&slot->cb) : aio_read(&slot->cb); + if (r != 0) + return (DB_OPNOTSUP); + + slot->active = 1; + ctx->inflight++; + return (0); +} + +/* + * __aio_kq_finish_slot -- + * Collect a completed slot's result, run its completion, free the slot. + */ +static void +__aio_kq_finish_slot(env, ctx, slot) + ENV *env; + DB_AIO_CONTEXT *ctx; + AIO_KQ_OP *slot; +{ + ssize_t n; + int err, io_ret; + + err = aio_error(&slot->cb); + if (err == 0) { + n = aio_return(&slot->cb); + io_ret = (n == (ssize_t)slot->len) ? 0 : EIO; + } else { + (void)aio_return(&slot->cb); + io_ret = err; + } + if (slot->done != NULL) + slot->done(env, slot->cookie, io_ret); + slot->active = 0; + if (ctx->inflight != 0) + ctx->inflight--; +} + +/* + * __aio_kq_reap -- + * Reap up to "max" completions (max < 0 means all ready). Drains + * EVFILT_AIO kevents; with "wait" set and ops outstanding, blocks in + * kevent until at least one completes. + */ +static int +__aio_kq_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + AIO_KQ_STATE *st; + struct kevent evs[64]; + struct timespec zero; + AIO_KQ_OP *slot; + int batch, got, i, n; + + st = ctx->priv; + got = 0; + zero.tv_sec = 0; + zero.tv_nsec = 0; + + for (;;) { + if (max >= 0 && got >= max) + break; + batch = (int)(sizeof(evs) / sizeof(evs[0])); + if (max >= 0 && (max - got) < batch) + batch = max - got; + + /* + * Block only when asked to wait, nothing has been reaped yet, + * and ops are still outstanding; otherwise poll (zero timeout). + */ + n = kevent(st->kq, NULL, 0, evs, batch, + (wait && got == 0 && ctx->inflight != 0) ? NULL : &zero); + if (n < 0) { + if (errno == EINTR) + continue; + break; + } + if (n == 0) + break; + for (i = 0; i < n; i++) { + slot = evs[i].udata; + if (slot == NULL || !slot->active) + continue; + __aio_kq_finish_slot(env, ctx, slot); + got++; + } + } + return (got); +} + +/* + * __aio_kq_destroy -- + * Drain all in-flight ops, close the kqueue, free state. + */ +static int +__aio_kq_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_KQ_STATE *st; + + if ((st = ctx->priv) == NULL) + return (0); + while (ctx->inflight != 0) + (void)__aio_kq_reap(env, ctx, -1, 1); + if (st->kq >= 0) + (void)close(st->kq); + __os_free(env, st->ops); + __os_free(env, st); + ctx->priv = NULL; + return (0); +} + +#else /* !HAVE_AIO_KQUEUE */ + +/* + * __os_aio_kqueue_init -- + * kqueue aio not configured. + * + * PUBLIC: int __os_aio_kqueue_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_kqueue_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + COMPQUIET(env, NULL); + COMPQUIET(ctx, NULL); + return (DB_OPNOTSUP); +} + +#endif /* HAVE_AIO_KQUEUE */ diff --git a/src/os/os_aio_pool.c b/src/os/os_aio_pool.c index 805298e36..ec20ca880 100644 --- a/src/os/os_aio_pool.c +++ b/src/os/os_aio_pool.c @@ -45,6 +45,8 @@ typedef struct __aio_work { typedef struct __aio_pool_state { pthread_cond_t done_cv; /* reap waits here */ AIO_WORK *cmp_head, *cmp_tail; /* this context's completions */ + DB_AIO_CONTEXT *ctx; /* owning context (inflight) */ + struct __aio_pool_state *reg_next; /* live-context registry link */ } AIO_POOL_STATE; /* @@ -58,6 +60,7 @@ static AIO_WORK *g_sub_head, *g_sub_tail; static pthread_t g_threads[AIO_POOL_THREADS]; static int g_nthreads, g_started, g_stopping; static pthread_once_t g_atfork_once = PTHREAD_ONCE_INIT; +static AIO_POOL_STATE *g_ctx_registry; /* all live contexts (g_lock). */ static AIO_WORK * __aio_q_pop(head, tail) @@ -131,11 +134,25 @@ __aio_atfork_parent() static void __aio_atfork_child() { + AIO_POOL_STATE *st; + /* * The worker threads did not survive the fork. Reset the pool to * unstarted (re-init the lock we held across the fork, drop inherited * submissions) so the child re-spawns lazily on its next submit and * never blocks on a pool mutex no live thread will release. + * + * The inherited submission/completion AIO_WORK nodes belonged to the + * parent's in-flight writes; in the child those I/Os will never run + * (no workers) and must NOT be completed here -- running a write + * completion would clear BH_DIRTY and drop a buffer pin for I/O the + * child never performed, corrupting the inherited (copy-on-write) + * buffer state. We therefore discard them and zero every live + * context's in-flight accounting so a subsequent reap does not block + * forever waiting on completions that can never arrive. The pinned + * buffers remain pinned in the child's address space, which is the + * conservative, safe outcome (they are simply never written by the + * child); the parent completes its own writes normally. */ (void)pthread_mutex_init(&g_lock, NULL); (void)pthread_cond_init(&g_work_cv, NULL); @@ -143,6 +160,13 @@ __aio_atfork_child() g_nthreads = 0; g_started = 0; g_stopping = 0; + + for (st = g_ctx_registry; st != NULL; st = st->reg_next) { + (void)pthread_cond_init(&st->done_cv, NULL); + st->cmp_head = st->cmp_tail = NULL; + if (st->ctx != NULL) + st->ctx->inflight = 0; + } } static void @@ -194,6 +218,7 @@ __aio_pool_submit(env, ctx, aio) w->owner = st; (void)pthread_mutex_lock(&g_lock); + st->ctx = ctx; /* for the atfork-child inflight reset */ if (__aio_pool_start_locked() != 0) { (void)pthread_mutex_unlock(&g_lock); __os_free(env, w); @@ -262,6 +287,17 @@ __aio_pool_destroy(env, ctx) (void)pthread_mutex_lock(&g_lock); while ((w = __aio_q_pop(&st->cmp_head, &st->cmp_tail)) != NULL) __os_free(env, w); + /* Unlink from the live-context registry. */ + if (g_ctx_registry == st) + g_ctx_registry = st->reg_next; + else { + AIO_POOL_STATE *p; + for (p = g_ctx_registry; p != NULL; p = p->reg_next) + if (p->reg_next == st) { + p->reg_next = st->reg_next; + break; + } + } (void)pthread_mutex_unlock(&g_lock); (void)pthread_cond_destroy(&st->done_cv); @@ -299,6 +335,13 @@ __os_aio_pool_init(env, ctx) __os_free(env, st); return (DB_OPNOTSUP); } + st->ctx = ctx; + /* Register so the atfork-child handler can reset our in-flight state. */ + (void)pthread_once(&g_atfork_once, __aio_install_atfork); + (void)pthread_mutex_lock(&g_lock); + st->reg_next = g_ctx_registry; + g_ctx_registry = st; + (void)pthread_mutex_unlock(&g_lock); ctx->priv = st; ctx->backend = &__aio_pool_backend; return (0); diff --git a/src/os/os_aio_posix.c b/src/os/os_aio_posix.c new file mode 100644 index 000000000..55e9b679b --- /dev/null +++ b/src/os/os_aio_posix.c @@ -0,0 +1,266 @@ +/*- + * See the file LICENSE for redistribution information. + * + * POSIX.1b asynchronous I/O backend for the os_aio abstraction. + * + * Uses the standard facility: aio_read/aio_write to submit and + * aio_suspend + aio_error/aio_return to reap. This is the native async + * path on systems that provide a working POSIX aio implementation but no + * other completion engine -- notably Solaris/illumos (libaio) -- and a + * portable fallback ahead of the thread pool elsewhere. + * + * Per-context state holds a fixed table of in-flight slots (ctx->depth + * entries); a submit that finds the table full reports DB_OPNOTSUP so the + * caller writes that one page synchronously, exactly as it would when no + * async backend is configured. The buffer-pool writeback path never has + * more than MEMP_AIO_WINDOW writes outstanding, so a reasonable depth keeps + * the table from filling in practice. + * + * Built only when configured with POSIX aio support (HAVE_AIO_POSIX); + * otherwise this file is an empty translation unit and contexts use the + * synchronous fallback in os_aio.c. + */ +#include "db_config.h" + +#include "db_int.h" +#include "dbinc/os_aio.h" + +#ifdef HAVE_AIO_POSIX + +#include +#include + +/* One in-flight op: its control block plus the caller's completion info. */ +typedef struct __aio_posix_op { + struct aiocb cb; /* kernel/library control block. */ + void *cookie; /* caller context (BH *). */ + db_aio_done_fn done; /* completion callback. */ + u_int32_t len; /* expected transfer length. */ + int op; /* DB_IO_READ / DB_IO_WRITE. */ + int active; /* slot in use. */ +} AIO_POSIX_OP; + +typedef struct __aio_posix_state { + AIO_POSIX_OP *ops; /* in-flight table, depth entries. */ + u_int32_t depth; /* table capacity. */ +} AIO_POSIX_STATE; + +static int __aio_posix_submit __P((ENV *, DB_AIO_CONTEXT *, DB_AIO_OP *)); +static int __aio_posix_reap __P((ENV *, DB_AIO_CONTEXT *, int, int)); +static int __aio_posix_destroy __P((ENV *, DB_AIO_CONTEXT *)); + +static const DB_AIO_BACKEND __aio_posix_backend = { + "posixaio", + __aio_posix_submit, + __aio_posix_reap, + NULL, /* cancel: unused */ + __aio_posix_destroy +}; + +/* + * __os_aio_posix_init -- + * Attach the POSIX aio backend to a context. + * + * PUBLIC: int __os_aio_posix_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_posix_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_POSIX_STATE *st; + int ret; + + if ((ret = __os_calloc(env, 1, sizeof(*st), &st)) != 0) + return (ret); + st->depth = ctx->depth == 0 ? DB_AIO_DEFAULT_DEPTH : ctx->depth; + if ((ret = __os_calloc(env, + st->depth, sizeof(AIO_POSIX_OP), &st->ops)) != 0) { + __os_free(env, st); + return (ret); + } + ctx->priv = st; + ctx->backend = &__aio_posix_backend; + return (0); +} + +/* + * __aio_posix_submit -- + * Find a free slot, fill its aiocb, and hand it to aio_read/aio_write. + * Returns DB_OPNOTSUP if the table is full (caller writes synchronously). + */ +static int +__aio_posix_submit(env, ctx, aio) + ENV *env; + DB_AIO_CONTEXT *ctx; + DB_AIO_OP *aio; +{ + AIO_POSIX_STATE *st; + AIO_POSIX_OP *slot; + u_int32_t i; + int r; + + st = ctx->priv; + for (slot = NULL, i = 0; i < st->depth; i++) + if (!st->ops[i].active) { + slot = &st->ops[i]; + break; + } + if (slot == NULL) + return (DB_OPNOTSUP); /* table full: caller does it inline. */ + + memset(&slot->cb, 0, sizeof(slot->cb)); + slot->cb.aio_fildes = aio->fhp->fd; + slot->cb.aio_buf = aio->buf; + slot->cb.aio_nbytes = aio->pagesize; + slot->cb.aio_offset = (off_t)aio->pgno * aio->pagesize; + slot->cb.aio_sigevent.sigev_notify = SIGEV_NONE; + slot->cookie = aio->cookie; + slot->done = aio->done; + slot->len = aio->pagesize; + slot->op = aio->op; + + r = aio->op == DB_IO_WRITE ? + aio_write(&slot->cb) : aio_read(&slot->cb); + if (r != 0) + return (DB_OPNOTSUP); /* submit refused: caller does it. */ + + slot->active = 1; + ctx->inflight++; + return (0); +} + +/* + * __aio_posix_finish_slot -- + * Collect one completed slot's result, run its completion, free the slot. + */ +static void +__aio_posix_finish_slot(env, ctx, slot, aio_err) + ENV *env; + DB_AIO_CONTEXT *ctx; + AIO_POSIX_OP *slot; + int aio_err; +{ + ssize_t n; + int io_ret; + + /* + * aio_error returns 0 on success, an errno on failure. On success + * aio_return yields the byte count and must be called exactly once to + * release the kernel/library resources; treat a short transfer as EIO. + */ + if (aio_err == 0) { + n = aio_return(&slot->cb); + io_ret = (n == (ssize_t)slot->len) ? 0 : EIO; + } else { + (void)aio_return(&slot->cb); + io_ret = aio_err; + } + if (slot->done != NULL) + slot->done(env, slot->cookie, io_ret); + slot->active = 0; + if (ctx->inflight != 0) + ctx->inflight--; +} + +/* + * __aio_posix_reap -- + * Reap up to "max" completions (max < 0 means all ready). When "wait" + * is set and nothing is ready, block in aio_suspend on the in-flight set. + */ +static int +__aio_posix_reap(env, ctx, max, wait) + ENV *env; + DB_AIO_CONTEXT *ctx; + int max, wait; +{ + AIO_POSIX_STATE *st; + const struct aiocb **list; + u_int32_t i; + int err, got, nlist; + + st = ctx->priv; + got = 0; + + for (;;) { + if (max >= 0 && got >= max) + break; + + /* Collect every still-active slot that has finished. */ + nlist = 0; + for (i = 0; i < st->depth; i++) { + if (!st->ops[i].active) + continue; + err = aio_error(&st->ops[i].cb); + if (err == EINPROGRESS) + continue; + __aio_posix_finish_slot(env, ctx, &st->ops[i], err); + if (++got >= max && max >= 0) + return (got); + } + + if (got > 0 || !wait || ctx->inflight == 0) + break; + + /* + * Nothing was ready but the caller asked to wait and ops are + * outstanding: build the in-flight aiocb list and block until + * at least one finishes, then loop to harvest it. + */ + if ((__os_malloc(env, + st->depth * sizeof(*list), &list)) != 0) + break; + for (nlist = 0, i = 0; i < st->depth; i++) + if (st->ops[i].active) + list[nlist++] = &st->ops[i].cb; + if (nlist == 0) { + __os_free(env, list); + break; + } + while (aio_suspend(list, nlist, NULL) != 0 && errno == EINTR) + ; + __os_free(env, list); + } + return (got); +} + +/* + * __aio_posix_destroy -- + * Drain all in-flight ops, then free the context state. + */ +static int +__aio_posix_destroy(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + AIO_POSIX_STATE *st; + + if ((st = ctx->priv) == NULL) + return (0); + while (ctx->inflight != 0) + (void)__aio_posix_reap(env, ctx, -1, 1); + __os_free(env, st->ops); + __os_free(env, st); + ctx->priv = NULL; + return (0); +} + +#else /* !HAVE_AIO_POSIX */ + +/* + * __os_aio_posix_init -- + * POSIX aio not configured. + * + * PUBLIC: int __os_aio_posix_init __P((ENV *, DB_AIO_CONTEXT *)); + */ +int +__os_aio_posix_init(env, ctx) + ENV *env; + DB_AIO_CONTEXT *ctx; +{ + COMPQUIET(env, NULL); + COMPQUIET(ctx, NULL); + return (DB_OPNOTSUP); +} + +#endif /* HAVE_AIO_POSIX */