1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey *
3 dnl Copyright 2010-2017,2018 Free Software Foundation, Inc. *
5 dnl Permission is hereby granted, free of charge, to any person obtaining a *
6 dnl copy of this software and associated documentation files (the *
7 dnl "Software"), to deal in the Software without restriction, including *
8 dnl without limitation the rights to use, copy, modify, merge, publish, *
9 dnl distribute, distribute with modifications, sublicense, and/or sell *
10 dnl copies of the Software, and to permit persons to whom the Software is *
11 dnl furnished to do so, subject to the following conditions: *
13 dnl The above copyright notice and this permission notice shall be included *
14 dnl in all copies or substantial portions of the Software. *
16 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
17 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
18 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
19 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
20 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
21 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
22 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
24 dnl Except as contained in this notice, the name(s) of the above copyright *
25 dnl holders shall not be used in advertising or otherwise to promote the *
26 dnl sale, use or other dealings in this Software without prior written *
28 dnl***************************************************************************
30 dnl Author: Thomas E. Dickey
32 dnl $Id: aclocal.m4,v 1.181 2021/09/04 10:47:55 tom Exp $
33 dnl Macros used in NCURSES Ada95 auto-configuration script.
35 dnl These macros are maintained separately from NCURSES. The copyright on
36 dnl this file applies to the aggregation of macros and does not affect use of
37 dnl these macros in other applications.
39 dnl See these pages for additional information:
40 dnl https://invisible-island.net/autoconf/
41 dnl https://invisible-island.net/autoconf/my-autoconf.html
43 dnl ---------------------------------------------------------------------------
44 dnl ---------------------------------------------------------------------------
45 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
46 dnl ------------------
47 dnl Conditionally generate script according to whether we're using a given autoconf.
49 dnl $1 = version to compare against
50 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
51 dnl $3 = code to use if AC_ACVERSION is older than $1.
52 define([CF_ACVERSION_CHECK],
54 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
55 ifdef([m4_version_compare],
56 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
57 [CF_ACVERSION_COMPARE(
58 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
59 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
60 dnl ---------------------------------------------------------------------------
61 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
62 dnl --------------------
63 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
64 dnl MAJOR2, MINOR2, TERNARY2,
65 dnl PRINTABLE2, not FOUND, FOUND)
66 define([CF_ACVERSION_COMPARE],
67 [ifelse(builtin([eval], [$2 < $5]), 1,
68 [ifelse([$8], , ,[$8])],
69 [ifelse([$9], , ,[$9])])])dnl
70 dnl ---------------------------------------------------------------------------
71 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
72 dnl -------------------
73 dnl Construct the list of include-options for the C programs in the Ada95
75 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
77 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
78 if test "$srcdir" != "."; then
79 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
81 if test "$GCC" != yes; then
82 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 elif test "$includedir" != "/usr/include"; then
84 if test "$includedir" = '${prefix}/include' ; then
85 if test x$prefix != x/usr ; then
86 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
89 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
94 dnl ---------------------------------------------------------------------------
95 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
97 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
98 AC_DEFUN([CF_ADD_ADAFLAGS],[
99 ADAFLAGS="$ADAFLAGS $1"
102 dnl ---------------------------------------------------------------------------
103 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
105 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
106 dnl $1 = flags to add
107 dnl $2 = if given makes this macro verbose.
109 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
110 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
111 dnl confused by the quotes (which require backslashes to keep them usable).
112 AC_DEFUN([CF_ADD_CFLAGS],
117 cf_new_extra_cppflags=
119 for cf_add_cflags in $1
121 case "$cf_fix_cppflags" in
123 case "$cf_add_cflags" in
124 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
125 case "$cf_add_cflags" in
127 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
129 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
130 && test -z "${cf_tst_cflags}" \
131 && cf_fix_cppflags=yes
133 if test "$cf_fix_cppflags" = yes ; then
134 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
136 elif test "${cf_tst_cflags}" = "\"'" ; then
137 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
146 case "$cf_add_cflags" in
148 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
149 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
152 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
157 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
162 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
164 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
166 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
167 && test -z "${cf_tst_cflags}" \
168 && cf_fix_cppflags=no
173 if test -n "$cf_new_cflags" ; then
174 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
175 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
178 if test -n "$cf_new_cppflags" ; then
179 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
180 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
183 if test -n "$cf_new_extra_cppflags" ; then
184 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
185 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
188 AC_SUBST(EXTRA_CPPFLAGS)
191 dnl ---------------------------------------------------------------------------
192 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
194 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it is
195 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
196 dnl but old versions (and some misinstalled ones) need that. To make things
197 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
198 dnl the include-path).
199 AC_DEFUN([CF_ADD_INCDIR],
201 if test -n "$1" ; then
202 for cf_add_incdir in $1
204 while test "$cf_add_incdir" != /usr/include
206 if test -d "$cf_add_incdir"
209 if test -n "$CFLAGS$CPPFLAGS" ; then
210 # a loop is needed to ensure we can add subdirs of existing dirs
211 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
212 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
213 cf_have_incdir=yes; break
218 if test "$cf_have_incdir" = no ; then
219 if test "$cf_add_incdir" = /usr/local/include ; then
222 cf_save_CPPFLAGS=$CPPFLAGS
223 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
224 AC_TRY_COMPILE([#include <stdio.h>],
227 [cf_have_incdir=yes])
228 CPPFLAGS=$cf_save_CPPFLAGS
233 if test "$cf_have_incdir" = no ; then
234 CF_VERBOSE(adding $cf_add_incdir to include-path)
235 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
237 cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
238 test "$cf_top_incdir" = "$cf_add_incdir" && break
239 cf_add_incdir="$cf_top_incdir"
250 dnl ---------------------------------------------------------------------------
251 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
253 dnl Add a library, used to enforce consistency.
255 dnl $1 = library to add, without the "-l"
256 dnl $2 = variable to update (default $LIBS)
257 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
258 dnl ---------------------------------------------------------------------------
259 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
261 dnl Adds to the library-path
263 dnl Some machines have trouble with multiple -L options.
265 dnl $1 is the (list of) directory(s) to add
266 dnl $2 is the optional name of the variable to update (default LDFLAGS)
268 AC_DEFUN([CF_ADD_LIBDIR],
270 if test -n "$1" ; then
271 for cf_add_libdir in $1
273 if test "$cf_add_libdir" = /usr/lib ; then
275 elif test -d "$cf_add_libdir"
278 if test -n "$LDFLAGS$LIBS" ; then
279 # a loop is needed to ensure we can add subdirs of existing dirs
280 for cf_test_libdir in $LDFLAGS $LIBS ; do
281 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
282 cf_have_libdir=yes; break
286 if test "$cf_have_libdir" = no ; then
287 CF_VERBOSE(adding $cf_add_libdir to library-path)
288 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
294 dnl ---------------------------------------------------------------------------
295 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
297 dnl Add one or more libraries, used to enforce consistency. Libraries are
298 dnl prepended to an existing list, since their dependencies are assumed to
299 dnl already exist in the list.
301 dnl $1 = libraries to add, with the "-l", etc.
302 dnl $2 = variable to update (default $LIBS)
303 AC_DEFUN([CF_ADD_LIBS],[
304 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
307 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
309 for cf_add_1lib in $cf_add_0lib; do
310 for cf_add_2lib in $cf_add_libs; do
311 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
316 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
318 ifelse($2,,LIBS,[$2])="$cf_add_libs"
320 dnl ---------------------------------------------------------------------------
321 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
322 dnl ------------------
323 dnl Append to a search-list for a nonstandard header/lib-file
324 dnl $1 = the variable to return as result
325 dnl $2 = the package name
326 dnl $3 = the subdirectory, e.g., bin, include or lib
327 dnl $4 = the directory under which we will test for subdirectories
328 dnl $5 = a directory that we do not want $4 to match
329 AC_DEFUN([CF_ADD_SUBDIR_PATH],
331 test "x$4" != "x$5" && \
333 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
334 test -n "$verbose" && echo " ... testing for $3-directories under $4"
335 test -d "$4/$3" && $1="[$]$1 $4/$3"
336 test -d "$4/$3/$2" && $1="[$]$1 $4/$3/$2"
337 test -d "$4/$3/$2/$3" && $1="[$]$1 $4/$3/$2/$3"
338 test -d "$4/$2/$3" && $1="[$]$1 $4/$2/$3"
339 test -d "$4/$2/$3/$2" && $1="[$]$1 $4/$2/$3/$2"
342 dnl ---------------------------------------------------------------------------
343 dnl CF_APPEND_CFLAGS version: 1 updated: 2021/08/28 15:20:37
345 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
346 dnl $1 = flags to add
347 dnl $2 = if given makes this macro verbose.
348 define([CF_APPEND_CFLAGS],
350 for cf_add_cflags in $1
352 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
353 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
355 CF_ADD_CFLAGS([$1],[$2])
357 dnl ---------------------------------------------------------------------------
358 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
360 dnl use this macro for appending text without introducing an extra blank at
362 define([CF_APPEND_TEXT],
364 test -n "[$]$1" && $1="[$]$1 "
367 dnl ---------------------------------------------------------------------------
368 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
370 dnl Allow user to disable a normally-on option.
371 AC_DEFUN([CF_ARG_DISABLE],
372 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
373 dnl ---------------------------------------------------------------------------
374 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
376 dnl Allow user to enable a normally-off option.
377 AC_DEFUN([CF_ARG_ENABLE],
378 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
379 dnl ---------------------------------------------------------------------------
380 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
382 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
388 dnl $3 = action to perform if option is not default
389 dnl $4 = action if perform if option is default
390 dnl $5 = default option value (either 'yes' or 'no')
391 AC_DEFUN([CF_ARG_OPTION],
392 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
393 if test "$enableval" != "$5" ; then
395 ,[ $3]) ifelse([$4],,,[
398 fi],[enableval=$5 ifelse([$4],,,[
402 dnl ---------------------------------------------------------------------------
403 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
405 dnl Check for suitable "ar" (archiver) options for updating an archive.
407 dnl In particular, handle some obsolete cases where the "-" might be omitted,
408 dnl as well as a workaround for breakage of make's archive rules by the GNU
409 dnl binutils "ar" program.
410 AC_DEFUN([CF_AR_FLAGS],[
411 AC_REQUIRE([CF_PROG_AR])
413 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
414 case "$cf_cv_system_name" in
417 cat >mk_static_lib.sh <<-EOF
422 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
424 chmod +x mk_static_lib.sh
425 AR=`pwd`/mk_static_lib.sh
428 cf_cv_ar_flags=unknown
429 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
432 # check if $ARFLAGS already contains this choice
433 if test "x$ARFLAGS" != "x" ; then
434 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
435 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
441 rm -f "conftest.$ac_cv_objext"
444 cat >"conftest.$ac_ext" <<EOF
445 #line __oline__ "configure"
446 int testdata[[3]] = { 123, 456, 789 };
448 if AC_TRY_EVAL(ac_compile) ; then
449 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
450 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
451 if test -f conftest.a ; then
452 cf_cv_ar_flags="$cf_ar_flags"
456 CF_VERBOSE(cannot compile test-program)
460 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
465 if test -n "$ARFLAGS" ; then
466 if test -n "$cf_cv_ar_flags" ; then
467 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
470 ARFLAGS=$cf_cv_ar_flags
475 dnl ---------------------------------------------------------------------------
476 dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
478 dnl If we're cross-compiling, allow the user to override the tools and their
479 dnl options. The configure script is oriented toward identifying the host
480 dnl compiler, etc., but we need a build compiler to generate parts of the
483 dnl $1 = default for $CPPFLAGS
484 dnl $2 = default for $LIBS
485 AC_DEFUN([CF_BUILD_CC],[
486 CF_ACVERSION_CHECK(2.52,,
487 [AC_REQUIRE([CF_PROG_EXT])])
488 if test "$cross_compiling" = yes ; then
490 # defaults that we might want to override
491 : ${BUILD_CFLAGS:=''}
492 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
493 : ${BUILD_LDFLAGS:=''}
494 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
495 : ${BUILD_EXEEXT:='$x'}
496 : ${BUILD_OBJEXT:='o'}
498 AC_ARG_WITH(build-cc,
499 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
500 [BUILD_CC="$withval"],
501 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
502 AC_MSG_CHECKING(for native build C compiler)
503 AC_MSG_RESULT($BUILD_CC)
505 AC_MSG_CHECKING(for native build C preprocessor)
506 AC_ARG_WITH(build-cpp,
507 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
508 [BUILD_CPP="$withval"],
509 [BUILD_CPP='${BUILD_CC} -E'])
510 AC_MSG_RESULT($BUILD_CPP)
512 AC_MSG_CHECKING(for native build C flags)
513 AC_ARG_WITH(build-cflags,
514 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
515 [BUILD_CFLAGS="$withval"])
516 AC_MSG_RESULT($BUILD_CFLAGS)
518 AC_MSG_CHECKING(for native build C preprocessor-flags)
519 AC_ARG_WITH(build-cppflags,
520 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
521 [BUILD_CPPFLAGS="$withval"])
522 AC_MSG_RESULT($BUILD_CPPFLAGS)
524 AC_MSG_CHECKING(for native build linker-flags)
525 AC_ARG_WITH(build-ldflags,
526 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
527 [BUILD_LDFLAGS="$withval"])
528 AC_MSG_RESULT($BUILD_LDFLAGS)
530 AC_MSG_CHECKING(for native build linker-libraries)
531 AC_ARG_WITH(build-libs,
532 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
533 [BUILD_LIBS="$withval"])
534 AC_MSG_RESULT($BUILD_LIBS)
536 # this assumes we're on Unix.
540 : ${BUILD_CC:='${CC}'}
542 if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
543 AC_MSG_ERROR([Cross-build requires two compilers.
544 Use --with-build-cc to specify the native compiler.])
548 : ${BUILD_CC:='${CC}'}
549 : ${BUILD_CPP:='${CPP}'}
550 : ${BUILD_CFLAGS:='${CFLAGS}'}
551 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
552 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
553 : ${BUILD_LIBS:='${LIBS}'}
554 : ${BUILD_EXEEXT:='$x'}
555 : ${BUILD_OBJEXT:='o'}
560 AC_SUBST(BUILD_CFLAGS)
561 AC_SUBST(BUILD_CPPFLAGS)
562 AC_SUBST(BUILD_LDFLAGS)
564 AC_SUBST(BUILD_EXEEXT)
565 AC_SUBST(BUILD_OBJEXT)
567 dnl ---------------------------------------------------------------------------
568 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
570 AC_DEFUN([CF_C11_NORETURN],
572 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
573 CF_ARG_ENABLE(stdnoreturn,
574 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
575 [enable_stdnoreturn=yes],
576 [enable_stdnoreturn=no])
577 AC_MSG_RESULT($enable_stdnoreturn)
579 if test $enable_stdnoreturn = yes; then
580 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
584 #include <stdnoreturn.h>
585 static _Noreturn void giveup(void) { exit(0); }
587 [if (feof(stdin)) giveup()],
588 cf_cv_c11_noreturn=yes,
589 cf_cv_c11_noreturn=no)
592 cf_cv_c11_noreturn=no,
595 if test "$cf_cv_c11_noreturn" = yes; then
596 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
597 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
603 AC_SUBST(HAVE_STDNORETURN_H)
604 AC_SUBST(STDC_NORETURN)
606 dnl ---------------------------------------------------------------------------
607 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
609 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
610 dnl into CC. This will not help with broken scripts that wrap the compiler
611 dnl with options, but eliminates a more common category of user confusion.
613 dnl In particular, it addresses the problem of being able to run the C
614 dnl preprocessor in a consistent manner.
616 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
617 dnl the nuisance of having inconsistent settings for compiler and preprocessor
618 dnl outweighs that limitation.
619 AC_DEFUN([CF_CC_ENV_FLAGS],
621 # This should have been defined by AC_PROG_CC
624 AC_MSG_CHECKING(\$CFLAGS variable)
627 AC_MSG_RESULT(broken)
628 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
631 for cf_arg in $cf_flags
633 CF_ADD_CFLAGS($cf_arg)
641 AC_MSG_CHECKING(\$CC variable)
644 AC_MSG_RESULT(broken)
645 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
647 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
648 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
650 for cf_arg in $cf_flags
654 CF_ADD_CFLAGS($cf_arg)
661 CF_VERBOSE(resulting CC: '$CC')
662 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
663 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
670 dnl ---------------------------------------------------------------------------
671 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
673 dnl Determine the default configuration into which we'll install ncurses. This
674 dnl can be overridden by the user's command-line options. There's two items to
676 dnl 1. the prefix (e.g., /usr)
677 dnl 2. the header files (e.g., /usr/include/ncurses)
678 dnl We'll look for a previous installation of ncurses and use the same defaults.
680 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
681 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
682 dnl programs from a vendor's.
683 AC_DEFUN([CF_CFG_DEFAULTS],
684 [AC_REQUIRE([AC_PROG_FGREP])dnl
686 AC_MSG_CHECKING(for prefix)
687 if test "x$prefix" = "xNONE" ; then
688 case "$cf_cv_system_name" in
689 # non-vendor systems don't have a conflict
690 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
693 (*) prefix=$ac_default_prefix
697 AC_MSG_RESULT($prefix)
699 if test "x$prefix" = "xNONE" ; then
700 AC_MSG_CHECKING(for default include-directory)
701 test -n "$verbose" && echo 1>&AC_FD_MSG
704 "$includedir/ncurses" \
706 "$prefix/include/ncurses" \
708 /usr/local/include/ncurses \
712 cf_dir=`eval echo "$cf_symbol"`
713 if test -f "$cf_dir/curses.h" ; then
714 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
715 includedir="$cf_symbol"
716 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
720 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
722 AC_MSG_RESULT($includedir)
725 dnl ---------------------------------------------------------------------------
726 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
728 dnl Check if we're accidentally using a cache from a different machine.
729 dnl Derive the system name, as a check for reusing the autoconf cache.
731 dnl If we've packaged config.guess and config.sub, run that (since it does a
732 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
733 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
734 dnl which is useful in cross-compiles.
736 dnl Note: we would use $ac_config_sub, but that is one of the places where
737 dnl autoconf 2.5x broke compatibility with autoconf 2.13
738 AC_DEFUN([CF_CHECK_CACHE],
740 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
741 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
742 system_name="$host_os"
744 system_name="`(uname -s -r) 2>/dev/null`"
745 if test -z "$system_name" ; then
746 system_name="`(hostname) 2>/dev/null`"
749 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
750 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
752 test -z "$system_name" && system_name="$cf_cv_system_name"
753 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
755 if test ".$system_name" != ".$cf_cv_system_name" ; then
756 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
757 AC_MSG_ERROR("Please remove config.cache and try again.")
760 dnl ---------------------------------------------------------------------------
761 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
762 dnl ---------------------
763 AC_DEFUN([CF_CHECK_GNAT_VERSION],
765 AC_REQUIRE([CF_GNAT_VERSION])
766 case "$cf_cv_gnat_version" in
767 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
768 cf_cv_prog_gnat_correct=yes
771 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
772 cf_cv_prog_gnat_correct=no
776 dnl ---------------------------------------------------------------------------
777 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
778 dnl -----------------
779 dnl Check if the given compiler is really clang. clang's C driver defines
780 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
781 dnl not ignore some gcc options.
783 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
784 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
785 dnl the wrappers for gcc and g++ warnings.
787 dnl $1 = GCC (default) or GXX
788 dnl $2 = CLANG_COMPILER (default)
789 dnl $3 = CFLAGS (default) or CXXFLAGS
790 AC_DEFUN([CF_CLANG_COMPILER],[
791 ifelse([$2],,CLANG_COMPILER,[$2])=no
793 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
794 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
795 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
801 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
803 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
804 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
809 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
811 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
812 AC_MSG_WARN(replacing broken compiler alias $CC)
813 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
818 AC_MSG_CHECKING(version of $CC)
819 CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
820 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
821 AC_MSG_RESULT($CLANG_VERSION)
823 for cf_clang_opt in \
825 -Wno-error=implicit-function-declaration
827 AC_MSG_CHECKING(if option $cf_clang_opt works)
828 cf_save_CFLAGS="$CFLAGS"
829 CFLAGS="$CFLAGS $cf_clang_opt"
831 #include <stdio.h>],[
832 printf("hello!\\n");],[
833 cf_clang_optok=yes],[
835 AC_MSG_RESULT($cf_clang_optok)
836 CFLAGS="$cf_save_CFLAGS"
837 if test "$cf_clang_optok" = yes; then
838 CF_VERBOSE(adding option $cf_clang_opt)
839 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
844 dnl ---------------------------------------------------------------------------
845 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
846 dnl -----------------
847 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
848 dnl character-strings.
850 dnl It is ambiguous because the specification accommodated the pre-ANSI
851 dnl compilers bundled by more than one vendor in lieu of providing a standard C
852 dnl compiler other than by costly add-ons. Because of this, the specification
853 dnl did not take into account the use of const for telling the compiler that
854 dnl string literals would be in readonly memory.
856 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
857 dnl let the compiler decide how to represent Xt's strings which were #define'd.
858 dnl That does not solve the problem of using the block of Xt's strings which
859 dnl are compiled into the library (and is less efficient than one might want).
861 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
862 dnl when compiling the library and compiling using the library, to tell the
863 dnl compiler that String is const.
864 AC_DEFUN([CF_CONST_X_STRING],
866 AC_REQUIRE([AC_PATH_XTRA])
868 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
873 #include <X11/Intrinsic.h>
875 [String foo = malloc(1); free((void*)foo)],[
877 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
880 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
881 #undef XTSTRINGDEFINES /* X11R5 and later */
883 #include <X11/Intrinsic.h>
884 ],[String foo = malloc(1); *foo = 0],[
885 cf_cv_const_x_string=no
887 cf_cv_const_x_string=yes
891 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
893 case "$cf_cv_const_x_string" in
895 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
898 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
904 dnl ---------------------------------------------------------------------------
905 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
906 dnl -----------------
907 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
908 dnl character-strings.
910 dnl It is ambiguous because the specification accommodated the pre-ANSI
911 dnl compilers bundled by more than one vendor in lieu of providing a standard C
912 dnl compiler other than by costly add-ons. Because of this, the specification
913 dnl did not take into account the use of const for telling the compiler that
914 dnl string literals would be in readonly memory.
916 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
917 dnl let the compiler decide how to represent Xt's strings which were #define'd.
918 dnl That does not solve the problem of using the block of Xt's strings which
919 dnl are compiled into the library (and is less efficient than one might want).
921 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
922 dnl when compiling the library and compiling using the library, to tell the
923 dnl compiler that String is const.
924 AC_DEFUN([CF_CONST_X_STRING],
926 AC_REQUIRE([AC_PATH_XTRA])
928 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
933 #include <X11/Intrinsic.h>
935 [String foo = malloc(1); free((void*)foo)],[
937 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
940 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
941 #undef XTSTRINGDEFINES /* X11R5 and later */
943 #include <X11/Intrinsic.h>
944 ],[String foo = malloc(1); *foo = 0],[
945 cf_cv_const_x_string=no
947 cf_cv_const_x_string=yes
951 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
953 case "$cf_cv_const_x_string" in
955 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
958 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
964 dnl ---------------------------------------------------------------------------
965 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
967 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
968 dnl variations of ncurses' installs.
970 dnl $1 = ncurses when looking for ncurses, or is empty
971 AC_DEFUN([CF_CURSES_HEADER],[
972 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
973 cf_cv_ncurses_header=none
975 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
976 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
978 AC_TRY_COMPILE([#include <${cf_header}>],
979 [initscr(); tgoto("?", 0,0)],
980 [cf_cv_ncurses_header=$cf_header; break],[])
984 if test "$cf_cv_ncurses_header" = none ; then
985 AC_MSG_ERROR(No curses header-files found)
988 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
989 AC_CHECK_HEADERS($cf_cv_ncurses_header)
991 dnl ---------------------------------------------------------------------------
992 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
994 dnl "dirname" is not portable, so we fake it with a shell script.
995 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
996 dnl ---------------------------------------------------------------------------
997 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
999 dnl You can always use "make -n" to see the actual options, but it is hard to
1000 dnl pick out/analyze warning messages when the compile-line is long.
1003 dnl ECHO_LT - symbol to control if libtool is verbose
1004 dnl ECHO_LD - symbol to prefix "cc -o" lines
1005 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1006 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1007 dnl ECHO_CC - symbol to put before any "cc" line
1009 AC_DEFUN([CF_DISABLE_ECHO],[
1010 AC_MSG_CHECKING(if you want to see long compiling messages)
1011 CF_ARG_DISABLE(echo,
1012 [ --disable-echo do not display "compiling" commands],
1015 ECHO_LD='@echo linking [$]@;'
1016 RULE_CC='@echo compiling [$]<'
1017 SHOW_CC='@echo compiling [$]@'
1026 AC_MSG_RESULT($enableval)
1033 dnl ---------------------------------------------------------------------------
1034 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1035 dnl ------------------------
1036 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1037 AC_MSG_CHECKING(if we want to use GNAT projects)
1038 CF_ARG_DISABLE(gnat-projects,
1039 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1040 [enable_gnat_projects=no],
1041 [enable_gnat_projects=yes])
1042 AC_MSG_RESULT($enable_gnat_projects)
1044 dnl ---------------------------------------------------------------------------
1045 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
1046 dnl -----------------------
1047 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
1048 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1049 dnl an unconditional feature.
1050 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1052 AC_MSG_CHECKING(if you want broken-linker support code)
1053 AC_ARG_ENABLE(broken_linker,
1054 [ --enable-broken_linker compile with broken-linker support code],
1055 [with_broken_linker=$enableval],
1056 [with_broken_linker=no])
1057 AC_MSG_RESULT($with_broken_linker)
1059 : "${BROKEN_LINKER:=0}"
1060 if test "x$with_broken_linker" = xyes ; then
1061 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1064 AC_SUBST(BROKEN_LINKER)
1066 dnl ---------------------------------------------------------------------------
1067 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1068 dnl ------------------
1069 dnl Configure-option to enable gcc warnings
1071 dnl $1 = extra options to add, if supported
1072 dnl $2 = option for checking attributes. By default, this is done when
1073 dnl warnings are enabled. For other values:
1074 dnl yes: always do this, e.g., to use in generated library-headers
1075 dnl no: never do this
1076 AC_DEFUN([CF_ENABLE_WARNINGS],[
1077 if test "$GCC" = yes || test "$GXX" = yes
1079 CF_FIX_WARNINGS(CFLAGS)
1080 CF_FIX_WARNINGS(CPPFLAGS)
1081 CF_FIX_WARNINGS(LDFLAGS)
1082 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1083 CF_ARG_ENABLE(warnings,
1084 [ --enable-warnings test: turn on gcc compiler warnings],
1085 [enable_warnings=yes],
1086 [enable_warnings=no])
1087 AC_MSG_RESULT($enable_warnings)
1088 if test "$enable_warnings" = "yes"
1090 ifelse($2,,[CF_GCC_ATTRIBUTES])
1093 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1096 dnl ---------------------------------------------------------------------------
1097 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1099 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1100 dnl prefer a standard location, and use -L options only if we do not find the
1101 dnl library in the standard library location(s).
1102 dnl $1 = library name
1103 dnl $2 = library class, usually the same as library name
1105 dnl $4 = code fragment to compile/link
1106 dnl $5 = corresponding function-name
1107 dnl $6 = flag, nonnull if failure should not cause an error-exit
1109 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1110 dnl to use a -L option.
1111 AC_DEFUN([CF_FIND_LIBRARY],
1113 eval 'cf_cv_have_lib_'"$1"'=no'
1116 eval 'cf_cv_have_lib_'"$1"'=yes',[
1117 cf_save_LIBS="$LIBS"
1118 AC_MSG_CHECKING(for $5 in -l$1)
1120 AC_TRY_LINK([$3],[$4],
1122 eval 'cf_cv_have_lib_'"$1"'=yes'
1125 CF_LIBRARY_PATH(cf_search,$2)
1126 for cf_libdir in $cf_search
1128 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1129 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1130 AC_TRY_LINK([$3],[$4],
1132 eval 'cf_cv_have_lib_'"$1"'=yes'
1135 LIBS="$cf_save_LIBS"])
1139 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1141 if test "$cf_found_library" = no ; then
1142 AC_MSG_ERROR(Cannot link $1 library)
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1149 dnl Find a library (specifically the linkage used in the code fragment),
1150 dnl searching for it if it is not already in the library path.
1151 dnl See also CF_ADD_SEARCHPATH.
1153 dnl Parameters (4-on are optional):
1154 dnl $1 = headers for library entrypoint
1155 dnl $2 = code fragment for library entrypoint
1156 dnl $3 = the library name without the "-l" option or ".so" suffix.
1157 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1158 dnl $5 = action to perform if not successful
1159 dnl $6 = module name, if not the same as the library name
1160 dnl $7 = extra libraries
1162 dnl Sets these variables:
1163 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1164 dnl $cf_cv_header_path_$3 - include-directory if needed
1165 dnl $cf_cv_library_path_$3 - library-directory if needed
1166 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1167 AC_DEFUN([CF_FIND_LINKAGE],[
1169 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1170 # will be set on completion of the AC_TRY_LINK below.
1171 cf_cv_header_path_$3=
1172 cf_cv_library_path_$3=
1174 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1176 cf_save_LIBS="$LIBS"
1178 AC_TRY_LINK([$1],[$2],[
1179 cf_cv_find_linkage_$3=yes
1180 cf_cv_header_path_$3=/usr/include
1181 cf_cv_library_path_$3=/usr/lib
1184 LIBS="-l$3 $7 $cf_save_LIBS"
1186 AC_TRY_LINK([$1],[$2],[
1187 cf_cv_find_linkage_$3=yes
1188 cf_cv_header_path_$3=/usr/include
1189 cf_cv_library_path_$3=/usr/lib
1190 cf_cv_library_file_$3="-l$3"
1192 cf_cv_find_linkage_$3=no
1193 LIBS="$cf_save_LIBS"
1195 CF_VERBOSE(find linkage for $3 library)
1196 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1198 cf_save_CPPFLAGS="$CPPFLAGS"
1199 cf_test_CPPFLAGS="$CPPFLAGS"
1201 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1202 for cf_cv_header_path_$3 in $cf_search
1204 if test -d "$cf_cv_header_path_$3" ; then
1205 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1206 CPPFLAGS="$cf_save_CPPFLAGS"
1207 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1208 AC_TRY_COMPILE([$1],[$2],[
1209 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1210 cf_cv_find_linkage_$3=maybe
1211 cf_test_CPPFLAGS="$CPPFLAGS"
1213 CPPFLAGS="$cf_save_CPPFLAGS"
1218 if test "$cf_cv_find_linkage_$3" = maybe ; then
1220 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1222 cf_save_LIBS="$LIBS"
1223 cf_save_LDFLAGS="$LDFLAGS"
1226 CPPFLAGS="$cf_test_CPPFLAGS"
1227 LIBS="-l$3 $7 $cf_save_LIBS"
1228 AC_TRY_LINK([$1],[$2],[
1229 CF_VERBOSE(... found $3 library in system)
1230 cf_cv_find_linkage_$3=yes])
1231 CPPFLAGS="$cf_save_CPPFLAGS"
1232 LIBS="$cf_save_LIBS"
1235 if test "$cf_cv_find_linkage_$3" != yes ; then
1236 CF_LIBRARY_PATH(cf_search,$3)
1237 for cf_cv_library_path_$3 in $cf_search
1239 if test -d "$cf_cv_library_path_$3" ; then
1240 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1241 CPPFLAGS="$cf_test_CPPFLAGS"
1242 LIBS="-l$3 $7 $cf_save_LIBS"
1243 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1244 AC_TRY_LINK([$1],[$2],[
1245 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1246 cf_cv_find_linkage_$3=yes
1247 cf_cv_library_file_$3="-l$3"
1249 CPPFLAGS="$cf_save_CPPFLAGS"
1250 LIBS="$cf_save_LIBS"
1251 LDFLAGS="$cf_save_LDFLAGS"
1255 CPPFLAGS="$cf_save_CPPFLAGS"
1256 LDFLAGS="$cf_save_LDFLAGS"
1260 cf_cv_find_linkage_$3=no
1265 LIBS="$cf_save_LIBS"
1267 if test "$cf_cv_find_linkage_$3" = yes ; then
1269 CF_ADD_INCDIR($cf_cv_header_path_$3)
1270 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1274 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1277 dnl ---------------------------------------------------------------------------
1278 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1279 dnl -----------------
1280 dnl make ADAFLAGS consistent with CFLAGS
1281 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1282 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1290 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1291 CF_ADD_ADAFLAGS($cf_O_flag)
1294 AC_MSG_RESULT($ADAFLAGS)
1296 dnl ---------------------------------------------------------------------------
1297 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1299 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1300 dnl "-Werror" flags can interfere with configure-checks. Those go into
1303 dnl $1 = variable name to repair
1304 define([CF_FIX_WARNINGS],[
1305 if test "$GCC" = yes || test "$GXX" = yes
1309 CF_VERBOSE(repairing $1: [$]$1)
1311 for cf_temp_scan in [$]$1
1313 case "x$cf_temp_scan" in
1315 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1318 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1323 CF_VERBOSE(... fixed [$]$1)
1324 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1328 AC_SUBST(EXTRA_CFLAGS)
1330 dnl ---------------------------------------------------------------------------
1331 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1332 dnl -----------------
1333 dnl Test for availability of useful gcc __attribute__ directives to quiet
1334 dnl compiler warnings. Though useful, not all are supported -- and contrary
1335 dnl to documentation, unrecognized directives cause older compilers to barf.
1336 AC_DEFUN([CF_GCC_ATTRIBUTES],
1337 [AC_REQUIRE([AC_PROG_FGREP])dnl
1338 AC_REQUIRE([CF_C11_NORETURN])dnl
1340 if test "$GCC" = yes || test "$GXX" = yes
1342 cat > conftest.i <<EOF
1344 #define GCC_PRINTF 0
1349 #ifndef GCC_NORETURN
1350 #define GCC_NORETURN /* nothing */
1353 #define GCC_UNUSED /* nothing */
1356 if test "$GCC" = yes
1358 AC_CHECKING([for $CC __attribute__ directives])
1359 cat > "conftest.$ac_ext" <<EOF
1360 #line __oline__ "${as_me:-configure}"
1361 #include "confdefs.h"
1362 #include "conftest.h"
1363 #include "conftest.i"
1365 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1367 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1370 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1372 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1374 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1375 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1376 extern GCC_NORETURN void foo(void);
1377 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1379 cf_printf_attribute=no
1380 cf_scanf_attribute=no
1381 for cf_attribute in scanf printf unused noreturn
1383 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1384 cf_directive="__attribute__(($cf_attribute))"
1385 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1387 case "$cf_attribute" in
1389 cf_printf_attribute=yes
1390 cat >conftest.h <<EOF
1391 #define GCC_$cf_ATTRIBUTE 1
1395 cf_scanf_attribute=yes
1396 cat >conftest.h <<EOF
1397 #define GCC_$cf_ATTRIBUTE 1
1401 cat >conftest.h <<EOF
1402 #define GCC_$cf_ATTRIBUTE $cf_directive
1407 if AC_TRY_EVAL(ac_compile); then
1408 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1409 cat conftest.h >>confdefs.h
1410 case "$cf_attribute" in
1412 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1415 cf_value='/* nothing */'
1416 if test "$cf_printf_attribute" != no ; then
1417 cf_value='__attribute__((format(printf,fmt,var)))'
1418 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1420 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1423 cf_value='/* nothing */'
1424 if test "$cf_scanf_attribute" != no ; then
1425 cf_value='__attribute__((format(scanf,fmt,var)))'
1426 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1428 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1431 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1437 ${FGREP-fgrep} define conftest.i >>confdefs.h
1442 dnl ---------------------------------------------------------------------------
1443 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1445 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1446 dnl compatible), attempt to determine if icc/clang is actually used.
1447 AC_DEFUN([CF_GCC_VERSION],[
1448 AC_REQUIRE([AC_PROG_CC])
1450 if test "$GCC" = yes ; then
1451 AC_MSG_CHECKING(version of $CC)
1452 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1453 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1454 AC_MSG_RESULT($GCC_VERSION)
1456 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1457 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1459 dnl ---------------------------------------------------------------------------
1460 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1462 dnl Check if the compiler supports useful warning options. There's a few that
1463 dnl we don't use, simply because they're too noisy:
1465 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1466 dnl -Winline (usually not worthwhile)
1467 dnl -Wredundant-decls (system headers make this too noisy)
1468 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1469 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1470 dnl is enabled for ncurses using "--enable-const".
1474 dnl $1 is an optional list of gcc warning flags that a particular
1475 dnl application might want to use, e.g., "no-unused" for
1478 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1480 AC_DEFUN([CF_GCC_WARNINGS],
1482 AC_REQUIRE([CF_GCC_VERSION])
1483 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1484 cat > "conftest.$ac_ext" <<EOF
1485 #line __oline__ "${as_me:-configure}"
1486 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1488 if test "$INTEL_COMPILER" = yes
1490 # The "-wdXXX" options suppress warnings:
1491 # remark #1419: external declaration in primary source file
1492 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1493 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1494 # remark #193: zero used for undefined preprocessing identifier
1495 # remark #593: variable "curs_sb_left_arrow" was set but never used
1496 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1497 # remark #869: parameter "tw" was never referenced
1498 # remark #981: operands are evaluated in unspecified order
1499 # warning #279: controlling expression is constant
1501 AC_CHECKING([for $CC warning options])
1502 cf_save_CFLAGS="$CFLAGS"
1503 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1515 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1516 if AC_TRY_EVAL(ac_compile); then
1517 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1518 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1521 CFLAGS="$cf_save_CFLAGS"
1522 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1524 AC_CHECKING([for $CC warning options])
1525 cf_save_CFLAGS="$CFLAGS"
1527 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1528 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1529 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1530 for cf_opt in W Wall \
1531 Wbad-function-cast \
1534 Wdeclaration-after-statement \
1537 Wmissing-declarations \
1538 Wmissing-prototypes \
1542 Wstrict-prototypes \
1543 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1545 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1546 if AC_TRY_EVAL(ac_compile); then
1547 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1550 case "$GCC_VERSION" in
1552 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1557 case "$GCC_VERSION" in
1559 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1564 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1567 CFLAGS="$cf_save_CFLAGS"
1571 AC_SUBST(EXTRA_CFLAGS)
1573 dnl ---------------------------------------------------------------------------
1574 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1575 dnl -----------------
1576 AC_DEFUN([CF_GNATPREP_OPT_T],[
1577 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1578 cf_cv_gnatprep_opt_t=no
1579 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1581 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1582 AC_SUBST(GNATPREP_OPTS)
1584 dnl ---------------------------------------------------------------------------
1585 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1586 dnl ----------------
1587 AC_DEFUN([CF_GNAT_GENERICS],
1589 AC_REQUIRE([CF_GNAT_VERSION])
1591 AC_MSG_CHECKING(if GNAT supports generics)
1592 case "$cf_cv_gnat_version" in
1593 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1594 cf_gnat_generics=yes
1600 AC_MSG_RESULT($cf_gnat_generics)
1602 if test "$cf_gnat_generics" = yes
1604 cf_compile_generics=generics
1605 cf_generic_objects="\${GENOBJS}"
1607 cf_compile_generics=
1611 AC_SUBST(cf_compile_generics)
1612 AC_SUBST(cf_generic_objects)
1614 dnl ---------------------------------------------------------------------------
1615 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1616 dnl ----------------
1617 dnl GNAT projects are configured with ".gpr" project files.
1618 dnl GNAT libraries are a further development, using the project feature.
1619 AC_DEFUN([CF_GNAT_PROJECTS],
1621 AC_REQUIRE([CF_GNAT_VERSION])
1622 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1624 cf_gnat_libraries=no
1627 if test "$enable_gnat_projects" != no ; then
1628 AC_MSG_CHECKING(if GNAT supports project files)
1629 case "$cf_cv_gnat_version" in
1633 case "$cf_cv_system_name" in
1637 rm -rf ./conftest* ./*~conftest*
1638 if mkdir conftest.src conftest.bin conftest.lib
1641 rm -rf ./conftest* ./*~conftest*
1642 cat >>library.gpr <<CF_EOF
1644 Kind := External ("LIB_KIND");
1645 for Library_Name use "ConfTest";
1646 for Object_Dir use ".";
1647 for Library_ALI_Dir use External("LIBRARY_DIR");
1648 for Library_Version use External ("SONAME");
1649 for Library_Kind use Kind;
1650 for Library_Dir use External("BUILD_DIR");
1651 Source_Dir := External ("SOURCE_DIR");
1652 for Source_Dirs use (Source_Dir);
1655 cat >>confpackage.ads <<CF_EOF
1656 package ConfPackage is
1660 cat >>confpackage.adb <<CF_EOF
1662 package body ConfPackage is
1663 procedure conftest is
1665 Text_IO.Put ("Hello World");
1670 if ( "$cf_ada_make" $ADAFLAGS \
1672 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1673 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1674 -XSOURCE_DIR="`pwd`" \
1675 -XSONAME=libConfTest.so.1 \
1676 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1677 cf_gnat_projects=yes
1681 if test -f conftest.lib/confpackage.ali
1683 cf_gnat_libraries=yes
1685 rm -rf ./conftest* ./*~conftest*
1690 AC_MSG_RESULT($cf_gnat_projects)
1691 fi # enable_gnat_projects
1693 if test "$cf_gnat_projects" = yes
1695 AC_MSG_CHECKING(if GNAT supports libraries)
1696 AC_MSG_RESULT($cf_gnat_libraries)
1699 USE_OLD_MAKERULES=""
1700 USE_GNAT_PROJECTS="#"
1701 USE_GNAT_MAKE_GPR="#"
1702 USE_GNAT_GPRBUILD="#"
1704 if test "$cf_gnat_projects" = yes
1706 USE_OLD_MAKERULES="#"
1707 USE_GNAT_PROJECTS=""
1708 if test "$cf_cv_VERSION_GPRBUILD" != no
1710 USE_GNAT_GPRBUILD=""
1711 elif test "$cf_cv_VERSION_GNATMAKE" != no
1713 USE_GNAT_MAKE_GPR=""
1715 AC_MSG_WARN(use old makefile rules since tools are missing)
1719 if test "$cf_gnat_libraries" = yes
1721 USE_GNAT_LIBRARIES=""
1723 USE_GNAT_LIBRARIES="#"
1726 AC_SUBST(USE_OLD_MAKERULES)
1727 AC_SUBST(USE_GNAT_PROJECTS)
1728 AC_SUBST(USE_GNAT_LIBRARIES)
1729 AC_SUBST(USE_GNAT_MAKE_GPR)
1730 AC_SUBST(USE_GNAT_GPRBUILD)
1732 dnl ---------------------------------------------------------------------------
1733 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1735 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1736 dnl is noted that gnat may compile a tasking unit even for configurations which
1737 dnl fail at runtime.
1738 AC_DEFUN([CF_GNAT_SIGINT],[
1739 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1740 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1744 pragma Warnings (Off); -- the next pragma exists since 3.11p
1745 pragma Unreserve_All_Interrupts;
1746 pragma Warnings (On);
1748 protected Process is
1750 function Continue return Boolean;
1751 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1753 Done : Boolean := False;
1757 [package body ConfTest is
1758 protected body Process is
1763 function Continue return Boolean is
1769 [cf_cv_gnat_sigint=yes],
1770 [cf_cv_gnat_sigint=no])])
1772 if test "$cf_cv_gnat_sigint" = yes ; then
1777 AC_SUBST(USE_GNAT_SIGINT)
1779 dnl ---------------------------------------------------------------------------
1780 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1781 dnl ----------------
1782 dnl Verify that a test program compiles/links with GNAT.
1783 dnl $cf_ada_make is set to the program that compiles/links
1784 dnl $ADAFLAGS may be set to the GNAT flags.
1786 dnl $1 is the text of the spec
1787 dnl $2 is the text of the body
1788 dnl $3 is the shell command to execute if successful
1789 dnl $4 is the shell command to execute if not successful
1790 AC_DEFUN([CF_GNAT_TRY_LINK],
1792 rm -rf ./conftest* ./*~conftest*
1793 cat >>conftest.ads <<CF_EOF
1796 cat >>conftest.adb <<CF_EOF
1799 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1800 ifelse($3,, :,[ $3])
1804 rm -rf ./conftest* ./*~conftest*
1806 dnl ---------------------------------------------------------------------------
1807 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1809 dnl Verify that a test program compiles and runs with GNAT
1810 dnl $cf_ada_make is set to the program that compiles/links
1811 dnl $ADAFLAGS may be set to the GNAT flags.
1813 dnl $1 is the text of the spec
1814 dnl $2 is the text of the body
1815 dnl $3 is the shell command to execute if successful
1816 dnl $4 is the shell command to execute if not successful
1817 AC_DEFUN([CF_GNAT_TRY_RUN],
1819 rm -rf ./conftest* ./*~conftest*
1820 cat >>conftest.ads <<CF_EOF
1823 cat >>conftest.adb <<CF_EOF
1826 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1827 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1828 ifelse($3,, :,[ $3])
1835 rm -rf ./conftest* ./*~conftest*
1837 dnl ---------------------------------------------------------------------------
1838 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1840 dnl $1 = cache variable to update
1841 dnl $2 = program name
1842 dnl Verify version of GNAT or related tool
1843 AC_DEFUN([CF_GNAT_VERSION],
1845 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1846 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1847 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1848 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1850 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1851 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1853 dnl ---------------------------------------------------------------------------
1854 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1856 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1857 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1858 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1859 dnl since it is interwoven with GNU extensions.
1861 dnl Well, yes we could work around it...
1864 dnl $1 is the nominal value for _XOPEN_SOURCE
1865 AC_DEFUN([CF_GNU_SOURCE],
1867 cf_gnu_xopen_source=ifelse($1,,500,$1)
1869 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1870 AC_TRY_COMPILE([#include <sys/types.h>],[
1871 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1873 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1876 # error not GNU C library
1878 [cf_cv_gnu_library=yes],
1879 [cf_cv_gnu_library=no])
1882 if test x$cf_cv_gnu_library = xyes; then
1884 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1885 # was changed to help a little. newlib incorporated the change about 4
1887 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1889 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1890 AC_TRY_COMPILE([#include <sys/types.h>],[
1891 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1893 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1896 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1898 [cf_cv_gnu_library_219=yes],
1899 [cf_cv_gnu_library_219=no])
1903 if test "x$cf_cv_gnu_library_219" = xyes; then
1905 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1906 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1909 #include <sys/types.h>
1911 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1914 # error GNU C library is too old
1916 [cf_cv_gnu_dftsrc_219=yes],
1917 [cf_cv_gnu_dftsrc_219=no])
1919 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1921 cf_cv_gnu_dftsrc_219=maybe
1924 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1926 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1927 AC_TRY_COMPILE([#include <sys/types.h>],[
1928 #ifndef _XOPEN_SOURCE
1929 #error expected _XOPEN_SOURCE to be defined
1931 [cf_cv_gnu_source=no],
1932 [cf_save="$CPPFLAGS"
1933 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1934 AC_TRY_COMPILE([#include <sys/types.h>],[
1935 #ifdef _XOPEN_SOURCE
1936 #error expected _XOPEN_SOURCE to be undefined
1938 [cf_cv_gnu_source=no],
1939 [cf_cv_gnu_source=yes])
1944 if test "$cf_cv_gnu_source" = yes
1946 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1947 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1948 AC_TRY_COMPILE([#include <sys/types.h>],[
1949 #ifdef _DEFAULT_SOURCE
1950 #error expected _DEFAULT_SOURCE to be undefined
1952 [cf_cv_default_source=no],
1953 [cf_cv_default_source=yes])
1955 if test "$cf_cv_default_source" = yes
1957 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1964 dnl ---------------------------------------------------------------------------
1965 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
1967 dnl Construct a search-list of directories for a nonstandard header-file
1970 dnl $1 = the variable to return as result
1971 dnl $2 = the package name
1972 AC_DEFUN([CF_HEADER_PATH],
1976 # collect the current set of include-directories from compiler flags
1977 cf_header_path_list=""
1978 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1979 for cf_header_path in $CPPFLAGS $CFLAGS
1981 case "$cf_header_path" in
1983 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1984 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1985 cf_header_path_list="$cf_header_path_list [$]$1"
1991 # add the variations for the package we are looking for
1992 CF_SUBDIR_PATH($1,$2,include)
1994 test "$includedir" != NONE && \
1995 test "$includedir" != "/usr/include" && \
1996 test -d "$includedir" && {
1997 test -d "$includedir" && $1="[$]$1 $includedir"
1998 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2001 test "$oldincludedir" != NONE && \
2002 test "$oldincludedir" != "/usr/include" && \
2003 test -d "$oldincludedir" && {
2004 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2005 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2008 $1="[$]$1 $cf_header_path_list"
2010 dnl ---------------------------------------------------------------------------
2011 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2013 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2014 AC_DEFUN([CF_HELP_MESSAGE],
2015 [CF_ACVERSION_CHECK(2.53,[],[
2016 AC_DIVERT_HELP($1)])dnl
2018 dnl ---------------------------------------------------------------------------
2019 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2021 dnl Construct the list of include-options according to whether we're building
2022 dnl in the source directory or using '--srcdir=DIR' option.
2023 AC_DEFUN([CF_INCLUDE_DIRS],
2025 if test "$srcdir" != "."; then
2026 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2028 CPPFLAGS="-I../include $CPPFLAGS"
2029 if test "$srcdir" != "."; then
2030 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2032 CPPFLAGS="-I. $CPPFLAGS"
2035 dnl ---------------------------------------------------------------------------
2036 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2038 dnl prompt for/fill-in useful install-program options
2039 AC_DEFUN([CF_INSTALL_OPTS],
2045 dnl ---------------------------------------------------------------------------
2046 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2047 dnl ----------------
2048 dnl Almost all "install" programs default to the current user's ownership.
2049 dnl Almost - MINIX is an exception.
2050 AC_DEFUN([CF_INSTALL_OPT_O],
2052 AC_MSG_CHECKING(if install needs to be told about ownership)
2053 case `$ac_config_guess` in
2062 AC_MSG_RESULT($with_install_o)
2063 if test "x$with_install_o" = xyes
2065 INSTALL_OPT_O="`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`"
2070 AC_SUBST(INSTALL_OPT_O)
2072 dnl ---------------------------------------------------------------------------
2073 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2074 dnl ----------------
2075 dnl Some install-programs accept a "-p" option to preserve file modification
2076 dnl timestamps. That can be useful as an install option, as well as a way to
2077 dnl avoid the need for ranlib after copying a static archive.
2078 AC_DEFUN([CF_INSTALL_OPT_P],
2080 : "${INSTALL:=install}"
2081 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2086 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2088 if test -f conftest.out/conftest.in
2090 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2091 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2092 if test -s conftest.err
2107 dnl ---------------------------------------------------------------------------
2108 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2109 dnl ----------------
2110 dnl By default, we should strip executables which are installed, but leave the
2111 dnl ability to suppress that for unit-testing.
2112 AC_DEFUN([CF_INSTALL_OPT_S],
2114 AC_MSG_CHECKING(if you want to install stripped executables)
2115 CF_ARG_DISABLE(stripping,
2116 [ --disable-stripping do not strip (debug info) installed executables],
2117 [enable_stripping=no],
2118 [enable_stripping=yes])
2119 AC_MSG_RESULT($enable_stripping)
2121 if test "$enable_stripping" = yes
2127 AC_SUBST(INSTALL_OPT_S)
2129 dnl ---------------------------------------------------------------------------
2130 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2131 dnl -----------------
2132 dnl Check if the given compiler is really the Intel compiler for Linux. It
2133 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2134 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2136 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2137 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2138 dnl the wrappers for gcc and g++ warnings.
2140 dnl $1 = GCC (default) or GXX
2141 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2142 dnl $3 = CFLAGS (default) or CXXFLAGS
2143 AC_DEFUN([CF_INTEL_COMPILER],[
2144 AC_REQUIRE([AC_CANONICAL_HOST])
2145 ifelse([$2],,INTEL_COMPILER,[$2])=no
2147 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2150 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2151 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2152 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2154 #ifdef __INTEL_COMPILER
2158 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2159 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2161 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2162 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2167 dnl ---------------------------------------------------------------------------
2168 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2170 dnl Add checks for large file support.
2171 AC_DEFUN([CF_LARGEFILE],[
2172 ifdef([AC_FUNC_FSEEKO],[
2174 if test "$enable_largefile" != no ; then
2177 # Normally we would collect these definitions in the config.h,
2178 # but (like _XOPEN_SOURCE), some environments rely on having these
2179 # defined before any of the system headers are included. Another
2180 # case comes up with C++, e.g., on AIX the compiler compiles the
2181 # header files by themselves before looking at the body files it is
2182 # told to compile. For ncurses, those header files do not include
2184 if test "$ac_cv_sys_large_files" != no
2186 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2188 if test "$ac_cv_sys_largefile_source" != no
2190 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2192 if test "$ac_cv_sys_file_offset_bits" != no
2194 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2197 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2199 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2200 #include <sys/types.h>
2203 /* if transitional largefile support is setup, this is true */
2204 extern struct dirent64 * readdir(DIR *);
2205 struct dirent64 *x = readdir((DIR *)0);
2206 struct dirent *y = readdir((DIR *)0);
2210 [cf_cv_struct_dirent64=yes],
2211 [cf_cv_struct_dirent64=no])
2213 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2217 dnl ---------------------------------------------------------------------------
2218 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2220 dnl For the given system and compiler, find the compiler flags to pass to the
2221 dnl loader to use the "rpath" feature.
2222 AC_DEFUN([CF_LD_RPATH_OPT],
2224 AC_REQUIRE([CF_CHECK_CACHE])
2227 if test "x$cf_cv_enable_rpath" != xno
2229 AC_MSG_CHECKING(for an rpath option)
2230 case "$cf_cv_system_name" in
2232 if test "$GCC" = yes; then
2233 LD_RPATH_OPT="-Wl,-rpath,"
2235 LD_RPATH_OPT="-rpath "
2238 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2239 LD_RPATH_OPT="-Wl,-rpath,"
2241 (openbsd[[2-9]].*|mirbsd*)
2242 LD_RPATH_OPT="-Wl,-rpath,"
2245 LD_RPATH_OPT="-rpath "
2248 LD_RPATH_OPT="-Wl,-rpath,"
2251 LD_RPATH_OPT="-rpath "
2259 AC_MSG_RESULT($LD_RPATH_OPT)
2261 case "x$LD_RPATH_OPT" in
2263 AC_MSG_CHECKING(if we need a space after rpath option)
2264 cf_save_LIBS="$LIBS"
2265 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2266 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2267 LIBS="$cf_save_LIBS"
2268 AC_MSG_RESULT($cf_rpath_space)
2269 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2274 dnl ---------------------------------------------------------------------------
2275 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2277 dnl Construct a search-list of directories for a nonstandard library-file
2280 dnl $1 = the variable to return as result
2281 dnl $2 = the package name
2282 AC_DEFUN([CF_LIBRARY_PATH],
2285 cf_library_path_list=""
2286 if test -n "${LDFLAGS}${LIBS}" ; then
2287 for cf_library_path in $LDFLAGS $LIBS
2289 case "$cf_library_path" in
2291 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2292 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2293 cf_library_path_list="$cf_library_path_list [$]$1"
2299 CF_SUBDIR_PATH($1,$2,lib)
2301 $1="$cf_library_path_list [$]$1"
2303 dnl ---------------------------------------------------------------------------
2304 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2306 dnl Compute the library-prefix for the given host system
2307 dnl $1 = variable to set
2308 define([CF_LIB_PREFIX],
2310 case "$cf_cv_system_name" in
2312 if test "$DFT_LWR_MODEL" = libtool; then
2321 (*) LIB_PREFIX='lib'
2324 ifelse($1,,,[$1=$LIB_PREFIX])
2325 AC_SUBST(LIB_PREFIX)
2327 dnl ---------------------------------------------------------------------------
2328 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2330 dnl Compute the library file-suffix from the given model name
2332 dnl $2 = variable to set (the nominal library suffix)
2333 dnl $3 = dependency variable to set (actual filename)
2334 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2335 AC_DEFUN([CF_LIB_SUFFIX],
2343 case "$cf_cv_system_name" in
2354 case "$cf_cv_system_name" in
2365 case "$cf_cv_system_name" in
2374 (cygwin*|msys*|mingw*)
2412 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2414 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2415 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2418 dnl ---------------------------------------------------------------------------
2419 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2421 dnl Compute the string to append to -library from the given model name
2423 dnl $2 = variable to set
2424 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2425 AC_DEFUN([CF_LIB_TYPE],
2431 (profile) $2='_p' ;;
2434 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2436 dnl ---------------------------------------------------------------------------
2437 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2438 dnl ----------------
2439 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2440 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2441 dnl have to provide wrappers for global tables to ensure they're linked
2443 AC_DEFUN([CF_LINK_DATAONLY],
2445 AC_MSG_CHECKING([if data-only library module links])
2446 AC_CACHE_VAL(cf_cv_link_dataonly,[
2448 cat >conftest.$ac_ext <<EOF
2449 #line __oline__ "configure"
2450 int testdata[[3]] = { 123, 456, 789 };
2452 if AC_TRY_EVAL(ac_compile) ; then
2453 mv conftest.o data.o && \
2454 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2456 rm -f conftest.$ac_ext data.o
2457 cat >conftest.$ac_ext <<EOF
2458 #line __oline__ "configure"
2462 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2464 extern int testdata[[3]];
2465 return testdata[[0]] == 123
2466 && testdata[[1]] == 456
2467 && testdata[[2]] == 789;
2471 if AC_TRY_EVAL(ac_compile); then
2472 mv conftest.o func.o && \
2473 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2475 rm -f conftest.$ac_ext func.o
2476 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2478 LIBS="conftest.a $LIBS"
2482 extern int testfunc();
2483 ${cf_cv_main_return:-return} (!testfunc());
2486 [cf_cv_link_dataonly=yes],
2487 [cf_cv_link_dataonly=no],
2488 [cf_cv_link_dataonly=unknown])
2491 AC_MSG_RESULT($cf_cv_link_dataonly)
2493 if test "$cf_cv_link_dataonly" = no ; then
2494 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2497 AC_SUBST(BROKEN_LINKER)
2500 dnl ---------------------------------------------------------------------------
2501 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2503 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2504 dnl options to lower-levels. It is very useful for "make -n" -- if we have it.
2505 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2506 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2507 AC_DEFUN([CF_MAKEFLAGS],
2508 [AC_REQUIRE([AC_PROG_FGREP])dnl
2510 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2512 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2514 cat >cf_makeflags.tmp <<CF_EOF
2517 @ echo '.$cf_option'
2519 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2520 case "$cf_result" in
2522 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2523 case "$cf_result" in
2524 (.*CC=*) cf_cv_makeflags=
2526 (*) cf_cv_makeflags=$cf_option
2534 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2538 rm -f cf_makeflags.tmp
2541 AC_SUBST(cf_cv_makeflags)
2543 dnl ---------------------------------------------------------------------------
2544 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2546 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2547 dnl acts as a placeholder.
2549 dnl The ".PHONY" feature was proposed in 2011 here
2550 dnl https://www.austingroupbugs.net/view.php?id=523
2551 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2553 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2554 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2556 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2557 dnl date unspecified).
2559 dnl + It was adopted in NetBSD make in June 1995.
2561 dnl + The other BSD make programs are derived from the NetBSD make (and for
2562 dnl that reason are not actually different "implementations").
2564 dnl + Some features of NetBSD make were actually adapted from pmake, which
2565 dnl began as a modified GNU make starting in 1993.
2567 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2568 dnl GNU make extension, but is less well known than the BSD make.
2569 AC_DEFUN([CF_MAKE_PHONY],[
2570 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2573 mkdir conftest || exit 1
2575 cat >makefile <<'CF_EOF'
2579 @echo "** making [$]@ [$](DATA)"
2581 @echo "** making [$]@ [$](DATA)"
2583 @echo "** making [$]@ [$](DATA)"
2584 echo [$](DATA) > [$]@
2586 @echo "** making [$]@ [$](DATA)"
2587 echo [$](DATA) > [$]@
2589 for cf_data in 1 2 3
2591 ${MAKE:-make} always DATA=$cf_data
2592 ${MAKE:-make} once DATA=$cf_data
2593 ${MAKE:-make} -t always once
2594 if test -f always ; then
2595 echo "no (case 1)" > ../conftest.tmp
2596 elif test ! -f always.out ; then
2597 echo "no (case 2)" > ../conftest.tmp
2598 elif test ! -f once.out ; then
2599 echo "no (case 3)" > ../conftest.tmp
2600 elif ! cmp -s always.out once.out ; then
2601 echo "no (case 4)" > ../conftest.tmp
2602 diff always.out once.out
2604 cf_check="`cat always.out`"
2605 if test "x$cf_check" != "x$cf_data" ; then
2606 echo "no (case 5)" > ../conftest.tmp
2608 echo yes > ../conftest.tmp
2616 cf_cv_make_PHONY="`cat conftest.tmp`"
2621 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2622 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2623 AC_SUBST(MAKE_NO_PHONY)
2624 AC_SUBST(MAKE_PHONY)
2626 dnl ---------------------------------------------------------------------------
2627 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2629 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2630 dnl a monocase filesystem.
2631 AC_DEFUN([CF_MAKE_TAGS],[
2632 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2634 AC_CHECK_PROGS(CTAGS, exctags ctags)
2635 AC_CHECK_PROGS(ETAGS, exetags etags)
2637 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2639 if test "$cf_cv_mixedcase" = yes ; then
2640 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2645 if test "$MAKE_UPPER_TAGS" = yes ; then
2651 if test "$MAKE_LOWER_TAGS" = yes ; then
2660 AC_SUBST(MAKE_UPPER_TAGS)
2661 AC_SUBST(MAKE_LOWER_TAGS)
2663 dnl ---------------------------------------------------------------------------
2664 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2665 dnl ----------------------
2666 dnl Check if the file-system supports mixed-case filenames. If we're able to
2667 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2668 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2670 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2671 if test "$cross_compiling" = yes ; then
2672 case "$target_alias" in
2673 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2681 rm -f conftest CONFTEST
2683 if test -f CONFTEST ; then
2688 rm -f conftest CONFTEST
2691 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2693 dnl ---------------------------------------------------------------------------
2694 dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
2696 dnl Check for a working mkstemp. This creates two files, checks that they are
2697 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2698 AC_DEFUN([CF_MKSTEMP],[
2702 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2705 #include <sys/types.h>
2706 #ifdef HAVE_UNISTD_H
2712 #include <sys/stat.h>
2715 char *tmpl = "conftestXXXXXX";
2723 for (n = 0; n < 2; ++n) {
2724 strcpy(name[n], tmpl);
2725 if ((fd = mkstemp(name[n])) >= 0) {
2726 if (!strcmp(name[n], tmpl)
2727 || stat(name[n], &sb) != 0
2728 || (sb.st_mode & S_IFMT) != S_IFREG
2729 || (sb.st_mode & 077) != 0) {
2736 && !strcmp(name[0], name[1]))
2738 ${cf_cv_main_return:-return}(result);
2740 ],[cf_cv_func_mkstemp=yes
2741 ],[cf_cv_func_mkstemp=no
2742 ],[cf_cv_func_mkstemp=maybe])
2744 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2745 AC_CHECK_FUNC(mkstemp)
2747 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2748 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2751 dnl ---------------------------------------------------------------------------
2752 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2754 dnl Write a debug message to config.log, along with the line number in the
2755 dnl configure script.
2756 AC_DEFUN([CF_MSG_LOG],[
2757 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2759 dnl ---------------------------------------------------------------------------
2760 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2761 dnl ----------------
2762 dnl Configure an ncurses add-on, built outside the ncurses tree.
2763 AC_DEFUN([CF_NCURSES_ADDON],[
2764 AC_REQUIRE([CF_NCURSES_CONFIG])
2766 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2768 AC_MSG_CHECKING(if you want wide-character code)
2769 AC_ARG_ENABLE(widec,
2770 [ --enable-widec compile with wide-char/UTF-8 code],
2771 [with_widec=$enableval],
2773 AC_MSG_RESULT($with_widec)
2774 if test "$with_widec" = yes ; then
2776 CF_NCURSES_CONFIG(ncursesw)
2778 CF_NCURSES_CONFIG(ncurses)
2781 if test "$NCURSES_CONFIG_PKG" != none ; then
2782 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2784 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2785 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2786 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2788 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2789 if test -z "$cf_cv_abi_version"
2791 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2794 elif test "$NCURSES_CONFIG" != none ; then
2796 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2798 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2799 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2800 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2802 # ABI version is not available from headers
2803 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2807 for cf_name in MAJOR MINOR PATCH
2809 cat >conftest.$ac_ext <<CF_EOF
2810 #include <${cf_cv_ncurses_header:-curses.h}>
2811 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2813 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2815 if test -f conftest.out ; then
2816 cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
2817 eval NCURSES_$cf_name=\"$cf_result\"
2818 # cat conftest.$ac_ext
2823 cf_cv_abi_version=${NCURSES_MAJOR}
2827 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2829 dnl Show the computed version, for logging
2830 cf_cv_timestamp=`date`
2832 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2834 dnl We need these values in the generated headers
2835 AC_SUBST(NCURSES_MAJOR)
2836 AC_SUBST(NCURSES_MINOR)
2837 AC_SUBST(NCURSES_PATCH)
2839 dnl We need these values in the generated makefiles
2840 AC_SUBST(cf_cv_rel_version)
2841 AC_SUBST(cf_cv_abi_version)
2843 dnl FIXME - not needed for Ada95
2844 AC_SUBST(cf_cv_builtin_bool)
2845 AC_SUBST(cf_cv_header_stdbool_h)
2846 AC_SUBST(cf_cv_type_of_bool)dnl
2849 dnl ---------------------------------------------------------------------------
2850 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2851 dnl -------------------
2852 dnl Check if we can compile with ncurses' header file
2853 dnl $1 is the cache variable to set
2854 dnl $2 is the header-file to include
2855 dnl $3 is the root name (ncurses or ncursesw)
2856 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2858 ]ifelse($3,ncursesw,[
2859 #define _XOPEN_SOURCE_EXTENDED
2860 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2861 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2864 #ifdef NCURSES_VERSION
2865 ]ifelse($3,ncursesw,[
2870 printf("%s\\n", NCURSES_VERSION);
2882 dnl ---------------------------------------------------------------------------
2883 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2884 dnl -----------------
2885 dnl Tie together the configure-script macros for ncurses, preferring these in
2887 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2888 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2889 dnl c) just plain libraries
2891 dnl $1 is the root library name (default: "ncurses")
2892 AC_DEFUN([CF_NCURSES_CONFIG],[
2893 AC_REQUIRE([CF_PKG_CONFIG])
2894 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2895 cf_have_ncuconfig=no
2897 if test "x${PKG_CONFIG:=none}" != xnone; then
2898 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2899 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2902 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2903 cf_have_ncuconfig=unknown
2905 cf_save_CFLAGS="$CFLAGS"
2906 cf_save_CPPFLAGS="$CPPFLAGS"
2907 cf_save_LIBS="$LIBS"
2909 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2910 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2912 # while -W for passing linker flags is prevalent, it is not "standard".
2913 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2914 # incompatible _and_ non-standard -W option which gives an error. Work
2915 # around that pitfall.
2916 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2918 CF_ADD_CFLAGS($cf_pkg_cflags)
2919 CF_ADD_LIBS($cf_pkg_libs)
2921 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2922 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2923 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2925 { const char *xx = curses_version(); return (xx == 0); }],
2926 [cf_test_ncuconfig=yes],
2927 [cf_test_ncuconfig=no],
2928 [cf_test_ncuconfig=maybe])],
2929 [cf_test_ncuconfig=no])
2931 CFLAGS="$cf_save_CFLAGS"
2932 CPPFLAGS="$cf_save_CPPFLAGS"
2933 LIBS="$cf_save_LIBS"
2935 if test "x$cf_test_ncuconfig" != xyes; then
2936 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2937 cf_pkg_cflags="$cf_temp"
2938 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2939 cf_pkg_libs="$cf_temp"
2944 CF_APPEND_CFLAGS($cf_pkg_cflags)
2945 CF_ADD_LIBS($cf_pkg_libs)
2947 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2948 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2949 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2951 { const char *xx = curses_version(); return (xx == 0); }],
2952 [cf_have_ncuconfig=yes],
2953 [cf_have_ncuconfig=no],
2954 [cf_have_ncuconfig=maybe])],
2955 [cf_have_ncuconfig=no])
2956 AC_MSG_RESULT($cf_have_ncuconfig)
2957 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2958 if test "$cf_have_ncuconfig" != "yes"
2960 CPPFLAGS="$cf_save_CPPFLAGS"
2961 LIBS="$cf_save_LIBS"
2962 NCURSES_CONFIG_PKG=none
2964 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2965 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2971 NCURSES_CONFIG_PKG=none
2974 NCURSES_CONFIG_PKG=none
2977 if test "x$cf_have_ncuconfig" = "xno"; then
2978 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2980 CF_ACVERSION_CHECK(2.52,
2981 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2982 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2984 if test "$NCURSES_CONFIG" != none ; then
2986 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
2987 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2989 # even with config script, some packages use no-override for curses.h
2990 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2992 dnl like CF_NCURSES_CPPFLAGS
2993 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2995 dnl like CF_NCURSES_LIBS
2996 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2997 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2999 dnl like CF_NCURSES_VERSION
3000 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3004 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3005 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3012 dnl ---------------------------------------------------------------------------
3013 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3014 dnl -------------------
3015 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3016 dnl the CPPFLAGS variable so we can include its header.
3018 dnl The header files may be installed as either curses.h, or ncurses.h (would
3019 dnl be obsolete, except that some packagers prefer this name to distinguish it
3020 dnl from a "native" curses implementation). If not installed for overwrite,
3021 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3022 dnl /usr/include/ncurses), but someone may have installed overwriting the
3023 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
3024 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3027 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3028 dnl is already in the include-path, don't even bother with this, since we cannot
3029 dnl easily determine which file it is. In this case, it has to be <curses.h>.
3031 dnl The optional parameter gives the root name of the library, in case it is
3032 dnl not installed as the default curses library. That is how the
3033 dnl wide-character version of ncurses is installed.
3034 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3035 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3037 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3038 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3040 test -n "$cf_cv_curses_dir" && \
3041 test "$cf_cv_curses_dir" != "no" && { \
3042 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3045 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3046 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3047 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3048 for cf_header in $cf_header_list
3050 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3051 test "$cf_cv_ncurses_h" != no && break
3058 # some applications need this, but should check for NCURSES_VERSION
3059 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3063 dnl ---------------------------------------------------------------------------
3064 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3065 dnl -----------------
3066 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3067 dnl variations of ncurses' installs.
3069 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3070 AC_DEFUN([CF_NCURSES_HEADER],[
3072 if test "$cf_cv_ncurses_h" != no ; then
3073 cf_cv_ncurses_header=$cf_cv_ncurses_h
3076 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3077 test -n "$verbose" && echo
3078 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3079 test -n "$verbose" && echo "search path $cf_search"
3080 cf_save2_CPPFLAGS="$CPPFLAGS"
3081 for cf_incdir in $cf_search
3083 CF_ADD_INCDIR($cf_incdir)
3088 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3089 if test "$cf_cv_ncurses_h2" != no ; then
3090 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3091 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
3094 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3096 CPPFLAGS="$cf_save2_CPPFLAGS"
3097 test "$cf_cv_ncurses_h2" != no && break
3099 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3102 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3103 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3104 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3105 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3107 CF_ADD_INCDIR($cf_1st_incdir)
3111 # Set definitions to allow ifdef'ing for ncurses.h
3113 case "$cf_cv_ncurses_header" in
3115 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3119 case "$cf_cv_ncurses_header" in
3120 (ncurses/curses.h|ncurses/ncurses.h)
3121 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3123 (ncursesw/curses.h|ncursesw/ncurses.h)
3124 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3129 dnl ---------------------------------------------------------------------------
3130 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3132 dnl Look for the ncurses library. This is a little complicated on Linux,
3133 dnl because it may be linked with the gpm (general purpose mouse) library.
3134 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3135 dnl unusable with ncurses. However, we don't want to link with gpm unless
3136 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3137 dnl and the linker will record a dependency.
3139 dnl The optional parameter gives the root name of the library, in case it is
3140 dnl not installed as the default curses library. That is how the
3141 dnl wide-character version of ncurses is installed.
3142 AC_DEFUN([CF_NCURSES_LIBS],
3143 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3145 cf_nculib_root=ifelse($1,,ncurses,$1)
3146 # This works, except for the special case where we find gpm, but
3147 # ncurses is in a nonstandard location via $LIBS, and we really want
3150 cf_ncurses_SAVE="$LIBS"
3151 AC_CHECK_LIB(gpm,Gpm_Open,
3152 [AC_CHECK_LIB(gpm,initscr,
3153 [LIBS="$cf_ncurses_SAVE"],
3154 [cf_ncurses_LIBS="-lgpm"])])
3158 # This is only necessary if you are linking against an obsolete
3159 # version of ncurses (but it should do no harm, since it is static).
3160 if test "$cf_nculib_root" = ncurses ; then
3161 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3166 CF_ADD_LIBS($cf_ncurses_LIBS)
3168 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3170 CF_ADD_LIBS(-l$cf_nculib_root)
3172 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3173 [#include <${cf_cv_ncurses_header:-curses.h}>],
3178 if test -n "$cf_ncurses_LIBS" ; then
3179 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3180 cf_ncurses_SAVE="$LIBS"
3181 for p in $cf_ncurses_LIBS ; do
3182 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3183 if test "$q" != "$LIBS" ; then
3187 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3188 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3189 [AC_MSG_RESULT(yes)],
3191 LIBS="$cf_ncurses_SAVE"])
3194 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3195 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3197 dnl ---------------------------------------------------------------------------
3198 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
3199 dnl ------------------
3200 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3201 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3202 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3203 AC_DEFUN([CF_NCURSES_VERSION],
3205 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3206 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3207 cf_cv_ncurses_version=no
3209 rm -f "$cf_tempfile"
3211 #include <${cf_cv_ncurses_header:-curses.h}>
3215 FILE *fp = fopen("$cf_tempfile", "w");
3216 #ifdef NCURSES_VERSION
3217 # ifdef NCURSES_VERSION_PATCH
3218 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3220 fprintf(fp, "%s\\n", NCURSES_VERSION);
3224 fprintf(fp, "old\\n");
3229 ${cf_cv_main_return:-return}(0);
3231 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3233 # This will not work if the preprocessor splits the line after the
3234 # Autoconf token. The 'unproto' program does that.
3235 cat > "conftest.$ac_ext" <<EOF
3236 #include <${cf_cv_ncurses_header:-curses.h}>
3238 #ifdef NCURSES_VERSION
3239 Autoconf NCURSES_VERSION
3247 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3249 if test -f conftest.out ; then
3250 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3251 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3255 rm -f "$cf_tempfile"
3257 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3259 dnl ---------------------------------------------------------------------------
3260 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3262 dnl Compute the object-directory name from the given model name
3263 AC_DEFUN([CF_OBJ_SUBDIR],
3266 (libtool) $2='obj_lo' ;;
3267 (normal) $2='objects' ;;
3268 (debug) $2='obj_g' ;;
3269 (profile) $2='obj_p' ;;
3271 case "$cf_cv_system_name" in
3279 dnl ---------------------------------------------------------------------------
3280 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3282 dnl Provide a value for the $PATH and similar separator (or amend the value
3283 dnl as provided in autoconf 2.5x).
3284 AC_DEFUN([CF_PATHSEP],
3286 AC_MSG_CHECKING(for PATH separator)
3287 case "$cf_cv_system_name" in
3288 (os2*) PATH_SEPARATOR=';' ;;
3289 (*) ${PATH_SEPARATOR:=':'} ;;
3291 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3292 AC_SUBST(PATH_SEPARATOR)
3293 AC_MSG_RESULT($PATH_SEPARATOR)
3295 dnl ---------------------------------------------------------------------------
3296 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3298 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3299 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3300 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3301 dnl delayed evaluation of those symbols.
3302 AC_DEFUN([CF_PATH_SYNTAX],[
3303 if test "x$prefix" != xNONE; then
3304 cf_path_syntax="$prefix"
3306 cf_path_syntax="$ac_default_prefix"
3310 (.\[$]\(*\)*|.\'*\'*)
3314 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3316 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3320 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3325 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3328 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3332 dnl ---------------------------------------------------------------------------
3333 dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
3335 dnl Check for the package-config program, unless disabled by command-line.
3336 AC_DEFUN([CF_PKG_CONFIG],
3338 AC_MSG_CHECKING(if you want to use pkg-config)
3339 AC_ARG_WITH(pkg-config,
3340 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3341 [cf_pkg_config=$withval],
3342 [cf_pkg_config=yes])
3343 AC_MSG_RESULT($cf_pkg_config)
3345 case "$cf_pkg_config" in
3350 CF_ACVERSION_CHECK(2.52,
3351 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3352 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3359 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3360 if test "$PKG_CONFIG" != none ; then
3361 CF_PATH_SYNTAX(PKG_CONFIG)
3362 elif test "x$cf_pkg_config" != xno ; then
3363 AC_MSG_WARN(pkg-config is not installed)
3366 AC_SUBST(PKG_CONFIG)
3368 dnl ---------------------------------------------------------------------------
3369 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3370 dnl -----------------
3371 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3373 dnl POSIX.1-1990 _POSIX_SOURCE
3374 dnl POSIX.1-1990 and _POSIX_SOURCE and
3375 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3377 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3378 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3379 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3382 dnl $1 is the nominal value for _POSIX_C_SOURCE
3383 AC_DEFUN([CF_POSIX_C_SOURCE],
3384 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3386 if test "$cf_cv_posix_visible" = no; then
3388 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3390 cf_save_CFLAGS="$CFLAGS"
3391 cf_save_CPPFLAGS="$CPPFLAGS"
3393 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3394 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3396 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3397 CF_MSG_LOG(if the symbol is already defined go no further)
3398 AC_TRY_COMPILE([#include <sys/types.h>],[
3399 #ifndef _POSIX_C_SOURCE
3402 [cf_cv_posix_c_source=no],
3403 [cf_want_posix_source=no
3404 case .$cf_POSIX_C_SOURCE in
3406 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3409 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3410 cf_want_posix_source=yes
3413 cf_want_posix_source=yes
3416 if test "$cf_want_posix_source" = yes ; then
3417 AC_TRY_COMPILE([#include <sys/types.h>],[
3418 #ifdef _POSIX_SOURCE
3421 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3423 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3424 CFLAGS="$cf_trim_CFLAGS"
3425 CPPFLAGS="$cf_trim_CPPFLAGS"
3426 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3427 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3428 AC_TRY_COMPILE([#include <sys/types.h>],[
3429 #ifndef _POSIX_C_SOURCE
3432 [cf_cv_posix_c_source=no])
3433 CFLAGS="$cf_save_CFLAGS"
3434 CPPFLAGS="$cf_save_CPPFLAGS"
3438 if test "$cf_cv_posix_c_source" != no ; then
3439 CFLAGS="$cf_trim_CFLAGS"
3440 CPPFLAGS="$cf_trim_CPPFLAGS"
3441 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3444 fi # cf_cv_posix_visible
3447 dnl ---------------------------------------------------------------------------
3448 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3449 dnl ----------------
3450 dnl POSIX documents test-macros which an application may set before any system
3451 dnl headers are included to make features available.
3453 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3454 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3455 dnl recent features visible in the system header files unless the application
3456 dnl overrides the corresponding test-macros. Doing that introduces portability
3459 dnl This macro makes a special check for the symbols used for this, to avoid a
3460 dnl conflicting definition.
3461 AC_DEFUN([CF_POSIX_VISIBLE],
3463 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3464 AC_TRY_COMPILE([#include <stdio.h>],[
3465 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3466 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3467 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3468 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3469 #error conflicting symbols found
3471 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3474 dnl ---------------------------------------------------------------------------
3475 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3477 dnl Check for archiver "ar".
3478 AC_DEFUN([CF_PROG_AR],[
3479 AC_CHECK_TOOL(AR, ar, ar)
3481 dnl ---------------------------------------------------------------------------
3482 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3484 dnl Check for awk, ensure that the check found something.
3485 AC_DEFUN([CF_PROG_AWK],
3488 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3490 dnl ---------------------------------------------------------------------------
3491 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3493 dnl standard check for CC, plus followup sanity checks
3494 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3495 AC_DEFUN([CF_PROG_CC],[
3496 CF_ACVERSION_CHECK(2.53,
3497 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3498 AC_REQUIRE([AC_PROG_CC])],
3500 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3502 CF_ACVERSION_CHECK(2.52,
3507 dnl ---------------------------------------------------------------------------
3508 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3510 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3511 dnl the output file can be renamed, and allows for a shell variable that can
3512 dnl be used later. The parameter is either CC or CXX. The result is the
3514 dnl $cf_cv_prog_CC_c_o
3515 dnl $cf_cv_prog_CXX_c_o
3518 dnl $2 = compiler options, if any
3519 AC_DEFUN([CF_PROG_CC_C_O],
3520 [AC_REQUIRE([AC_PROG_CC])dnl
3521 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3522 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3524 cat > conftest.$ac_ext <<CF_EOF
3527 ${cf_cv_main_return:-return}(0);
3530 # We do the test twice because some compilers refuse to overwrite an
3531 # existing .o file with -o, though they will create one.
3532 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3533 if AC_TRY_EVAL(ac_try) &&
3534 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3536 eval cf_cv_prog_$1_c_o=yes
3538 eval cf_cv_prog_$1_c_o=no
3542 if test "$cf_cv_prog_$1_c_o" = yes; then
3543 AC_MSG_RESULT([yes])
3548 dnl ---------------------------------------------------------------------------
3549 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3551 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3552 dnl This macro adds a check to ensure the script found something.
3553 AC_DEFUN([CF_PROG_EGREP],
3554 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3555 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3556 then ac_cv_prog_egrep='grep -E'
3557 else ac_cv_prog_egrep='egrep'
3559 EGREP=$ac_cv_prog_egrep
3561 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3563 dnl ---------------------------------------------------------------------------
3564 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3566 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3567 AC_DEFUN([CF_PROG_EXT],
3569 AC_REQUIRE([CF_CHECK_CACHE])
3570 case "$cf_cv_system_name" in
3572 CFLAGS="$CFLAGS -Zmt"
3573 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3574 CXXFLAGS="$CXXFLAGS -Zmt"
3575 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3576 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3586 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3588 dnl ---------------------------------------------------------------------------
3589 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
3591 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3592 AC_DEFUN([CF_PROG_GNAT],[
3593 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3595 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3597 unset ac_cv_path_cf_TEMP_gnat
3599 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3600 eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
3602 if test "x$cf_TEMP_gnat" != xno; then
3603 unset cf_cv_gnat_version
3605 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3607 eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
3610 unset cf_cv_gnat_version
3611 unset ac_cv_path_cf_TEMP_gnat
3614 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3616 cf_cv_prog_gnat_correct=no
3618 cf_ada_make=gnatmake
3619 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3620 # gprconfig is newer than gnatmake; we can continue...
3623 rm -rf ./conftest* ./*~conftest*
3624 if mkdir conftest.src
3628 for cf_gprconfig in Ada C
3630 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3631 if test "$cf_gprconfig" = C
3633 for cf_gprconfig_param in \
3634 "$cf_gprconfig,,,,GNATGCC" \
3635 "$cf_gprconfig,,,,GCC" \
3638 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3639 test -n "$cf_gprconfig_value" && break
3642 cf_gprconfig_param=$cf_gprconfig
3643 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3645 if test -n "$cf_gprconfig_value"
3647 eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
3648 AC_MSG_RESULT($cf_gprconfig_value)
3650 AC_MSG_RESULT(missing)
3656 rm -rf ./conftest* ./*~conftest*
3659 if test "x$cf_ada_config" != "x#"
3662 CF_CHECK_GNAT_VERSION
3663 AC_CHECK_PROG(M4_exists, m4, yes, no)
3664 if test "$ac_cv_prog_M4_exists" = no; then
3665 cf_cv_prog_gnat_correct=no
3666 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3668 if test "$cf_cv_prog_gnat_correct" = yes; then
3669 AC_MSG_CHECKING(if GNAT works)
3670 CF_GNAT_TRY_RUN([procedure conftest;],
3673 procedure conftest is
3675 Text_IO.Put ("Hello World");
3677 GNAT.OS_Lib.OS_Exit (0);
3679 [cf_cv_prog_gnat_correct=yes],
3680 [cf_cv_prog_gnat_correct=no])
3681 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3684 cf_cv_prog_gnat_correct=no
3688 AC_SUBST(cf_ada_make)
3689 AC_SUBST(cf_ada_config)
3690 AC_SUBST(cf_ada_config_Ada)
3691 AC_SUBST(cf_ada_config_C)
3693 dnl ---------------------------------------------------------------------------
3694 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3696 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3697 dnl misc/tabset install won't work properly. Usually this happens only when
3698 dnl using the fallback mkinstalldirs script
3699 AC_DEFUN([CF_PROG_INSTALL],
3705 CF_DIRNAME(cf_dir,$INSTALL)
3706 test -z "$cf_dir" && cf_dir=.
3707 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3711 dnl ---------------------------------------------------------------------------
3712 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3714 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3715 dnl option if it is supported.
3716 AC_DEFUN([CF_PROG_LN_S],[
3718 AC_MSG_CHECKING(if $LN_S -f options work)
3720 rm -f conf$$.src conf$$dst
3722 echo first >conf$$.src
3723 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3728 rm -f conf$$.dst conf$$src
3729 AC_MSG_RESULT($cf_prog_ln_sf)
3731 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3733 dnl ---------------------------------------------------------------------------
3734 dnl CF_REMOVE_CFLAGS version: 1 updated: 2021/08/28 15:20:37
3735 dnl ----------------
3736 dnl Remove a given option from CFLAGS/CPPFLAGS
3737 dnl $1 = option to remove
3738 dnl $2 = variable to update
3739 dnl $3 = nonempty to allow verbose message
3740 define([CF_REMOVE_CFLAGS],
3742 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3743 cf_old_cflag="[$]$2"
3747 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%$cf_tmp_cflag=[[^ ]]*%%g"`
3750 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%${cf_tmp_cflag}.%%"`
3753 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%$cf_tmp_cflag%%"`
3757 if test "[$]$2" != "$cf_old_cflag" ;
3759 ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3763 dnl ---------------------------------------------------------------------------
3764 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3765 dnl ----------------
3766 dnl Remove all -U and -D options that refer to the given symbol from a list
3767 dnl of C compiler options. This works around the problem that not all
3768 dnl compilers process -U and -D options from left-to-right, so a -U option
3769 dnl cannot be used to cancel the effect of a preceding -D option.
3771 dnl $1 = target (which could be the same as the source variable)
3772 dnl $2 = source (including '$')
3773 dnl $3 = symbol to remove
3774 define([CF_REMOVE_DEFINE],
3777 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3778 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3780 dnl ---------------------------------------------------------------------------
3781 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3783 dnl Remove the given library from the symbol
3785 dnl $1 = target (which could be the same as the source variable)
3786 dnl $2 = source (including '$')
3787 dnl $3 = library to remove
3788 define([CF_REMOVE_LIB],
3790 # remove $3 library from $2
3791 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3793 dnl ---------------------------------------------------------------------------
3794 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3795 dnl ---------------------
3796 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3797 dnl $1 = name of current macro
3798 define([CF_RESTORE_XTRA_FLAGS],
3800 LIBS="$cf_save_LIBS_$1"
3801 CFLAGS="$cf_save_CFLAGS_$1"
3802 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3804 dnl ---------------------------------------------------------------------------
3805 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3806 dnl ------------------
3807 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3808 dnl and libraries which do not update those variables.
3810 dnl $1 = name of current macro
3811 define([CF_SAVE_XTRA_FLAGS],
3813 cf_save_LIBS_$1="$LIBS"
3814 cf_save_CFLAGS_$1="$CFLAGS"
3815 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3816 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3817 for cf_X_CFLAGS in $X_CFLAGS
3819 case "x$cf_X_CFLAGS" in
3821 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3824 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3829 dnl ---------------------------------------------------------------------------
3830 dnl CF_SHARED_OPTS version: 107 updated: 2021/09/04 06:47:34
3833 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3837 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3838 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3839 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3840 dnl shared library since that can lead to unexpected results at runtime.
3841 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3842 dnl libraries are compiled in ../../lib
3844 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3845 dnl to install symbolic links to the rel/abi versions of shared libraries.
3847 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3848 dnl version when making symbolic links.
3850 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3851 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3852 dnl (ex: libncurses.so.<ver>).
3854 dnl Some loaders leave 'so_locations' lying around. It is nice to clean up.
3855 AC_DEFUN([CF_SHARED_OPTS],
3857 AC_REQUIRE([CF_LD_RPATH_OPT])
3863 INSTALL_LIB="-m 644"
3864 : ${rel_builddir:=.}
3872 cf_cv_do_symlinks=no
3874 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3876 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3877 AC_ARG_WITH(shlib-version,
3878 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3879 [test -z "$withval" && withval=auto
3882 cf_cv_shlib_version=auto
3885 cf_cv_shlib_version=$withval
3888 AC_MSG_RESULT($withval)
3889 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3892 ],[cf_cv_shlib_version=auto])
3893 AC_MSG_RESULT($cf_cv_shlib_version)
3898 # Some less-capable ports of gcc support only -fpic
3902 if test "$GCC" = yes
3906 case "$cf_cv_system_name" in
3907 (*linux*) # e.g., PGI compiler
3913 if test "$cf_try_fPIC" = yes
3915 AC_MSG_CHECKING(which $CC option to use)
3916 cf_save_CFLAGS="$CFLAGS"
3917 for CC_SHARED_OPTS in -fPIC -fpic ''
3919 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3920 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3922 AC_MSG_RESULT($CC_SHARED_OPTS)
3923 CFLAGS="$cf_save_CFLAGS"
3926 cf_cv_shlib_version_infix=no
3928 case "$cf_cv_system_name" in
3929 (aix4.[3-9]*|aix[[5-7]]*)
3930 if test "$GCC" = yes; then
3931 CC_SHARED_OPTS='-Wl,-brtl'
3932 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3934 CC_SHARED_OPTS='-brtl'
3935 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3936 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3940 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3944 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3945 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3946 cf_cv_shlib_version=cygdll
3947 cf_cv_shlib_version_infix=cygdll
3950 cat >mk_shared_lib.sh <<-CF_EOF
3953 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3956 Linking shared library
3957 ** SHARED_LIB \[$]SHARED_LIB
3958 ** IMPORT_LIB \[$]IMPORT_LIB
3960 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3962 chmod +x mk_shared_lib.sh
3966 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3967 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3968 cf_cv_shlib_version=msysdll
3969 cf_cv_shlib_version_infix=msysdll
3972 cat >mk_shared_lib.sh <<-CF_EOF
3975 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3978 Linking shared library
3979 ** SHARED_LIB \[$]SHARED_LIB
3980 ** IMPORT_LIB \[$]IMPORT_LIB
3982 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3984 chmod +x mk_shared_lib.sh
3987 cf_try_cflags="no-cpp-precomp"
3988 CC_SHARED_OPTS="-dynamic"
3989 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3990 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3991 cf_cv_shlib_version_infix=yes
3992 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3993 cf_save_LDFLAGS=$LDFLAGS
3994 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3995 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3996 LDFLAGS=$cf_save_LDFLAGS])
3997 if test "$cf_cv_ldflags_search_paths_first" = yes; then
3998 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4003 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4006 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
4007 if test "$GCC" != yes; then
4010 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
4011 INSTALL_LIB="-m 555"
4014 # (tested with gcc 2.7.2 -- I don't have c89)
4015 if test "$GCC" = yes; then
4016 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4019 LD_SHARED_OPTS='-Wl,+b,${libdir}'
4021 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
4022 # HP-UX shared libraries must be executable, and should be
4023 # readonly to exploit a quirk in the memory manager.
4024 INSTALL_LIB="-m 555"
4027 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4028 if test "$cf_cv_shlib_version" = rel; then
4029 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4031 cf_shared_soname='`basename $[@]`'
4034 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
4037 if test "$cf_cv_enable_rpath" = yes ; then
4038 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4040 # tested with IRIX 5.2 and 'cc'.
4041 if test "$GCC" != yes; then
4042 CC_SHARED_OPTS='-KPIC'
4043 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4045 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4047 cf_cv_rm_so_locs=yes
4049 (linux*|gnu*|k*bsd*-gnu)
4050 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4051 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4052 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4054 if test "$cf_cv_enable_rpath" = yes ; then
4055 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4058 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4061 cf_cv_shlib_version=msvcdll
4062 cf_cv_shlib_version_infix=msvcdll
4065 if test "$DFT_LWR_MODEL" = "shared" ; then
4066 LOCAL_LDFLAGS="-link -dll"
4067 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4068 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
4071 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
4072 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
4073 cat >mk_shared_lib.sh <<-CF_EOF
4076 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
4081 Linking shared library
4082 ** SHARED LIB \$SHARED_LIB
4083 ** IMPORT_LIB \$IMPORT_LIB
4085 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
4086 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
4087 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
4089 chmod +x mk_shared_lib.sh
4090 cat >mk_prog.sh <<-CF_EOF
4093 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
4096 ldopts=("/subsystem:console")
4099 while test \[$]# -gt 0; do
4102 # ignore -link argument
4104 -M[[TD]] | -M[[TD]]d)
4105 # ignore runtime-library option
4120 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
4123 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
4129 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
4130 ldopts+=("\[$]{linkarg}")
4138 ldopts+=("-out:\[$]1")
4147 if [[ "\$isdll" -ne 0 ]]; then
4148 for lib in \[$]{libs[[*]]}; do
4149 ldopts+=("\[$]lib.dll.lib")
4152 for lib in \[$]{libs[[*]]}; do
4153 ldopts+=("\[$]lib.lib")
4158 ** ld options: "\[$]{ldopts[[@]]}"
4160 exec \[$]LD \[$]{ldopts[[@]]}
4163 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
4164 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
4167 cf_cv_shlib_version=mingw
4168 cf_cv_shlib_version_infix=mingw
4171 if test "$DFT_LWR_MODEL" = "shared" ; then
4172 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
4173 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4174 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
4177 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4178 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4179 cat >mk_shared_lib.sh <<-CF_EOF
4182 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4185 Linking shared library
4186 ** SHARED_LIB \[$]SHARED_LIB
4187 ** IMPORT_LIB \[$]IMPORT_LIB
4189 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4191 chmod +x mk_shared_lib.sh
4193 (openbsd[[2-9]].*|mirbsd*)
4194 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4195 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4196 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4198 if test "$cf_cv_enable_rpath" = yes ; then
4199 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4201 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4203 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4207 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4211 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4213 (nto-qnx*|openbsd*|freebsd[[12]].*)
4214 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4215 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4216 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4218 (dragonfly*|freebsd*)
4219 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4220 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4221 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4222 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4223 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4226 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4229 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4230 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4231 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4232 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4233 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4234 if test "$cf_cv_shlib_version" = auto; then
4235 if test -f /usr/libexec/ld.elf_so; then
4236 cf_cv_shlib_version=abi
4238 cf_cv_shlib_version=rel
4242 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4244 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4248 # tested with OSF/1 V3.2 and 'cc'
4249 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4250 # link with shared libs).
4251 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4254 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4257 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4258 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4259 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4260 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4262 cf_cv_rm_so_locs=yes
4264 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
4265 # tested with osr5.0.5
4266 if test "$GCC" != yes; then
4267 CC_SHARED_OPTS='-belf -KPIC'
4269 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4270 if test "$cf_cv_enable_rpath" = yes ; then
4271 # only way is to set LD_RUN_PATH but no switch for it
4274 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4275 LINK_PROGS='LD_RUN_PATH=${libdir}'
4276 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4279 # tested with SunOS 4.1.1 and gcc 2.7.0
4280 if test "$GCC" != yes; then
4281 CC_SHARED_OPTS='-KPIC'
4283 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4284 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4287 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4288 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4289 if test "$DFT_LWR_MODEL" = "shared" ; then
4290 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4291 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4293 if test "$cf_cv_enable_rpath" = yes ; then
4294 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
4297 if test "$GCC" != yes; then
4298 cf_save_CFLAGS="$CFLAGS"
4299 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4301 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4302 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
4304 CFLAGS="$cf_save_CFLAGS"
4305 CC_SHARED_OPTS=$cf_shared_opts
4306 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4308 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4311 (sysv5uw7*|unix_sv*)
4312 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4313 if test "$GCC" != yes; then
4314 CC_SHARED_OPTS='-KPIC'
4316 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4319 CC_SHARED_OPTS='unknown'
4320 MK_SHARED_LIB='echo unknown'
4324 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4325 case "$cf_cv_shlib_version" in
4327 case "$MK_SHARED_LIB" in
4329 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4332 AC_MSG_WARN(ignored --with-shlib-version)
4338 if test -n "$cf_try_cflags"
4340 cat > conftest.$ac_ext <<EOF
4341 #line __oline__ "${as_me:-configure}"
4343 int main(int argc, char *argv[[]])
4346 return (argv[[argc-1]] == 0) ;
4349 cf_save_CFLAGS="$CFLAGS"
4350 for cf_opt in $cf_try_cflags
4352 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4353 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4354 if AC_TRY_EVAL(ac_compile); then
4356 cf_save_CFLAGS="$CFLAGS"
4361 CFLAGS="$cf_save_CFLAGS"
4365 # RPATH_LIST is a colon-separated list of directories
4366 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4367 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4369 test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4371 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4372 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4374 AC_SUBST(CC_SHARED_OPTS)
4375 AC_SUBST(LD_RPATH_OPT)
4376 AC_SUBST(LD_SHARED_OPTS)
4377 AC_SUBST(MK_SHARED_LIB)
4378 AC_SUBST(RM_SHARED_OPTS)
4380 AC_SUBST(LINK_PROGS)
4381 AC_SUBST(LINK_TESTS)
4383 AC_SUBST(EXTRA_LDFLAGS)
4384 AC_SUBST(LOCAL_LDFLAGS)
4385 AC_SUBST(LOCAL_LDFLAGS2)
4387 AC_SUBST(INSTALL_LIB)
4388 AC_SUBST(RPATH_LIST)
4390 dnl ---------------------------------------------------------------------------
4391 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4392 dnl ----------------
4393 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4394 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4397 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4398 dnl If missing, use "rel".
4399 define([CF_SHARED_SONAME],
4401 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4402 if test "$cf_cv_shlib_version" = rel; then
4403 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4405 cf_cv_shared_soname='`basename $[@]`'
4408 dnl ---------------------------------------------------------------------------
4409 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
4411 dnl Remove "-g" option from the compiler options
4412 AC_DEFUN([CF_STRIP_G_OPT],
4413 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
4414 dnl ---------------------------------------------------------------------------
4415 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4417 dnl Construct a search-list for a nonstandard header/lib-file
4418 dnl $1 = the variable to return as result
4419 dnl $2 = the package name
4420 dnl $3 = the subdirectory, e.g., bin, include or lib
4421 AC_DEFUN([CF_SUBDIR_PATH],
4425 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4427 for cf_subdir_prefix in \
4435 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4438 dnl ---------------------------------------------------------------------------
4439 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
4441 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4442 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4443 dnl but some packagers change this, breaking various applications.
4444 AC_DEFUN([CF_TERM_HEADER],[
4445 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4446 case "${cf_cv_ncurses_header}" in
4447 (*/ncurses.h|*/ncursesw.h)
4448 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4451 cf_term_header=term.h
4455 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4457 AC_TRY_COMPILE([#include <stdio.h>
4458 #include <${cf_cv_ncurses_header:-curses.h}>
4460 ],[int x = auto_left_margin; (void)x],[
4461 cf_cv_term_header="$cf_test"],[
4462 cf_cv_term_header=unknown
4464 test "$cf_cv_term_header" != unknown && break
4468 # Set definitions to allow ifdef'ing to accommodate subdirectories
4470 case "$cf_cv_term_header" in
4472 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4476 case "$cf_cv_term_header" in
4478 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4481 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4485 dnl ---------------------------------------------------------------------------
4486 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4488 dnl Define a top_builddir symbol, for applications that need an absolute path.
4489 AC_DEFUN([CF_TOP_BUILDDIR],
4491 top_builddir=ifelse($1,,`pwd`,$1)
4492 AC_SUBST(top_builddir)
4494 dnl ---------------------------------------------------------------------------
4495 dnl CF_TRY_XOPEN_SOURCE version: 3 updated: 2021/08/28 15:20:37
4496 dnl -------------------
4497 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4498 dnl can define it successfully.
4499 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4500 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4504 #include <sys/types.h>
4506 #ifndef _XOPEN_SOURCE
4509 [cf_cv_xopen_source=no],
4510 [cf_save="$CPPFLAGS"
4511 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4515 #include <sys/types.h>
4517 #ifdef _XOPEN_SOURCE
4520 [cf_cv_xopen_source=no],
4521 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4526 if test "$cf_cv_xopen_source" != no ; then
4527 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4528 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4529 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4530 CF_APPEND_CFLAGS($cf_temp_xopen_source)
4533 dnl ---------------------------------------------------------------------------
4534 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4536 dnl Make an uppercase version of a variable
4537 dnl $1=uppercase($2)
4538 AC_DEFUN([CF_UPPER],
4540 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4542 dnl ---------------------------------------------------------------------------
4543 dnl CF_UTF8_LIB version: 9 updated: 2021/05/19 19:35:25
4545 dnl Check for multibyte support, and if not found, utf8 compatibility library
4546 AC_DEFUN([CF_UTF8_LIB],
4548 AC_HAVE_HEADERS(wchar.h)
4549 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4550 cf_save_LIBS="$LIBS"
4558 [cf_cv_utf8_lib=yes],
4560 #include <libutf8.h>],[putwc(0,0);],utf8,
4561 [cf_cv_utf8_lib=add-on],
4562 [cf_cv_utf8_lib=no])
4565 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4567 if test "$cf_cv_utf8_lib" = "add-on" ; then
4568 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4569 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4570 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4571 CF_ADD_LIBS($cf_cv_library_file_utf8)
4574 dnl ---------------------------------------------------------------------------
4575 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4577 dnl Use AC_VERBOSE w/o the warnings
4578 AC_DEFUN([CF_VERBOSE],
4579 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4582 dnl ---------------------------------------------------------------------------
4583 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4585 dnl Check for compiler-support for weak symbols.
4586 dnl This works with "recent" gcc.
4587 AC_DEFUN([CF_WEAK_SYMBOLS],[
4588 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4591 #include <stdio.h>],
4593 #if defined(__GNUC__)
4594 # if defined __USE_ISOC99
4595 # define _cat_pragma(exp) _Pragma(#exp)
4596 # define _weak_pragma(exp) _cat_pragma(weak name)
4598 # define _weak_pragma(exp)
4600 # define _declare(name) __extension__ extern __typeof__(name) name
4601 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4605 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4608 dnl ---------------------------------------------------------------------------
4609 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4610 dnl --------------------
4611 dnl Command-line option to specify the Ada95 compiler.
4612 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4613 AC_MSG_CHECKING(for ada-compiler)
4614 AC_ARG_WITH(ada-compiler,
4615 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4616 [cf_ada_compiler=$withval],
4617 [cf_ada_compiler=gnatmake])
4618 AC_SUBST(cf_ada_compiler)
4619 AC_MSG_RESULT($cf_ada_compiler)
4621 dnl ---------------------------------------------------------------------------
4622 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4623 dnl -------------------
4624 dnl Command-line option to specify where Ada includes will install.
4625 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4626 AC_MSG_CHECKING(for ada-include)
4627 CF_WITH_PATH(ada-include,
4628 [ --with-ada-include=DIR Ada includes are in DIR],
4630 PREFIX/share/ada/adainclude,
4631 [$]prefix/share/ada/adainclude)
4632 AC_SUBST(ADA_INCLUDE)
4633 AC_MSG_RESULT($ADA_INCLUDE)
4635 dnl ---------------------------------------------------------------------------
4636 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4637 dnl -------------------
4638 dnl CF_WITH_ADA_LIBNAME
4639 dnl -------------------
4640 dnl Command-line option to specify how to name the resulting Ada library.
4641 dnl $1 = default value
4642 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4643 AC_MSG_CHECKING(for ada-libname)
4644 AC_ARG_WITH(ada-libname,
4645 [ --with-ada-libname=XXX override default Ada library-name],
4646 ADA_LIBNAME=[$]withval,
4648 case "x$ADA_LIBNAME" in
4653 AC_SUBST(ADA_LIBNAME)
4654 AC_MSG_RESULT($ADA_LIBNAME)
4656 dnl ---------------------------------------------------------------------------
4657 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4658 dnl -------------------
4659 dnl Command-line option to specify where Ada objects will install.
4660 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4661 AC_MSG_CHECKING(for ada-objects)
4662 CF_WITH_PATH(ada-objects,
4663 [ --with-ada-objects=DIR Ada objects are in DIR],
4665 PREFIX/lib/ada/adalib,
4666 [$]prefix/lib/ada/adalib)
4667 AC_SUBST(ADA_OBJECTS)
4668 AC_MSG_RESULT($ADA_OBJECTS)
4670 dnl ---------------------------------------------------------------------------
4671 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4672 dnl ---------------------
4673 dnl Command-line option to specify if an Ada95 shared-library should be built,
4674 dnl and optionally what its soname should be.
4675 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4676 AC_REQUIRE([CF_GNAT_PROJECTS])
4677 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4678 AC_ARG_WITH(ada-sharedlib,
4679 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4680 [with_ada_sharedlib=$withval],
4681 [with_ada_sharedlib=no])
4682 AC_MSG_RESULT($with_ada_sharedlib)
4684 if test "x$with_ada_sharedlib" != xno
4686 if test "x$cf_gnat_projects" != xyes
4688 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4689 with_ada_sharedlib=no
4693 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4694 MAKE_ADA_SHAREDLIB="#"
4696 if test "x$with_ada_sharedlib" != xno
4699 if test "x$with_ada_sharedlib" != xyes
4701 ADA_SHAREDLIB="$with_ada_sharedlib"
4705 AC_SUBST(ADA_SHAREDLIB)
4706 AC_SUBST(MAKE_ADA_SHAREDLIB)
4708 dnl ---------------------------------------------------------------------------
4709 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4710 dnl ------------------
4711 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4713 AC_DEFUN([CF_WITH_CURSES_DIR],[
4715 AC_MSG_CHECKING(for specific curses-directory)
4716 AC_ARG_WITH(curses-dir,
4717 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4718 [cf_cv_curses_dir=$withval],
4719 [cf_cv_curses_dir=no])
4720 AC_MSG_RESULT($cf_cv_curses_dir)
4722 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4724 CF_PATH_SYNTAX(withval)
4725 if test -d "$cf_cv_curses_dir"
4727 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4728 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4732 dnl ---------------------------------------------------------------------------
4733 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
4734 dnl ------------------
4735 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4736 dnl "lib" prefix, e.g., because it used the dll naming convention.
4738 dnl $1 = variable to set
4739 AC_DEFUN([CF_WITH_LIB_PREFIX],
4741 AC_MSG_CHECKING(if you want to have a library-prefix)
4742 AC_ARG_WITH(lib-prefix,
4743 [ --with-lib-prefix override library-prefix],
4744 [with_lib_prefix=$withval],
4745 [with_lib_prefix=auto])
4746 AC_MSG_RESULT($with_lib_prefix)
4748 if test "$with_lib_prefix" = auto
4751 elif test "$with_lib_prefix" = no
4755 LIB_PREFIX=$with_lib_prefix
4758 dnl ---------------------------------------------------------------------------
4759 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
4761 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4762 dnl defaulting to yes/no.
4764 dnl $1 = option name
4766 dnl $3 = environment variable to set
4767 dnl $4 = default value, shown in the help-message, must be a constant
4768 dnl $5 = default value, if it is an expression & cannot be in the help-message
4770 AC_DEFUN([CF_WITH_PATH],
4771 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4772 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4773 if ifelse([$5],,true,[test -n "$5"]) ; then
4774 CF_PATH_SYNTAX(withval)
4779 dnl ---------------------------------------------------------------------------
4780 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 11 updated: 2021/01/01 16:16:30
4781 dnl -------------------------
4782 dnl Allow the choice of the pkg-config library directory to be overridden.
4783 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4785 case "$PKG_CONFIG" in
4787 AC_MSG_CHECKING(for pkg-config library directory)
4790 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4794 PKG_CONFIG_LIBDIR=no
4795 AC_ARG_WITH(pkg-config-libdir,
4796 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4797 [PKG_CONFIG_LIBDIR=$withval],
4798 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
4800 case x$PKG_CONFIG_LIBDIR in
4804 # Look for the library directory using the same prefix as the executable
4805 if test "x$PKG_CONFIG" = xnone
4809 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
4812 # If you don't like using the default architecture, you have to specify the
4813 # intended library directory and corresponding compiler/linker options.
4815 # This case allows for Debian's 2014-flavor of multiarch, along with the
4816 # most common variations before that point. Some other variants spell the
4817 # directory differently, e.g., "pkg-config", and put it in unusual places.
4818 # pkg-config has always been poorly standardized, which is ironic...
4819 case x`(arch) 2>/dev/null` in
4822 $cf_path/lib/*64-linux-gnu \
4830 $cf_path/lib/*-linux-gnu \
4839 for cf_config in $cf_search_path
4841 CF_VERBOSE(checking $cf_config/pkgconfig)
4842 if test -d "$cf_config/pkgconfig"
4844 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
4845 AC_MSG_CHECKING(done)
4854 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
4855 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4858 AC_SUBST(PKG_CONFIG_LIBDIR)
4860 dnl ---------------------------------------------------------------------------
4861 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4863 dnl Check for POSIX thread library.
4864 AC_DEFUN([CF_WITH_PTHREAD],
4866 AC_MSG_CHECKING(if you want to link with the pthread library)
4867 AC_ARG_WITH(pthread,
4868 [ --with-pthread use POSIX thread library],
4869 [with_pthread=$withval],
4871 AC_MSG_RESULT($with_pthread)
4873 if test "$with_pthread" != no ; then
4874 AC_CHECK_HEADER(pthread.h,[
4875 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4877 for cf_lib_pthread in pthread c_r
4879 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4880 cf_save_LIBS="$LIBS"
4881 CF_ADD_LIB($cf_lib_pthread)
4883 #include <pthread.h>
4885 int rc = pthread_create(0,0,0,0);
4886 int r2 = pthread_mutexattr_settype(0, 0);
4887 ],[with_pthread=yes],[with_pthread=no])
4888 LIBS="$cf_save_LIBS"
4889 AC_MSG_RESULT($with_pthread)
4890 test "$with_pthread" = yes && break
4893 if test "$with_pthread" = yes ; then
4894 CF_ADD_LIB($cf_lib_pthread)
4895 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4897 AC_MSG_ERROR(Cannot link with pthread library)
4902 dnl ---------------------------------------------------------------------------
4903 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
4905 dnl For testing, override the derived host system-type which is used to decide
4906 dnl things such as the linker commands used to build shared libraries. This is
4907 dnl normally chosen automatically based on the type of system which you are
4908 dnl building on. We use it for testing the configure script.
4910 dnl This is different from the --host option: it is used only for testing parts
4911 dnl of the configure script which would not be reachable with --host since that
4912 dnl relies on the build environment being real, rather than mocked up.
4913 AC_DEFUN([CF_WITH_SYSTYPE],[
4914 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
4915 AC_ARG_WITH(system-type,
4916 [ --with-system-type=XXX test: override derived host system-type],
4917 [AC_MSG_WARN(overriding system type to $withval)
4918 cf_cv_system_name=$withval
4922 dnl ---------------------------------------------------------------------------
4923 dnl CF_XOPEN_SOURCE version: 59 updated: 2021/08/28 15:20:37
4925 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4926 dnl or adapt to the vendor's definitions to get equivalent functionality,
4927 dnl without losing the common non-POSIX features.
4930 dnl $1 is the nominal value for _XOPEN_SOURCE
4931 dnl $2 is the nominal value for _POSIX_C_SOURCE
4932 AC_DEFUN([CF_XOPEN_SOURCE],[
4933 AC_REQUIRE([AC_CANONICAL_HOST])
4934 AC_REQUIRE([CF_POSIX_VISIBLE])
4936 if test "$cf_cv_posix_visible" = no; then
4938 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4939 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4944 cf_xopen_source="-D_ALL_SOURCE"
4950 cf_xopen_source="-D_APPLE_C_SOURCE"
4953 cf_xopen_source="-D_DARWIN_C_SOURCE"
4956 (freebsd*|dragonfly*|midnightbsd*)
4957 # 5.x headers associate
4958 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4959 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4960 cf_POSIX_C_SOURCE=200112L
4962 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4965 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4968 cf_xopen_source="-D_HPUX_SOURCE"
4971 cf_xopen_source="-D_SGI_SOURCE"
4974 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4975 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4978 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4981 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4983 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4986 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4989 # OpenBSD 6.x has broken locale support, both compile-time and runtime.
4990 # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
4991 # Abusing the conformance level is a workaround.
4992 AC_MSG_WARN(this system does not provide usable locale support)
4993 cf_xopen_source="-D_BSD_SOURCE"
4997 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4998 cf_xopen_source="-D_BSD_SOURCE"
5002 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5005 cf_xopen_source="-D_OSF_SOURCE"
5008 cf_xopen_source="-D_QNX_SOURCE"
5011 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5014 cf_xopen_source="-D__EXTENSIONS__"
5015 cf_cv_xopen_source=broken
5017 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
5023 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5027 if test -n "$cf_xopen_source" ; then
5028 CF_APPEND_CFLAGS($cf_xopen_source,true)
5031 dnl In anything but the default case, we may have system-specific setting
5032 dnl which is still not guaranteed to provide all of the entrypoints that
5033 dnl _XOPEN_SOURCE would yield.
5034 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
5035 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
5036 AC_TRY_COMPILE([#include <stdlib.h>],[
5037 #ifndef _XOPEN_SOURCE
5040 [cf_XOPEN_SOURCE_set=yes],
5041 [cf_XOPEN_SOURCE_set=no])
5042 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
5043 if test "$cf_XOPEN_SOURCE_set" = yes
5045 AC_TRY_COMPILE([#include <stdlib.h>],[
5046 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
5049 [cf_XOPEN_SOURCE_set_ok=yes],
5050 [cf_XOPEN_SOURCE_set_ok=no])
5051 if test "$cf_XOPEN_SOURCE_set_ok" = no
5053 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
5059 fi # cf_cv_posix_visible
5061 dnl ---------------------------------------------------------------------------
5062 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
5063 dnl ------------------
5064 dnl Trim something using sed, then trim extra whitespace
5065 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
5066 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl