1 dnl***************************************************************************
2 dnl Copyright 2018-2023,2024 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.216 2024/06/01 21:38:29 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: 3 updated: 2021/09/05 17:25:40
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 case "x$cf_add_cflags" in
354 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
355 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
358 CF_ADD_CFLAGS([$cf_add_cflags],[$2])
361 dnl ---------------------------------------------------------------------------
362 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
364 dnl use this macro for appending text without introducing an extra blank at
366 define([CF_APPEND_TEXT],
368 test -n "[$]$1" && $1="[$]$1 "
371 dnl ---------------------------------------------------------------------------
372 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
374 dnl Allow user to disable a normally-on option.
375 AC_DEFUN([CF_ARG_DISABLE],
376 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
377 dnl ---------------------------------------------------------------------------
378 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
380 dnl Allow user to enable a normally-off option.
381 AC_DEFUN([CF_ARG_ENABLE],
382 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
383 dnl ---------------------------------------------------------------------------
384 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
386 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
392 dnl $3 = action to perform if option is not default
393 dnl $4 = action if perform if option is default
394 dnl $5 = default option value (either 'yes' or 'no')
395 AC_DEFUN([CF_ARG_OPTION],
396 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
397 if test "$enableval" != "$5" ; then
399 ,[ $3]) ifelse([$4],,,[
402 fi],[enableval=$5 ifelse([$4],,,[
406 dnl ---------------------------------------------------------------------------
407 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
409 dnl Check for suitable "ar" (archiver) options for updating an archive.
411 dnl In particular, handle some obsolete cases where the "-" might be omitted,
412 dnl as well as a workaround for breakage of make's archive rules by the GNU
413 dnl binutils "ar" program.
414 AC_DEFUN([CF_AR_FLAGS],[
415 AC_REQUIRE([CF_PROG_AR])
417 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
418 case "$cf_cv_system_name" in
421 cat >mk_static_lib.sh <<-EOF
426 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
428 chmod +x mk_static_lib.sh
429 AR=`pwd`/mk_static_lib.sh
432 cf_cv_ar_flags=unknown
433 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
436 # check if $ARFLAGS already contains this choice
437 if test "x$ARFLAGS" != "x" ; then
438 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
439 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
445 rm -f "conftest.$ac_cv_objext"
448 cat >"conftest.$ac_ext" <<EOF
449 #line __oline__ "configure"
450 int testdata[[3]] = { 123, 456, 789 };
452 if AC_TRY_EVAL(ac_compile) ; then
453 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
454 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
455 if test -f conftest.a ; then
456 cf_cv_ar_flags="$cf_ar_flags"
460 CF_VERBOSE(cannot compile test-program)
464 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
469 if test -n "$ARFLAGS" ; then
470 if test -n "$cf_cv_ar_flags" ; then
471 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
474 ARFLAGS=$cf_cv_ar_flags
479 dnl ---------------------------------------------------------------------------
480 dnl CF_BUILD_CC version: 12 updated: 2024/03/17 09:17:26
482 dnl If we're cross-compiling, allow the user to override the tools and their
483 dnl options. The configure script is oriented toward identifying the host
484 dnl compiler, etc., but we need a build compiler to generate parts of the
487 dnl $1 = default for $CPPFLAGS
488 dnl $2 = default for $LIBS
489 AC_DEFUN([CF_BUILD_CC],[
490 CF_ACVERSION_CHECK(2.52,,
491 [AC_REQUIRE([CF_PROG_EXT])])
492 if test "$cross_compiling" = yes ; then
494 # defaults that we might want to override
495 : ${BUILD_CFLAGS:=''}
496 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
497 : ${BUILD_LDFLAGS:=''}
498 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
499 : ${BUILD_EXEEXT:='$x'}
500 : ${BUILD_OBJEXT:='o'}
502 AC_ARG_WITH(build-cc,
503 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
504 [BUILD_CC="$withval"],
505 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
506 AC_MSG_CHECKING(for native build C compiler)
507 AC_MSG_RESULT($BUILD_CC)
509 AC_MSG_CHECKING(for native build C preprocessor)
510 AC_ARG_WITH(build-cpp,
511 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
512 [BUILD_CPP="$withval"],
513 [BUILD_CPP='${BUILD_CC} -E'])
514 AC_MSG_RESULT($BUILD_CPP)
516 AC_MSG_CHECKING(for native build C flags)
517 AC_ARG_WITH(build-cflags,
518 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
519 [BUILD_CFLAGS="$withval"])
520 AC_MSG_RESULT($BUILD_CFLAGS)
522 AC_MSG_CHECKING(for native build C preprocessor-flags)
523 AC_ARG_WITH(build-cppflags,
524 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
525 [BUILD_CPPFLAGS="$withval"])
526 AC_MSG_RESULT($BUILD_CPPFLAGS)
528 AC_MSG_CHECKING(for native build linker-flags)
529 AC_ARG_WITH(build-ldflags,
530 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
531 [BUILD_LDFLAGS="$withval"])
532 AC_MSG_RESULT($BUILD_LDFLAGS)
534 AC_MSG_CHECKING(for native build linker-libraries)
535 AC_ARG_WITH(build-libs,
536 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
537 [BUILD_LIBS="$withval"])
538 AC_MSG_RESULT($BUILD_LIBS)
540 # this assumes we're on Unix.
544 : ${BUILD_CC:='${CC}'}
546 AC_MSG_CHECKING(if the build-compiler "$BUILD_CC" works)
548 cf_save_crossed=$cross_compiling
549 cf_save_ac_link=$ac_link
551 cf_build_cppflags=$BUILD_CPPFLAGS
552 test "$cf_build_cppflags" = "#" && cf_build_cppflags=
553 ac_link='$BUILD_CC -o "conftest$ac_exeext" $BUILD_CFLAGS $cf_build_cppflags $BUILD_LDFLAGS "conftest.$ac_ext" $BUILD_LIBS >&AS_MESSAGE_LOG_FD'
555 AC_TRY_RUN([#include <stdio.h>
556 int main(int argc, char *argv[])
558 ${cf_cv_main_return:-return}(argc < 0 || argv == 0 || argv[0] == 0);
563 cf_ok_build_cc=unknown)
565 cross_compiling=$cf_save_crossed
566 ac_link=$cf_save_ac_link
568 AC_MSG_RESULT($cf_ok_build_cc)
570 if test "$cf_ok_build_cc" != yes
572 AC_MSG_ERROR([Cross-build requires two compilers.
573 Use --with-build-cc to specify the native compiler.])
577 : ${BUILD_CC:='${CC}'}
578 : ${BUILD_CPP:='${CPP}'}
579 : ${BUILD_CFLAGS:='${CFLAGS}'}
580 : ${BUILD_CPPFLAGS:='ifelse([$1],,'${CPPFLAGS}',[$1])'}
581 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
582 : ${BUILD_LIBS:='ifelse([$2],,'${LIBS}',[$2])'}
583 : ${BUILD_EXEEXT:='$x'}
584 : ${BUILD_OBJEXT:='o'}
589 AC_SUBST(BUILD_CFLAGS)
590 AC_SUBST(BUILD_CPPFLAGS)
591 AC_SUBST(BUILD_LDFLAGS)
593 AC_SUBST(BUILD_EXEEXT)
594 AC_SUBST(BUILD_OBJEXT)
596 dnl ---------------------------------------------------------------------------
597 dnl CF_C11_NORETURN version: 4 updated: 2023/02/18 17:41:25
599 AC_DEFUN([CF_C11_NORETURN],
601 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
602 CF_ARG_ENABLE(stdnoreturn,
603 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
604 [enable_stdnoreturn=yes],
605 [enable_stdnoreturn=no])
606 AC_MSG_RESULT($enable_stdnoreturn)
608 if test $enable_stdnoreturn = yes; then
609 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
612 #include <stdnoreturn.h>
613 static _Noreturn void giveup(void) { exit(0); }
615 [if (feof(stdin)) giveup()],
616 cf_cv_c11_noreturn=yes,
617 cf_cv_c11_noreturn=no)
620 cf_cv_c11_noreturn=no,
623 if test "$cf_cv_c11_noreturn" = yes; then
624 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
625 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
631 AC_SUBST(HAVE_STDNORETURN_H)
632 AC_SUBST(STDC_NORETURN)
634 dnl ---------------------------------------------------------------------------
635 dnl CF_CC_ENV_FLAGS version: 11 updated: 2023/02/20 11:15:46
637 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
638 dnl into CC. This will not help with broken scripts that wrap the compiler
639 dnl with options, but eliminates a more common category of user confusion.
641 dnl In particular, it addresses the problem of being able to run the C
642 dnl preprocessor in a consistent manner.
644 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
645 dnl the nuisance of having inconsistent settings for compiler and preprocessor
646 dnl outweighs that limitation.
647 AC_DEFUN([CF_CC_ENV_FLAGS],
649 # This should have been defined by AC_PROG_CC
652 AC_MSG_CHECKING(\$CFLAGS variable)
655 AC_MSG_RESULT(broken)
656 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
659 for cf_arg in $cf_flags
661 CF_ADD_CFLAGS($cf_arg)
669 AC_MSG_CHECKING(\$CC variable)
672 AC_MSG_RESULT(broken)
673 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
675 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
676 cf_flags=`echo "$CC" | sed -e "s%^$cf_prog%%"`
678 for cf_arg in $cf_flags
682 CF_ADD_CFLAGS($cf_arg)
689 CF_VERBOSE(resulting CC: '$CC')
690 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
691 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
698 dnl ---------------------------------------------------------------------------
699 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
701 dnl Determine the default configuration into which we'll install ncurses. This
702 dnl can be overridden by the user's command-line options. There's two items to
704 dnl 1. the prefix (e.g., /usr)
705 dnl 2. the header files (e.g., /usr/include/ncurses)
706 dnl We'll look for a previous installation of ncurses and use the same defaults.
708 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
709 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
710 dnl programs from a vendor's.
711 AC_DEFUN([CF_CFG_DEFAULTS],
712 [AC_REQUIRE([AC_PROG_FGREP])dnl
714 AC_MSG_CHECKING(for prefix)
715 if test "x$prefix" = "xNONE" ; then
716 case "$cf_cv_system_name" in
717 # non-vendor systems don't have a conflict
718 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
721 (*) prefix=$ac_default_prefix
725 AC_MSG_RESULT($prefix)
727 if test "x$prefix" = "xNONE" ; then
728 AC_MSG_CHECKING(for default include-directory)
729 test -n "$verbose" && echo 1>&AC_FD_MSG
732 "$includedir/ncurses" \
734 "$prefix/include/ncurses" \
736 /usr/local/include/ncurses \
740 cf_dir=`eval echo "$cf_symbol"`
741 if test -f "$cf_dir/curses.h" ; then
742 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
743 includedir="$cf_symbol"
744 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
748 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
750 AC_MSG_RESULT($includedir)
753 dnl ---------------------------------------------------------------------------
754 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
756 dnl Check if we're accidentally using a cache from a different machine.
757 dnl Derive the system name, as a check for reusing the autoconf cache.
759 dnl If we've packaged config.guess and config.sub, run that (since it does a
760 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
761 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
762 dnl which is useful in cross-compiles.
764 dnl Note: we would use $ac_config_sub, but that is one of the places where
765 dnl autoconf 2.5x broke compatibility with autoconf 2.13
766 AC_DEFUN([CF_CHECK_CACHE],
768 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
769 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
770 system_name="$host_os"
772 system_name="`(uname -s -r) 2>/dev/null`"
773 if test -z "$system_name" ; then
774 system_name="`(hostname) 2>/dev/null`"
777 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
778 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
780 test -z "$system_name" && system_name="$cf_cv_system_name"
781 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
783 if test ".$system_name" != ".$cf_cv_system_name" ; then
784 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
785 AC_MSG_ERROR("Please remove config.cache and try again.")
788 dnl ---------------------------------------------------------------------------
789 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
790 dnl ---------------------
791 AC_DEFUN([CF_CHECK_GNAT_VERSION],
793 AC_REQUIRE([CF_GNAT_VERSION])
794 case "$cf_cv_gnat_version" in
795 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
796 cf_cv_prog_gnat_correct=yes
799 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
800 cf_cv_prog_gnat_correct=no
804 dnl ---------------------------------------------------------------------------
805 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
807 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
808 dnl used in cross-compiling to MinGW.
809 AC_DEFUN([CF_CHECK_LIBSSP],[
810 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
812 #include <sys/types.h>
815 DIR *dp = opendir(".");
816 ],cf_cv_need_libssp=no,[
820 #include <sys/types.h>
823 DIR *dp = opendir(".");
824 ],cf_cv_need_libssp=yes,
825 cf_cv_need_libssp=maybe)
830 if test "x$cf_cv_need_libssp" = xyes
835 dnl ---------------------------------------------------------------------------
836 dnl CF_CLANG_COMPILER version: 9 updated: 2023/02/18 17:41:25
837 dnl -----------------
838 dnl Check if the given compiler is really clang. clang's C driver defines
839 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
840 dnl not ignore some gcc options.
842 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
843 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
844 dnl the wrappers for gcc and g++ warnings.
846 dnl $1 = GCC (default) or GXX
847 dnl $2 = CLANG_COMPILER (default)
848 dnl $3 = CFLAGS (default) or CXXFLAGS
849 AC_DEFUN([CF_CLANG_COMPILER],[
850 ifelse([$2],,CLANG_COMPILER,[$2])=no
852 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
853 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
854 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
858 #error __clang__ is not defined
860 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
862 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
863 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
868 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
870 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
871 AC_MSG_WARN(replacing broken compiler alias $CC)
872 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
877 AC_MSG_CHECKING(version of $CC)
878 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.]].*//'`"
879 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
880 AC_MSG_RESULT($CLANG_VERSION)
882 for cf_clang_opt in \
884 -Wno-error=implicit-function-declaration
886 AC_MSG_CHECKING(if option $cf_clang_opt works)
887 cf_save_CFLAGS="$CFLAGS"
888 CFLAGS="$CFLAGS $cf_clang_opt"
890 #include <stdio.h>],[
891 printf("hello!\\n");],[
892 cf_clang_optok=yes],[
894 AC_MSG_RESULT($cf_clang_optok)
895 CFLAGS="$cf_save_CFLAGS"
896 if test "$cf_clang_optok" = yes; then
897 CF_VERBOSE(adding option $cf_clang_opt)
898 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
903 dnl ---------------------------------------------------------------------------
904 dnl CF_CONST_X_STRING version: 8 updated: 2023/12/01 17:22:50
905 dnl -----------------
906 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
907 dnl character-strings.
909 dnl It is ambiguous because the specification accommodated the pre-ANSI
910 dnl compilers bundled by more than one vendor in lieu of providing a standard C
911 dnl compiler other than by costly add-ons. Because of this, the specification
912 dnl did not take into account the use of const for telling the compiler that
913 dnl string literals would be in readonly memory.
915 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
916 dnl let the compiler decide how to represent Xt's strings which were #define'd.
917 dnl That does not solve the problem of using the block of Xt's strings which
918 dnl are compiled into the library (and is less efficient than one might want).
920 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
921 dnl when compiling the library and compiling using the library, to tell the
922 dnl compiler that String is const.
923 AC_DEFUN([CF_CONST_X_STRING],
925 AC_REQUIRE([AC_PATH_XTRA])
927 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
932 #include <X11/Intrinsic.h>
934 [String foo = malloc(1); free((void*)foo)],[
936 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
939 #undef _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: 6 updated: 2022/12/02 20:06:52
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(); endwin()],
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: 4 updated: 2021/12/16 18:22:31
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
1310 for cf_temp_scan in [$]$1
1312 case "x$cf_temp_scan" in
1314 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1317 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1320 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1324 if test "x[$]$1" != "x$cf_temp_flags"
1326 CF_VERBOSE(repairing $1: [$]$1)
1328 CF_VERBOSE(... fixed [$]$1)
1329 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1334 AC_SUBST(EXTRA_CFLAGS)
1336 dnl ---------------------------------------------------------------------------
1337 dnl CF_FUNC_GETTIME version: 3 updated: 2024/05/11 13:40:02
1339 dnl Check for gettimeofday or clock_gettime. In 2023, the former is still more
1340 dnl widely supported, but "deprecated" (2008), so we will use the latter if it
1341 dnl is available, to reduce compiler warnings.
1342 AC_DEFUN([CF_FUNC_GETTIME],[
1343 cf_save_libs="$LIBS"
1344 AC_CHECK_FUNC(clock_gettime,
1345 cf_cv_test_clock_gettime=yes,
1346 AC_CHECK_LIB(rt, clock_gettime,
1348 cf_cv_test_clock_gettime=yes],
1349 cf_cv_test_clock_gettime=no))
1351 if test "$cf_cv_test_clock_gettime" = yes ; then
1352 AC_CACHE_CHECK(if clock_gettime links,cf_cv_func_clock_gettime,[
1354 $ac_includes_default
1357 [struct timespec ts;
1358 int rc = clock_gettime(CLOCK_REALTIME, &ts)
1359 + clock_gettime(CLOCK_MONOTONIC, &ts);
1360 (void) rc; (void)ts],
1361 [cf_cv_func_clock_gettime=yes],
1362 [cf_cv_func_clock_gettime=no])
1365 cf_cv_func_clock_gettime=no
1368 if test "$cf_cv_func_clock_gettime" = yes
1370 AC_DEFINE(HAVE_CLOCK_GETTIME,1,[Define to 1 if we have clock_gettime function])
1372 AC_CHECK_FUNC(gettimeofday,
1373 AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[
1375 AC_CHECK_LIB(bsd, gettimeofday,
1376 AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function])
1377 CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday
1380 dnl ---------------------------------------------------------------------------
1381 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1382 dnl -----------------
1383 dnl Test for availability of useful gcc __attribute__ directives to quiet
1384 dnl compiler warnings. Though useful, not all are supported -- and contrary
1385 dnl to documentation, unrecognized directives cause older compilers to barf.
1386 AC_DEFUN([CF_GCC_ATTRIBUTES],
1387 [AC_REQUIRE([AC_PROG_FGREP])dnl
1388 AC_REQUIRE([CF_C11_NORETURN])dnl
1390 if test "$GCC" = yes || test "$GXX" = yes
1392 cat > conftest.i <<EOF
1394 #define GCC_PRINTF 0
1399 #ifndef GCC_NORETURN
1400 #define GCC_NORETURN /* nothing */
1403 #define GCC_UNUSED /* nothing */
1406 if test "$GCC" = yes
1408 AC_CHECKING([for $CC __attribute__ directives])
1409 cat > "conftest.$ac_ext" <<EOF
1410 #line __oline__ "${as_me:-configure}"
1412 #include "confdefs.h"
1413 #include "conftest.h"
1414 #include "conftest.i"
1416 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1418 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1421 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1423 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1425 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1426 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1427 extern GCC_NORETURN void foo(void);
1428 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1430 cf_printf_attribute=no
1431 cf_scanf_attribute=no
1432 for cf_attribute in scanf printf unused noreturn
1434 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1435 cf_directive="__attribute__(($cf_attribute))"
1436 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1438 case "$cf_attribute" in
1440 cf_printf_attribute=yes
1441 cat >conftest.h <<EOF
1442 #define GCC_$cf_ATTRIBUTE 1
1446 cf_scanf_attribute=yes
1447 cat >conftest.h <<EOF
1448 #define GCC_$cf_ATTRIBUTE 1
1452 cat >conftest.h <<EOF
1453 #define GCC_$cf_ATTRIBUTE $cf_directive
1458 if AC_TRY_EVAL(ac_compile); then
1459 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1460 cat conftest.h >>confdefs.h
1461 case "$cf_attribute" in
1463 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1466 cf_value='/* nothing */'
1467 if test "$cf_printf_attribute" != no ; then
1468 cf_value='__attribute__((format(printf,fmt,var)))'
1469 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1471 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1474 cf_value='/* nothing */'
1475 if test "$cf_scanf_attribute" != no ; then
1476 cf_value='__attribute__((format(scanf,fmt,var)))'
1477 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1479 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1482 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1488 ${FGREP-fgrep} define conftest.i >>confdefs.h
1493 dnl ---------------------------------------------------------------------------
1494 dnl CF_GCC_VERSION version: 9 updated: 2023/03/05 14:30:13
1496 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1497 dnl compatible), attempt to determine if icc/clang is actually used.
1498 AC_DEFUN([CF_GCC_VERSION],[
1499 AC_REQUIRE([AC_PROG_CC])
1501 if test "$GCC" = yes ; then
1502 AC_MSG_CHECKING(version of $CC)
1503 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1504 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1505 AC_MSG_RESULT($GCC_VERSION)
1507 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1508 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1510 dnl ---------------------------------------------------------------------------
1511 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1513 dnl Check if the compiler supports useful warning options. There's a few that
1514 dnl we don't use, simply because they're too noisy:
1516 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1517 dnl -Winline (usually not worthwhile)
1518 dnl -Wredundant-decls (system headers make this too noisy)
1519 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1520 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1521 dnl is enabled for ncurses using "--enable-const".
1525 dnl $1 is an optional list of gcc warning flags that a particular
1526 dnl application might want to use, e.g., "no-unused" for
1529 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1531 AC_DEFUN([CF_GCC_WARNINGS],
1533 AC_REQUIRE([CF_GCC_VERSION])
1534 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1535 cat > "conftest.$ac_ext" <<EOF
1536 #line __oline__ "${as_me:-configure}"
1537 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1539 if test "$INTEL_COMPILER" = yes
1541 # The "-wdXXX" options suppress warnings:
1542 # remark #1419: external declaration in primary source file
1543 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1544 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1545 # remark #193: zero used for undefined preprocessing identifier
1546 # remark #593: variable "curs_sb_left_arrow" was set but never used
1547 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1548 # remark #869: parameter "tw" was never referenced
1549 # remark #981: operands are evaluated in unspecified order
1550 # warning #279: controlling expression is constant
1552 AC_CHECKING([for $CC warning options])
1553 cf_save_CFLAGS="$CFLAGS"
1554 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1566 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1567 if AC_TRY_EVAL(ac_compile); then
1568 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1569 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1572 CFLAGS="$cf_save_CFLAGS"
1573 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1575 AC_CHECKING([for $CC warning options])
1576 cf_save_CFLAGS="$CFLAGS"
1578 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1579 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1580 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1581 for cf_opt in W Wall \
1582 Wbad-function-cast \
1585 Wdeclaration-after-statement \
1588 Wmissing-declarations \
1589 Wmissing-prototypes \
1593 Wstrict-prototypes \
1594 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1596 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1597 if AC_TRY_EVAL(ac_compile); then
1598 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1601 case "$GCC_VERSION" in
1603 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1608 case "$GCC_VERSION" in
1610 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1615 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1618 CFLAGS="$cf_save_CFLAGS"
1622 AC_SUBST(EXTRA_CFLAGS)
1624 dnl ---------------------------------------------------------------------------
1625 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1626 dnl -----------------
1627 AC_DEFUN([CF_GNATPREP_OPT_T],[
1628 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1629 cf_cv_gnatprep_opt_t=no
1630 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1632 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1633 AC_SUBST(GNATPREP_OPTS)
1635 dnl ---------------------------------------------------------------------------
1636 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1637 dnl ----------------
1638 AC_DEFUN([CF_GNAT_GENERICS],
1640 AC_REQUIRE([CF_GNAT_VERSION])
1642 AC_MSG_CHECKING(if GNAT supports generics)
1643 case "$cf_cv_gnat_version" in
1644 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1645 cf_gnat_generics=yes
1651 AC_MSG_RESULT($cf_gnat_generics)
1653 if test "$cf_gnat_generics" = yes
1655 cf_compile_generics=generics
1656 cf_generic_objects="\${GENOBJS}"
1658 cf_compile_generics=
1662 AC_SUBST(cf_compile_generics)
1663 AC_SUBST(cf_generic_objects)
1665 dnl ---------------------------------------------------------------------------
1666 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1667 dnl ----------------
1668 dnl GNAT projects are configured with ".gpr" project files.
1669 dnl GNAT libraries are a further development, using the project feature.
1670 AC_DEFUN([CF_GNAT_PROJECTS],
1672 AC_REQUIRE([CF_GNAT_VERSION])
1673 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1675 cf_gnat_libraries=no
1678 if test "$enable_gnat_projects" != no ; then
1679 AC_MSG_CHECKING(if GNAT supports project files)
1680 case "$cf_cv_gnat_version" in
1684 case "$cf_cv_system_name" in
1688 rm -rf ./conftest* ./*~conftest*
1689 if mkdir conftest.src conftest.bin conftest.lib
1692 rm -rf ./conftest* ./*~conftest*
1693 cat >>library.gpr <<CF_EOF
1695 Kind := External ("LIB_KIND");
1696 for Library_Name use "ConfTest";
1697 for Object_Dir use ".";
1698 for Library_ALI_Dir use External("LIBRARY_DIR");
1699 for Library_Version use External ("SONAME");
1700 for Library_Kind use Kind;
1701 for Library_Dir use External("BUILD_DIR");
1702 Source_Dir := External ("SOURCE_DIR");
1703 for Source_Dirs use (Source_Dir);
1706 cat >>confpackage.ads <<CF_EOF
1707 package ConfPackage is
1711 cat >>confpackage.adb <<CF_EOF
1713 package body ConfPackage is
1714 procedure conftest is
1716 Text_IO.Put ("Hello World");
1721 if ( "$cf_ada_make" $ADAFLAGS \
1723 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1724 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1725 -XSOURCE_DIR="`pwd`" \
1726 -XSONAME=libConfTest.so.1 \
1727 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1728 cf_gnat_projects=yes
1732 if test -f conftest.lib/confpackage.ali
1734 cf_gnat_libraries=yes
1736 rm -rf ./conftest* ./*~conftest*
1741 AC_MSG_RESULT($cf_gnat_projects)
1742 fi # enable_gnat_projects
1744 if test "$cf_gnat_projects" = yes
1746 AC_MSG_CHECKING(if GNAT supports libraries)
1747 AC_MSG_RESULT($cf_gnat_libraries)
1750 USE_OLD_MAKERULES=""
1751 USE_GNAT_PROJECTS="#"
1752 USE_GNAT_MAKE_GPR="#"
1753 USE_GNAT_GPRBUILD="#"
1755 if test "$cf_gnat_projects" = yes
1757 USE_OLD_MAKERULES="#"
1758 USE_GNAT_PROJECTS=""
1759 if test "$cf_cv_VERSION_GPRBUILD" != no
1761 USE_GNAT_GPRBUILD=""
1762 elif test "$cf_cv_VERSION_GNATMAKE" != no
1764 USE_GNAT_MAKE_GPR=""
1766 AC_MSG_WARN(use old makefile rules since tools are missing)
1770 if test "$cf_gnat_libraries" = yes
1772 USE_GNAT_LIBRARIES=""
1774 USE_GNAT_LIBRARIES="#"
1777 AC_SUBST(USE_OLD_MAKERULES)
1778 AC_SUBST(USE_GNAT_PROJECTS)
1779 AC_SUBST(USE_GNAT_LIBRARIES)
1780 AC_SUBST(USE_GNAT_MAKE_GPR)
1781 AC_SUBST(USE_GNAT_GPRBUILD)
1783 dnl ---------------------------------------------------------------------------
1784 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1786 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1787 dnl is noted that gnat may compile a tasking unit even for configurations which
1788 dnl fail at runtime.
1789 AC_DEFUN([CF_GNAT_SIGINT],[
1790 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1791 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1795 pragma Warnings (Off); -- the next pragma exists since 3.11p
1796 pragma Unreserve_All_Interrupts;
1797 pragma Warnings (On);
1799 protected Process is
1801 function Continue return Boolean;
1802 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1804 Done : Boolean := False;
1808 [package body ConfTest is
1809 protected body Process is
1814 function Continue return Boolean is
1820 [cf_cv_gnat_sigint=yes],
1821 [cf_cv_gnat_sigint=no])])
1823 if test "$cf_cv_gnat_sigint" = yes ; then
1828 AC_SUBST(USE_GNAT_SIGINT)
1830 dnl ---------------------------------------------------------------------------
1831 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1832 dnl ----------------
1833 dnl Verify that a test program compiles/links with GNAT.
1834 dnl $cf_ada_make is set to the program that compiles/links
1835 dnl $ADAFLAGS may be set to the GNAT flags.
1837 dnl $1 is the text of the spec
1838 dnl $2 is the text of the body
1839 dnl $3 is the shell command to execute if successful
1840 dnl $4 is the shell command to execute if not successful
1841 AC_DEFUN([CF_GNAT_TRY_LINK],
1843 rm -rf ./conftest* ./*~conftest*
1844 cat >>conftest.ads <<CF_EOF
1847 cat >>conftest.adb <<CF_EOF
1850 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1851 ifelse($3,, :,[ $3])
1855 rm -rf ./conftest* ./*~conftest*
1857 dnl ---------------------------------------------------------------------------
1858 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1860 dnl Verify that a test program compiles and runs with GNAT
1861 dnl $cf_ada_make is set to the program that compiles/links
1862 dnl $ADAFLAGS may be set to the GNAT flags.
1864 dnl $1 is the text of the spec
1865 dnl $2 is the text of the body
1866 dnl $3 is the shell command to execute if successful
1867 dnl $4 is the shell command to execute if not successful
1868 AC_DEFUN([CF_GNAT_TRY_RUN],
1870 rm -rf ./conftest* ./*~conftest*
1871 cat >>conftest.ads <<CF_EOF
1874 cat >>conftest.adb <<CF_EOF
1877 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1878 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1879 ifelse($3,, :,[ $3])
1886 rm -rf ./conftest* ./*~conftest*
1888 dnl ---------------------------------------------------------------------------
1889 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1891 dnl $1 = cache variable to update
1892 dnl $2 = program name
1893 dnl Verify version of GNAT or related tool
1894 AC_DEFUN([CF_GNAT_VERSION],
1896 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1897 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1898 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1899 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1901 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1902 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1904 dnl ---------------------------------------------------------------------------
1905 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1907 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1908 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1909 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1910 dnl since it is interwoven with GNU extensions.
1912 dnl Well, yes we could work around it...
1915 dnl $1 is the nominal value for _XOPEN_SOURCE
1916 AC_DEFUN([CF_GNU_SOURCE],
1918 cf_gnu_xopen_source=ifelse($1,,500,$1)
1920 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1921 AC_TRY_COMPILE([#include <sys/types.h>],[
1922 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1924 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1927 # error not GNU C library
1929 [cf_cv_gnu_library=yes],
1930 [cf_cv_gnu_library=no])
1933 if test x$cf_cv_gnu_library = xyes; then
1935 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1936 # was changed to help a little. newlib incorporated the change about 4
1938 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1940 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1941 AC_TRY_COMPILE([#include <sys/types.h>],[
1942 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1944 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1947 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1949 [cf_cv_gnu_library_219=yes],
1950 [cf_cv_gnu_library_219=no])
1954 if test "x$cf_cv_gnu_library_219" = xyes; then
1956 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1957 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1960 #include <sys/types.h>
1962 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1965 # error GNU C library is too old
1967 [cf_cv_gnu_dftsrc_219=yes],
1968 [cf_cv_gnu_dftsrc_219=no])
1970 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1972 cf_cv_gnu_dftsrc_219=maybe
1975 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1977 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1978 AC_TRY_COMPILE([#include <sys/types.h>],[
1979 #ifndef _XOPEN_SOURCE
1980 #error expected _XOPEN_SOURCE to be defined
1982 [cf_cv_gnu_source=no],
1983 [cf_save="$CPPFLAGS"
1984 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1985 AC_TRY_COMPILE([#include <sys/types.h>],[
1986 #ifdef _XOPEN_SOURCE
1987 #error expected _XOPEN_SOURCE to be undefined
1989 [cf_cv_gnu_source=no],
1990 [cf_cv_gnu_source=yes])
1995 if test "$cf_cv_gnu_source" = yes
1997 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1998 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1999 AC_TRY_COMPILE([#include <sys/types.h>],[
2000 #ifdef _DEFAULT_SOURCE
2001 #error expected _DEFAULT_SOURCE to be undefined
2003 [cf_cv_default_source=no],
2004 [cf_cv_default_source=yes])
2006 if test "$cf_cv_default_source" = yes
2008 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2015 dnl ---------------------------------------------------------------------------
2016 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2018 dnl Construct a search-list of directories for a nonstandard header-file
2021 dnl $1 = the variable to return as result
2022 dnl $2 = the package name
2023 AC_DEFUN([CF_HEADER_PATH],
2027 # collect the current set of include-directories from compiler flags
2028 cf_header_path_list=""
2029 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2030 for cf_header_path in $CPPFLAGS $CFLAGS
2032 case "$cf_header_path" in
2034 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2035 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2036 cf_header_path_list="$cf_header_path_list [$]$1"
2042 # add the variations for the package we are looking for
2043 CF_SUBDIR_PATH($1,$2,include)
2045 test "$includedir" != NONE && \
2046 test "$includedir" != "/usr/include" && \
2047 test -d "$includedir" && {
2048 test -d "$includedir" && $1="[$]$1 $includedir"
2049 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2052 test "$oldincludedir" != NONE && \
2053 test "$oldincludedir" != "/usr/include" && \
2054 test -d "$oldincludedir" && {
2055 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2056 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2059 $1="[$]$1 $cf_header_path_list"
2061 dnl ---------------------------------------------------------------------------
2062 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2064 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2065 AC_DEFUN([CF_HELP_MESSAGE],
2066 [CF_ACVERSION_CHECK(2.53,[],[
2067 AC_DIVERT_HELP($1)])dnl
2069 dnl ---------------------------------------------------------------------------
2070 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2072 dnl Construct the list of include-options according to whether we're building
2073 dnl in the source directory or using '--srcdir=DIR' option.
2074 AC_DEFUN([CF_INCLUDE_DIRS],
2076 if test "$srcdir" != "."; then
2077 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2079 CPPFLAGS="-I../include $CPPFLAGS"
2080 if test "$srcdir" != "."; then
2081 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2083 CPPFLAGS="-I. $CPPFLAGS"
2086 dnl ---------------------------------------------------------------------------
2087 dnl CF_INSTALL_OPTS version: 3 updated: 2023/06/03 15:17:30
2089 dnl prompt for/fill-in useful install-program options
2090 AC_DEFUN([CF_INSTALL_OPTS],
2095 CF_INSTALL_OPT_STRIP_PROG
2097 dnl ---------------------------------------------------------------------------
2098 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2099 dnl ----------------
2100 dnl Almost all "install" programs default to the current user's ownership.
2101 dnl Almost - MINIX is an exception.
2102 AC_DEFUN([CF_INSTALL_OPT_O],
2104 AC_MSG_CHECKING(if install needs to be told about ownership)
2105 case `$ac_config_guess` in
2114 AC_MSG_RESULT($with_install_o)
2115 if test "x$with_install_o" = xyes
2117 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'`"
2122 AC_SUBST(INSTALL_OPT_O)
2124 dnl ---------------------------------------------------------------------------
2125 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2126 dnl ----------------
2127 dnl Some install-programs accept a "-p" option to preserve file modification
2128 dnl timestamps. That can be useful as an install option, as well as a way to
2129 dnl avoid the need for ranlib after copying a static archive.
2130 AC_DEFUN([CF_INSTALL_OPT_P],
2132 : "${INSTALL:=install}"
2133 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2138 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2140 if test -f conftest.out/conftest.in
2142 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2143 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2144 if test -s conftest.err
2159 dnl ---------------------------------------------------------------------------
2160 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2161 dnl ----------------
2162 dnl By default, we should strip executables which are installed, but leave the
2163 dnl ability to suppress that for unit-testing.
2164 AC_DEFUN([CF_INSTALL_OPT_S],
2166 AC_MSG_CHECKING(if you want to install stripped executables)
2167 CF_ARG_DISABLE(stripping,
2168 [ --disable-stripping do not strip (debug info) installed executables],
2169 [enable_stripping=no],
2170 [enable_stripping=yes])
2171 AC_MSG_RESULT($enable_stripping)
2173 if test "$enable_stripping" = yes
2179 AC_SUBST(INSTALL_OPT_S)
2181 dnl ---------------------------------------------------------------------------
2182 dnl CF_INSTALL_OPT_STRIP_PROG version: 1 updated: 2023/06/03 15:17:30
2183 dnl -------------------------
2184 dnl Provide an option for overriding the strip program used in install "-s"
2186 dnl coreutils install provides a --strip-program option
2187 dnl FreeBSD uses STRIPBIN environment variable, while NetBSD and OpenBSD use
2188 dnl STRIP environment variable. Other versions of install do not support this.
2189 AC_DEFUN([CF_INSTALL_OPT_STRIP_PROG],
2191 AC_REQUIRE([CF_INSTALL_OPT_S])
2192 if test -n "$INSTALL_OPT_S"
2194 AC_MSG_CHECKING(if you want to specify strip-program)
2195 AC_ARG_WITH(strip-program,
2196 [ --with-strip-program=XX specify program to use when stripping in install],
2197 [with_strip_program=$withval],
2198 [with_strip_program=no])
2199 AC_MSG_RESULT($with_strip_program)
2200 if test "$with_strip_program" != no
2202 AC_MSG_CHECKING(if strip-program is supported with this installer)
2203 cf_install_program=`echo "$INSTALL" | sed -e 's%[[ ]]*[[ ]]-.%%'`
2204 check_install_strip=no
2205 if test -f "$cf_install_program"
2207 check_install_version=`"$cf_install_program" --version 2>/dev/null | head -n 1 | grep coreutils`
2208 if test -n "$check_install_version"
2210 check_install_strip="option"
2212 for check_strip_variable in STRIPBIN STRIP
2214 if strings "$cf_install_program" | grep "^$check_strip_variable[$]" >/dev/null
2216 check_install_strip="environ"
2222 AC_MSG_RESULT($check_install_strip)
2223 case "$check_install_strip" in
2225 AC_MSG_WARN($cf_install_program does not support strip program option)
2226 with_strip_program=no
2229 cat >install.tmp <<-CF_EOF
2231 STRIPBIN="$with_strip_program" \\
2232 STRIP="$with_strip_program" \\
2235 INSTALL="`pwd`/install.tmp"
2237 CF_VERBOSE(created $INSTALL)
2240 INSTALL_OPT_S="$INSTALL_OPT_S --strip-program=\"$with_strip_program\""
2245 AC_SUBST(INSTALL_OPT_S)
2247 dnl ---------------------------------------------------------------------------
2248 dnl CF_INTEL_COMPILER version: 9 updated: 2023/02/18 17:41:25
2249 dnl -----------------
2250 dnl Check if the given compiler is really the Intel compiler for Linux. It
2251 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2252 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2254 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2255 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2256 dnl the wrappers for gcc and g++ warnings.
2258 dnl $1 = GCC (default) or GXX
2259 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2260 dnl $3 = CFLAGS (default) or CXXFLAGS
2261 AC_DEFUN([CF_INTEL_COMPILER],[
2262 AC_REQUIRE([AC_CANONICAL_HOST])
2263 ifelse([$2],,INTEL_COMPILER,[$2])=no
2265 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2268 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2269 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2270 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2272 #ifdef __INTEL_COMPILER
2274 #error __INTEL_COMPILER is not defined
2276 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2277 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2279 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2280 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2285 dnl ---------------------------------------------------------------------------
2286 dnl CF_LARGEFILE version: 13 updated: 2023/12/03 19:09:59
2288 dnl Add checks for large file support.
2289 AC_DEFUN([CF_LARGEFILE],[
2290 ifdef([AC_FUNC_FSEEKO],[
2292 if test "$enable_largefile" != no ; then
2295 # Normally we would collect these definitions in the config.h,
2296 # but (like _XOPEN_SOURCE), some environments rely on having these
2297 # defined before any of the system headers are included. Another
2298 # case comes up with C++, e.g., on AIX the compiler compiles the
2299 # header files by themselves before looking at the body files it is
2300 # told to compile. For ncurses, those header files do not include
2302 if test "$ac_cv_sys_large_files" != no
2304 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2306 if test "$ac_cv_sys_largefile_source" != no
2308 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2310 if test "$ac_cv_sys_file_offset_bits" != no
2312 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2315 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2317 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2318 #include <sys/types.h>
2322 /* if transitional largefile support is setup, this is true */
2323 extern struct dirent64 * readdir(DIR *);
2326 DIR *dp = opendir(".");
2327 struct dirent64 *x = readdir(dp);
2328 struct dirent *y = readdir(dp);
2332 [cf_cv_struct_dirent64=yes],
2333 [cf_cv_struct_dirent64=no])
2335 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2339 dnl ---------------------------------------------------------------------------
2340 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2342 dnl For the given system and compiler, find the compiler flags to pass to the
2343 dnl loader to use the "rpath" feature.
2344 AC_DEFUN([CF_LD_RPATH_OPT],
2346 AC_REQUIRE([CF_CHECK_CACHE])
2349 if test "x$cf_cv_enable_rpath" != xno
2351 AC_MSG_CHECKING(for an rpath option)
2352 case "$cf_cv_system_name" in
2354 if test "$GCC" = yes; then
2355 LD_RPATH_OPT="-Wl,-rpath,"
2357 LD_RPATH_OPT="-rpath "
2360 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2361 LD_RPATH_OPT="-Wl,-rpath,"
2363 (openbsd[[2-9]].*|mirbsd*)
2364 LD_RPATH_OPT="-Wl,-rpath,"
2367 LD_RPATH_OPT="-rpath "
2370 LD_RPATH_OPT="-Wl,-rpath,"
2373 LD_RPATH_OPT="-rpath "
2381 AC_MSG_RESULT($LD_RPATH_OPT)
2383 case "x$LD_RPATH_OPT" in
2385 AC_MSG_CHECKING(if we need a space after rpath option)
2386 cf_save_LIBS="$LIBS"
2387 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2388 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2389 LIBS="$cf_save_LIBS"
2390 AC_MSG_RESULT($cf_rpath_space)
2391 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2396 dnl ---------------------------------------------------------------------------
2397 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2399 dnl Construct a search-list of directories for a nonstandard library-file
2402 dnl $1 = the variable to return as result
2403 dnl $2 = the package name
2404 AC_DEFUN([CF_LIBRARY_PATH],
2407 cf_library_path_list=""
2408 if test -n "${LDFLAGS}${LIBS}" ; then
2409 for cf_library_path in $LDFLAGS $LIBS
2411 case "$cf_library_path" in
2413 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2414 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2415 cf_library_path_list="$cf_library_path_list [$]$1"
2421 CF_SUBDIR_PATH($1,$2,lib)
2423 $1="$cf_library_path_list [$]$1"
2425 dnl ---------------------------------------------------------------------------
2426 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2428 dnl Compute the library-prefix for the given host system
2429 dnl $1 = variable to set
2430 define([CF_LIB_PREFIX],
2432 case "$cf_cv_system_name" in
2434 if test "$DFT_LWR_MODEL" = libtool; then
2443 (*) LIB_PREFIX='lib'
2446 ifelse($1,,,[$1=$LIB_PREFIX])
2447 AC_SUBST(LIB_PREFIX)
2449 dnl ---------------------------------------------------------------------------
2450 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2452 dnl Compute the library file-suffix from the given model name
2454 dnl $2 = variable to set (the nominal library suffix)
2455 dnl $3 = dependency variable to set (actual filename)
2456 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2457 AC_DEFUN([CF_LIB_SUFFIX],
2465 case "$cf_cv_system_name" in
2476 case "$cf_cv_system_name" in
2487 case "$cf_cv_system_name" in
2496 (cygwin*|msys*|mingw*)
2534 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2536 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2537 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2540 dnl ---------------------------------------------------------------------------
2541 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2543 dnl Compute the string to append to -library from the given model name
2545 dnl $2 = variable to set
2546 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2547 AC_DEFUN([CF_LIB_TYPE],
2553 (profile) $2='_p' ;;
2556 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2558 dnl ---------------------------------------------------------------------------
2559 dnl CF_LINK_DATAONLY version: 15 updated: 2023/12/03 10:03:10
2560 dnl ----------------
2561 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2562 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2563 dnl have to provide wrappers for global tables to ensure they're linked
2565 AC_DEFUN([CF_LINK_DATAONLY],
2567 AC_MSG_CHECKING([if data-only library module links])
2568 AC_CACHE_VAL(cf_cv_link_dataonly,[
2570 cat >conftest.$ac_ext <<EOF
2571 #line __oline__ "configure"
2572 int testdata[[3]] = { 123, 456, 789 };
2574 if AC_TRY_EVAL(ac_compile) ; then
2575 mv conftest.o data.o && \
2576 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2578 rm -f conftest.$ac_ext data.o
2579 cat >conftest.$ac_ext <<EOF
2580 #line __oline__ "configure"
2581 extern int testfunc(void);
2585 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2588 extern int testdata[[3]];
2591 return testdata[[0]] == 123
2592 && testdata[[1]] == 456
2593 && testdata[[2]] == 789;
2597 if AC_TRY_EVAL(ac_compile); then
2598 mv conftest.o func.o && \
2599 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2601 rm -f conftest.$ac_ext func.o
2602 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2604 LIBS="conftest.a $LIBS"
2606 extern int testfunc(void);
2609 ${cf_cv_main_return:-return} (!testfunc());
2612 [cf_cv_link_dataonly=yes],
2613 [cf_cv_link_dataonly=no],
2614 [cf_cv_link_dataonly=unknown])
2617 AC_MSG_RESULT($cf_cv_link_dataonly)
2619 if test "$cf_cv_link_dataonly" = no ; then
2620 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2623 AC_SUBST(BROKEN_LINKER)
2626 dnl ---------------------------------------------------------------------------
2627 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2629 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2630 dnl options to lower-levels. It is very useful for "make -n" -- if we have it.
2631 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2632 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2633 AC_DEFUN([CF_MAKEFLAGS],
2634 [AC_REQUIRE([AC_PROG_FGREP])dnl
2636 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2638 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2640 cat >cf_makeflags.tmp <<CF_EOF
2643 @ echo '.$cf_option'
2645 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2646 case "$cf_result" in
2648 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2649 case "$cf_result" in
2650 (.*CC=*) cf_cv_makeflags=
2652 (*) cf_cv_makeflags=$cf_option
2660 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2664 rm -f cf_makeflags.tmp
2667 AC_SUBST(cf_cv_makeflags)
2669 dnl ---------------------------------------------------------------------------
2670 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2672 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2673 dnl acts as a placeholder.
2675 dnl The ".PHONY" feature was proposed in 2011 here
2676 dnl https://www.austingroupbugs.net/view.php?id=523
2677 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2679 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2680 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2682 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2683 dnl date unspecified).
2685 dnl + It was adopted in NetBSD make in June 1995.
2687 dnl + The other BSD make programs are derived from the NetBSD make (and for
2688 dnl that reason are not actually different "implementations").
2690 dnl + Some features of NetBSD make were actually adapted from pmake, which
2691 dnl began as a modified GNU make starting in 1993.
2693 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2694 dnl GNU make extension, but is less well known than the BSD make.
2695 AC_DEFUN([CF_MAKE_PHONY],[
2696 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2699 mkdir conftest || exit 1
2701 cat >makefile <<'CF_EOF'
2705 @echo "** making [$]@ [$](DATA)"
2707 @echo "** making [$]@ [$](DATA)"
2709 @echo "** making [$]@ [$](DATA)"
2710 echo [$](DATA) > [$]@
2712 @echo "** making [$]@ [$](DATA)"
2713 echo [$](DATA) > [$]@
2715 for cf_data in 1 2 3
2717 ${MAKE:-make} always DATA=$cf_data
2718 ${MAKE:-make} once DATA=$cf_data
2719 ${MAKE:-make} -t always once
2720 if test -f always ; then
2721 echo "no (case 1)" > ../conftest.tmp
2722 elif test ! -f always.out ; then
2723 echo "no (case 2)" > ../conftest.tmp
2724 elif test ! -f once.out ; then
2725 echo "no (case 3)" > ../conftest.tmp
2726 elif ! cmp -s always.out once.out ; then
2727 echo "no (case 4)" > ../conftest.tmp
2728 diff always.out once.out
2730 cf_check="`cat always.out`"
2731 if test "x$cf_check" != "x$cf_data" ; then
2732 echo "no (case 5)" > ../conftest.tmp
2734 echo yes > ../conftest.tmp
2742 cf_cv_make_PHONY="`cat conftest.tmp`"
2747 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2748 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2749 AC_SUBST(MAKE_NO_PHONY)
2750 AC_SUBST(MAKE_PHONY)
2752 dnl ---------------------------------------------------------------------------
2753 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2755 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2756 dnl a monocase filesystem.
2757 AC_DEFUN([CF_MAKE_TAGS],[
2758 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2760 AC_CHECK_PROGS(CTAGS, exctags ctags)
2761 AC_CHECK_PROGS(ETAGS, exetags etags)
2763 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2765 if test "$cf_cv_mixedcase" = yes ; then
2766 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2771 if test "$MAKE_UPPER_TAGS" = yes ; then
2777 if test "$MAKE_LOWER_TAGS" = yes ; then
2786 AC_SUBST(MAKE_UPPER_TAGS)
2787 AC_SUBST(MAKE_LOWER_TAGS)
2789 dnl ---------------------------------------------------------------------------
2790 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2791 dnl ----------------------
2792 dnl Check if the file-system supports mixed-case filenames. If we're able to
2793 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2794 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2796 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2797 if test "$cross_compiling" = yes ; then
2798 case "$target_alias" in
2799 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2807 rm -f conftest CONFTEST
2809 if test -f CONFTEST ; then
2814 rm -f conftest CONFTEST
2817 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2819 dnl ---------------------------------------------------------------------------
2820 dnl CF_MKSTEMP version: 13 updated: 2023/12/01 17:22:50
2822 dnl Check for a working mkstemp. This creates two files, checks that they are
2823 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2824 AC_DEFUN([CF_MKSTEMP],[
2828 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2831 $ac_includes_default
2835 static char tmpl[] = "conftestXXXXXX";
2843 for (n = 0; n < 2; ++n) {
2844 strcpy(name[n], tmpl);
2845 if ((fd = mkstemp(name[n])) >= 0) {
2846 if (!strcmp(name[n], tmpl)
2847 || stat(name[n], &sb) != 0
2848 || (sb.st_mode & S_IFMT) != S_IFREG
2849 || (sb.st_mode & 077) != 0) {
2856 && !strcmp(name[0], name[1]))
2858 ${cf_cv_main_return:-return}(result);
2860 ],[cf_cv_func_mkstemp=yes
2861 ],[cf_cv_func_mkstemp=no
2862 ],[cf_cv_func_mkstemp=maybe])
2864 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2865 AC_CHECK_FUNC(mkstemp)
2867 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2868 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2871 dnl ---------------------------------------------------------------------------
2872 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2874 dnl Write a debug message to config.log, along with the line number in the
2875 dnl configure script.
2876 AC_DEFUN([CF_MSG_LOG],[
2877 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2879 dnl ---------------------------------------------------------------------------
2880 dnl CF_NCURSES_ADDON version: 7 updated: 2024/06/01 17:37:13
2881 dnl ----------------
2882 dnl Configure an ncurses add-on, built outside the ncurses tree.
2883 AC_DEFUN([CF_NCURSES_ADDON],[
2884 AC_REQUIRE([CF_NCURSES_CONFIG])
2886 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2888 AC_MSG_CHECKING(for specified curses library type)
2890 [ --with-screen=XXX use specified curses-libraries],
2891 [cf_cv_screen=$withval],
2892 [cf_cv_screen=ncurses])
2894 case $cf_cv_screen in
2900 CF_NCURSES_CONFIG($cf_cv_screen)
2903 CF_NCURSES_CONFIG($cf_cv_screen)
2906 AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
2910 AC_SUBST(cf_cv_screen)
2912 if test "$NCURSES_CONFIG_PKG" != none ; then
2913 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2915 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2916 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2917 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2919 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2920 if test -z "$cf_cv_abi_version"
2922 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2925 elif test "$NCURSES_CONFIG" != none ; then
2927 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2929 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2930 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2931 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2933 # ABI version is not available from headers
2934 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2938 for cf_name in MAJOR MINOR PATCH
2940 cat >conftest.$ac_ext <<CF_EOF
2941 #include <${cf_cv_ncurses_header:-curses.h}>
2942 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2944 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2946 if test -f conftest.out ; then
2947 cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
2948 eval NCURSES_$cf_name=\"$cf_result\"
2949 # cat conftest.$ac_ext
2954 cf_cv_abi_version=${NCURSES_MAJOR}
2958 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2960 dnl Show the computed version, for logging
2961 cf_cv_timestamp=`date`
2963 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2965 dnl We need these values in the generated headers
2966 AC_SUBST(NCURSES_MAJOR)
2967 AC_SUBST(NCURSES_MINOR)
2968 AC_SUBST(NCURSES_PATCH)
2970 dnl We need these values in the generated makefiles
2971 AC_SUBST(cf_cv_rel_version)
2972 AC_SUBST(cf_cv_abi_version)
2974 dnl FIXME - not needed for Ada95
2975 AC_SUBST(cf_cv_builtin_bool)
2976 AC_SUBST(cf_cv_header_stdbool_h)
2977 AC_SUBST(cf_cv_type_of_bool)dnl
2979 AC_CACHE_CHECK(if KEY_RESIZE is supported,cf_cv_curses_resizes,[
2980 AC_TRY_COMPILE([#include <${cf_cv_ncurses_header:-curses.h}>],
2981 [int key = KEY_RESIZE; (void)key],
2982 cf_cv_curses_resizes=yes,
2983 cf_cv_curses_resizes=no)])
2984 cf_cv_enable_sigwinch=0
2985 test "$cf_cv_curses_resizes" = yes && cf_cv_enable_sigwinch=1
2986 AC_SUBST(cf_cv_enable_sigwinch)
2988 dnl ---------------------------------------------------------------------------
2989 dnl CF_NCURSES_CC_CHECK version: 6 updated: 2023/02/18 17:47:58
2990 dnl -------------------
2991 dnl Check if we can compile with ncurses' header file
2992 dnl $1 is the cache variable to set
2993 dnl $2 is the header-file to include
2994 dnl $3 is the root name (ncurses or ncursesw)
2995 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2997 ]ifelse($3,ncursesw,[
2998 #define _XOPEN_SOURCE_EXTENDED
2999 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
3000 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
3003 #ifdef NCURSES_VERSION
3004 ]ifelse($3,ncursesw,[
3006 #error WACS_BSSB is not defined
3009 printf("%s\\n", NCURSES_VERSION);
3014 #error __NCURSES_H is not defined
3021 dnl ---------------------------------------------------------------------------
3022 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
3023 dnl -----------------
3024 dnl Tie together the configure-script macros for ncurses, preferring these in
3026 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
3027 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
3028 dnl c) just plain libraries
3030 dnl $1 is the root library name (default: "ncurses")
3031 AC_DEFUN([CF_NCURSES_CONFIG],[
3032 AC_REQUIRE([CF_PKG_CONFIG])
3033 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
3034 cf_have_ncuconfig=no
3036 if test "x${PKG_CONFIG:=none}" != xnone; then
3037 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
3038 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
3041 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
3042 cf_have_ncuconfig=unknown
3044 cf_save_CFLAGS="$CFLAGS"
3045 cf_save_CPPFLAGS="$CPPFLAGS"
3046 cf_save_LIBS="$LIBS"
3048 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
3049 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
3051 # while -W for passing linker flags is prevalent, it is not "standard".
3052 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
3053 # incompatible _and_ non-standard -W option which gives an error. Work
3054 # around that pitfall.
3055 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
3057 CF_ADD_CFLAGS($cf_pkg_cflags)
3058 CF_ADD_LIBS($cf_pkg_libs)
3060 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3061 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3062 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
3064 { const char *xx = curses_version(); return (xx == 0); }],
3065 [cf_test_ncuconfig=yes],
3066 [cf_test_ncuconfig=no],
3067 [cf_test_ncuconfig=maybe])],
3068 [cf_test_ncuconfig=no])
3070 CFLAGS="$cf_save_CFLAGS"
3071 CPPFLAGS="$cf_save_CPPFLAGS"
3072 LIBS="$cf_save_LIBS"
3074 if test "x$cf_test_ncuconfig" != xyes; then
3075 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
3076 cf_pkg_cflags="$cf_temp"
3077 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
3078 cf_pkg_libs="$cf_temp"
3083 CF_APPEND_CFLAGS($cf_pkg_cflags)
3084 CF_ADD_LIBS($cf_pkg_libs)
3086 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3087 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3088 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
3090 { const char *xx = curses_version(); return (xx == 0); }],
3091 [cf_have_ncuconfig=yes],
3092 [cf_have_ncuconfig=no],
3093 [cf_have_ncuconfig=maybe])],
3094 [cf_have_ncuconfig=no])
3095 AC_MSG_RESULT($cf_have_ncuconfig)
3096 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
3097 if test "$cf_have_ncuconfig" != "yes"
3099 CPPFLAGS="$cf_save_CPPFLAGS"
3100 LIBS="$cf_save_LIBS"
3101 NCURSES_CONFIG_PKG=none
3103 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3104 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
3110 NCURSES_CONFIG_PKG=none
3113 NCURSES_CONFIG_PKG=none
3116 if test "x$cf_have_ncuconfig" = "xno"; then
3117 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
3119 CF_ACVERSION_CHECK(2.52,
3120 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
3121 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
3123 if test "$NCURSES_CONFIG" != none ; then
3125 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
3126 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
3128 # even with config script, some packages use no-override for curses.h
3129 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
3131 dnl like CF_NCURSES_CPPFLAGS
3132 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3134 dnl like CF_NCURSES_LIBS
3135 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
3136 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3138 dnl like CF_NCURSES_VERSION
3139 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3143 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3144 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3151 dnl ---------------------------------------------------------------------------
3152 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3153 dnl -------------------
3154 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3155 dnl the CPPFLAGS variable so we can include its header.
3157 dnl The header files may be installed as either curses.h, or ncurses.h (would
3158 dnl be obsolete, except that some packagers prefer this name to distinguish it
3159 dnl from a "native" curses implementation). If not installed for overwrite,
3160 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3161 dnl /usr/include/ncurses), but someone may have installed overwriting the
3162 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
3163 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3166 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3167 dnl is already in the include-path, don't even bother with this, since we cannot
3168 dnl easily determine which file it is. In this case, it has to be <curses.h>.
3170 dnl The optional parameter gives the root name of the library, in case it is
3171 dnl not installed as the default curses library. That is how the
3172 dnl wide-character version of ncurses is installed.
3173 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3174 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3176 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3177 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3179 test -n "$cf_cv_curses_dir" && \
3180 test "$cf_cv_curses_dir" != "no" && { \
3181 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3184 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3185 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3186 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3187 for cf_header in $cf_header_list
3189 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3190 test "$cf_cv_ncurses_h" != no && break
3197 # some applications need this, but should check for NCURSES_VERSION
3198 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3202 dnl ---------------------------------------------------------------------------
3203 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3204 dnl -----------------
3205 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3206 dnl variations of ncurses' installs.
3208 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3209 AC_DEFUN([CF_NCURSES_HEADER],[
3211 if test "$cf_cv_ncurses_h" != no ; then
3212 cf_cv_ncurses_header=$cf_cv_ncurses_h
3215 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3216 test -n "$verbose" && echo
3217 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3218 test -n "$verbose" && echo "search path $cf_search"
3219 cf_save2_CPPFLAGS="$CPPFLAGS"
3220 for cf_incdir in $cf_search
3222 CF_ADD_INCDIR($cf_incdir)
3227 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3228 if test "$cf_cv_ncurses_h2" != no ; then
3229 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3230 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
3233 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3235 CPPFLAGS="$cf_save2_CPPFLAGS"
3236 test "$cf_cv_ncurses_h2" != no && break
3238 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3241 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3242 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3243 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3244 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3246 CF_ADD_INCDIR($cf_1st_incdir)
3250 # Set definitions to allow ifdef'ing for ncurses.h
3252 case "$cf_cv_ncurses_header" in
3254 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3258 case "$cf_cv_ncurses_header" in
3259 (ncurses/curses.h|ncurses/ncurses.h)
3260 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3262 (ncursesw/curses.h|ncursesw/ncurses.h)
3263 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3268 dnl ---------------------------------------------------------------------------
3269 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3271 dnl Look for the ncurses library. This is a little complicated on Linux,
3272 dnl because it may be linked with the gpm (general purpose mouse) library.
3273 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3274 dnl unusable with ncurses. However, we don't want to link with gpm unless
3275 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3276 dnl and the linker will record a dependency.
3278 dnl The optional parameter gives the root name of the library, in case it is
3279 dnl not installed as the default curses library. That is how the
3280 dnl wide-character version of ncurses is installed.
3281 AC_DEFUN([CF_NCURSES_LIBS],
3282 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3284 cf_nculib_root=ifelse($1,,ncurses,$1)
3285 # This works, except for the special case where we find gpm, but
3286 # ncurses is in a nonstandard location via $LIBS, and we really want
3289 cf_ncurses_SAVE="$LIBS"
3290 AC_CHECK_LIB(gpm,Gpm_Open,
3291 [AC_CHECK_LIB(gpm,initscr,
3292 [LIBS="$cf_ncurses_SAVE"],
3293 [cf_ncurses_LIBS="-lgpm"])])
3297 # This is only necessary if you are linking against an obsolete
3298 # version of ncurses (but it should do no harm, since it is static).
3299 if test "$cf_nculib_root" = ncurses ; then
3300 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3305 CF_ADD_LIBS($cf_ncurses_LIBS)
3307 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3309 CF_ADD_LIBS(-l$cf_nculib_root)
3311 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3312 [#include <${cf_cv_ncurses_header:-curses.h}>],
3317 if test -n "$cf_ncurses_LIBS" ; then
3318 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3319 cf_ncurses_SAVE="$LIBS"
3320 for p in $cf_ncurses_LIBS ; do
3321 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3322 if test "$q" != "$LIBS" ; then
3326 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3327 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3328 [AC_MSG_RESULT(yes)],
3330 LIBS="$cf_ncurses_SAVE"])
3333 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3334 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3336 dnl ---------------------------------------------------------------------------
3337 dnl CF_NCURSES_VERSION version: 18 updated: 2024/01/07 06:34:16
3338 dnl ------------------
3339 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3340 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3341 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3342 AC_DEFUN([CF_NCURSES_VERSION],
3344 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3345 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3346 cf_cv_ncurses_version=no
3348 rm -f "$cf_tempfile"
3350 $ac_includes_default
3352 #include <${cf_cv_ncurses_header:-curses.h}>
3356 FILE *fp = fopen("$cf_tempfile", "w");
3357 #ifdef NCURSES_VERSION
3358 # ifdef NCURSES_VERSION_PATCH
3359 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3361 fprintf(fp, "%s\\n", NCURSES_VERSION);
3365 fprintf(fp, "old\\n");
3367 #error expected ncurses header to define __NCURSES_H
3370 ${cf_cv_main_return:-return}(0);
3372 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3374 # This will not work if the preprocessor splits the line after the
3375 # Autoconf token. The 'unproto' program does that.
3376 cat > "conftest.$ac_ext" <<EOF
3377 #include <${cf_cv_ncurses_header:-curses.h}>
3379 #ifdef NCURSES_VERSION
3380 Autoconf NCURSES_VERSION
3388 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3390 if test -f conftest.out ; then
3391 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3392 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3396 rm -f "$cf_tempfile"
3398 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3400 dnl ---------------------------------------------------------------------------
3401 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3403 dnl Compute the object-directory name from the given model name
3404 AC_DEFUN([CF_OBJ_SUBDIR],
3407 (libtool) $2='obj_lo' ;;
3408 (normal) $2='objects' ;;
3409 (debug) $2='obj_g' ;;
3410 (profile) $2='obj_p' ;;
3412 case "$cf_cv_system_name" in
3420 dnl ---------------------------------------------------------------------------
3421 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3423 dnl Provide a value for the $PATH and similar separator (or amend the value
3424 dnl as provided in autoconf 2.5x).
3425 AC_DEFUN([CF_PATHSEP],
3427 AC_MSG_CHECKING(for PATH separator)
3428 case "$cf_cv_system_name" in
3429 (os2*) PATH_SEPARATOR=';' ;;
3430 (*) ${PATH_SEPARATOR:=':'} ;;
3432 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3433 AC_SUBST(PATH_SEPARATOR)
3434 AC_MSG_RESULT($PATH_SEPARATOR)
3436 dnl ---------------------------------------------------------------------------
3437 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3439 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3440 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3441 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3442 dnl delayed evaluation of those symbols.
3443 AC_DEFUN([CF_PATH_SYNTAX],[
3444 if test "x$prefix" != xNONE; then
3445 cf_path_syntax="$prefix"
3447 cf_path_syntax="$ac_default_prefix"
3451 (.\[$]\(*\)*|.\'*\'*)
3455 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3457 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3461 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3466 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3469 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3473 dnl ---------------------------------------------------------------------------
3474 dnl CF_PKG_CONFIG version: 13 updated: 2023/10/28 11:59:01
3476 dnl Check for the package-config program, unless disabled by command-line.
3478 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3479 AC_DEFUN([CF_PKG_CONFIG],
3481 AC_MSG_CHECKING(if you want to use pkg-config)
3482 AC_ARG_WITH(pkg-config,
3483 [[ --with-pkg-config[=CMD] enable/disable use of pkg-config and its name CMD]],
3484 [cf_pkg_config=$withval],
3485 [cf_pkg_config=yes])
3486 AC_MSG_RESULT($cf_pkg_config)
3488 case "$cf_pkg_config" in
3493 CF_ACVERSION_CHECK(2.52,
3494 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3495 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3502 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3503 if test "$PKG_CONFIG" != none ; then
3504 CF_PATH_SYNTAX(PKG_CONFIG)
3505 elif test "x$cf_pkg_config" != xno ; then
3506 AC_MSG_WARN(pkg-config is not installed)
3509 AC_SUBST(PKG_CONFIG)
3511 dnl ---------------------------------------------------------------------------
3512 dnl CF_POSIX_C_SOURCE version: 12 updated: 2023/02/18 17:41:25
3513 dnl -----------------
3514 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3516 dnl POSIX.1-1990 _POSIX_SOURCE
3517 dnl POSIX.1-1990 and _POSIX_SOURCE and
3518 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3520 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3521 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3522 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3525 dnl $1 is the nominal value for _POSIX_C_SOURCE
3526 AC_DEFUN([CF_POSIX_C_SOURCE],
3527 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3529 if test "$cf_cv_posix_visible" = no; then
3531 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3533 cf_save_CFLAGS="$CFLAGS"
3534 cf_save_CPPFLAGS="$CPPFLAGS"
3536 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3537 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3539 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3540 CF_MSG_LOG(if the symbol is already defined go no further)
3541 AC_TRY_COMPILE([#include <sys/types.h>],[
3542 #ifndef _POSIX_C_SOURCE
3543 #error _POSIX_C_SOURCE is not defined
3545 [cf_cv_posix_c_source=no],
3546 [cf_want_posix_source=no
3547 case .$cf_POSIX_C_SOURCE in
3549 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3552 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3553 cf_want_posix_source=yes
3556 cf_want_posix_source=yes
3559 if test "$cf_want_posix_source" = yes ; then
3560 AC_TRY_COMPILE([#include <sys/types.h>],[
3561 #ifdef _POSIX_SOURCE
3562 #error _POSIX_SOURCE is defined
3564 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3566 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3567 CFLAGS="$cf_trim_CFLAGS"
3568 CPPFLAGS="$cf_trim_CPPFLAGS"
3569 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3570 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3571 AC_TRY_COMPILE([#include <sys/types.h>],[
3572 #ifndef _POSIX_C_SOURCE
3573 #error _POSIX_C_SOURCE is not defined
3575 [cf_cv_posix_c_source=no])
3576 CFLAGS="$cf_save_CFLAGS"
3577 CPPFLAGS="$cf_save_CPPFLAGS"
3581 if test "$cf_cv_posix_c_source" != no ; then
3582 CFLAGS="$cf_trim_CFLAGS"
3583 CPPFLAGS="$cf_trim_CPPFLAGS"
3584 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3587 fi # cf_cv_posix_visible
3590 dnl ---------------------------------------------------------------------------
3591 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3592 dnl ----------------
3593 dnl POSIX documents test-macros which an application may set before any system
3594 dnl headers are included to make features available.
3596 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3597 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3598 dnl recent features visible in the system header files unless the application
3599 dnl overrides the corresponding test-macros. Doing that introduces portability
3602 dnl This macro makes a special check for the symbols used for this, to avoid a
3603 dnl conflicting definition.
3604 AC_DEFUN([CF_POSIX_VISIBLE],
3606 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3607 AC_TRY_COMPILE([#include <stdio.h>],[
3608 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3609 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3610 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3611 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3612 #error conflicting symbols found
3614 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3617 dnl ---------------------------------------------------------------------------
3618 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3620 dnl Check for archiver "ar".
3621 AC_DEFUN([CF_PROG_AR],[
3622 AC_CHECK_TOOL(AR, ar, ar)
3624 dnl ---------------------------------------------------------------------------
3625 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3627 dnl Check for awk, ensure that the check found something.
3628 AC_DEFUN([CF_PROG_AWK],
3631 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3633 dnl ---------------------------------------------------------------------------
3634 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3636 dnl standard check for CC, plus followup sanity checks
3637 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3638 AC_DEFUN([CF_PROG_CC],[
3639 CF_ACVERSION_CHECK(2.53,
3640 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3641 AC_REQUIRE([AC_PROG_CC])],
3643 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3645 CF_ACVERSION_CHECK(2.52,
3650 dnl ---------------------------------------------------------------------------
3651 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3653 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3654 dnl the output file can be renamed, and allows for a shell variable that can
3655 dnl be used later. The parameter is either CC or CXX. The result is the
3657 dnl $cf_cv_prog_CC_c_o
3658 dnl $cf_cv_prog_CXX_c_o
3661 dnl $2 = compiler options, if any
3662 AC_DEFUN([CF_PROG_CC_C_O],
3663 [AC_REQUIRE([AC_PROG_CC])dnl
3664 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3665 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3667 cat > conftest.$ac_ext <<CF_EOF
3670 ${cf_cv_main_return:-return}(0);
3673 # We do the test twice because some compilers refuse to overwrite an
3674 # existing .o file with -o, though they will create one.
3675 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3676 if AC_TRY_EVAL(ac_try) &&
3677 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3679 eval cf_cv_prog_$1_c_o=yes
3681 eval cf_cv_prog_$1_c_o=no
3685 if test "$cf_cv_prog_$1_c_o" = yes; then
3686 AC_MSG_RESULT([yes])
3691 dnl ---------------------------------------------------------------------------
3692 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3694 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3695 dnl This macro adds a check to ensure the script found something.
3696 AC_DEFUN([CF_PROG_EGREP],
3697 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3698 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3699 then ac_cv_prog_egrep='grep -E'
3700 else ac_cv_prog_egrep='egrep'
3702 EGREP=$ac_cv_prog_egrep
3704 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3706 dnl ---------------------------------------------------------------------------
3707 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3709 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3710 AC_DEFUN([CF_PROG_EXT],
3712 AC_REQUIRE([CF_CHECK_CACHE])
3713 case "$cf_cv_system_name" in
3715 CFLAGS="$CFLAGS -Zmt"
3716 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3717 CXXFLAGS="$CXXFLAGS -Zmt"
3718 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3719 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3729 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3731 dnl ---------------------------------------------------------------------------
3732 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
3734 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3735 AC_DEFUN([CF_PROG_GNAT],[
3736 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3738 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3740 unset ac_cv_path_cf_TEMP_gnat
3742 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3743 eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
3745 if test "x$cf_TEMP_gnat" != xno; then
3746 unset cf_cv_gnat_version
3748 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3750 eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
3753 unset cf_cv_gnat_version
3754 unset ac_cv_path_cf_TEMP_gnat
3757 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3759 cf_cv_prog_gnat_correct=no
3761 cf_ada_make=gnatmake
3762 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3763 # gprconfig is newer than gnatmake; we can continue...
3766 rm -rf ./conftest* ./*~conftest*
3767 if mkdir conftest.src
3771 for cf_gprconfig in Ada C
3773 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3774 if test "$cf_gprconfig" = C
3776 for cf_gprconfig_param in \
3777 "$cf_gprconfig,,,,GNATGCC" \
3778 "$cf_gprconfig,,,,GCC" \
3781 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3782 test -n "$cf_gprconfig_value" && break
3785 cf_gprconfig_param=$cf_gprconfig
3786 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3788 if test -n "$cf_gprconfig_value"
3790 eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
3791 AC_MSG_RESULT($cf_gprconfig_value)
3793 AC_MSG_RESULT(missing)
3799 rm -rf ./conftest* ./*~conftest*
3802 if test "x$cf_ada_config" != "x#"
3805 CF_CHECK_GNAT_VERSION
3806 AC_CHECK_PROG(M4_exists, m4, yes, no)
3807 if test "$ac_cv_prog_M4_exists" = no; then
3808 cf_cv_prog_gnat_correct=no
3809 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3811 if test "$cf_cv_prog_gnat_correct" = yes; then
3812 AC_MSG_CHECKING(if GNAT works)
3813 CF_GNAT_TRY_RUN([procedure conftest;],
3816 procedure conftest is
3818 Text_IO.Put ("Hello World");
3820 GNAT.OS_Lib.OS_Exit (0);
3822 [cf_cv_prog_gnat_correct=yes],
3823 [cf_cv_prog_gnat_correct=no])
3824 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3827 cf_cv_prog_gnat_correct=no
3831 AC_SUBST(cf_ada_make)
3832 AC_SUBST(cf_ada_config)
3833 AC_SUBST(cf_ada_config_Ada)
3834 AC_SUBST(cf_ada_config_C)
3836 dnl ---------------------------------------------------------------------------
3837 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3839 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3840 dnl misc/tabset install won't work properly. Usually this happens only when
3841 dnl using the fallback mkinstalldirs script
3842 AC_DEFUN([CF_PROG_INSTALL],
3848 CF_DIRNAME(cf_dir,$INSTALL)
3849 test -z "$cf_dir" && cf_dir=.
3850 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3854 dnl ---------------------------------------------------------------------------
3855 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3857 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3858 dnl option if it is supported.
3859 AC_DEFUN([CF_PROG_LN_S],[
3861 AC_MSG_CHECKING(if $LN_S -f options work)
3863 rm -f conf$$.src conf$$dst
3865 echo first >conf$$.src
3866 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3871 rm -f conf$$.dst conf$$src
3872 AC_MSG_RESULT($cf_prog_ln_sf)
3874 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3876 dnl ---------------------------------------------------------------------------
3877 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
3878 dnl ----------------
3879 dnl Remove a given option from CFLAGS/CPPFLAGS
3880 dnl $1 = option to remove
3881 dnl $2 = variable to update
3882 dnl $3 = nonempty to allow verbose message
3883 define([CF_REMOVE_CFLAGS],
3885 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3888 cf_old_cflag=`echo "x[$]$2" | sed -e 's/^.//' -e 's/[[ ]][[ ]]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[[^ ]][[^ ]]*\\)\?%%" -e 's/^[[ ]]*//' -e 's%[[ ]][[ ]]*-D% -D%g' -e 's%[[ ]][[ ]]*-I% -I%g'`
3889 test "[$]$2" != "$cf_old_cflag" || break
3890 ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3894 dnl ---------------------------------------------------------------------------
3895 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3896 dnl ----------------
3897 dnl Remove all -U and -D options that refer to the given symbol from a list
3898 dnl of C compiler options. This works around the problem that not all
3899 dnl compilers process -U and -D options from left-to-right, so a -U option
3900 dnl cannot be used to cancel the effect of a preceding -D option.
3902 dnl $1 = target (which could be the same as the source variable)
3903 dnl $2 = source (including '$')
3904 dnl $3 = symbol to remove
3905 define([CF_REMOVE_DEFINE],
3908 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3909 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3911 dnl ---------------------------------------------------------------------------
3912 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3914 dnl Remove the given library from the symbol
3916 dnl $1 = target (which could be the same as the source variable)
3917 dnl $2 = source (including '$')
3918 dnl $3 = library to remove
3919 define([CF_REMOVE_LIB],
3921 # remove $3 library from $2
3922 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3924 dnl ---------------------------------------------------------------------------
3925 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3926 dnl ---------------------
3927 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3928 dnl $1 = name of current macro
3929 define([CF_RESTORE_XTRA_FLAGS],
3931 LIBS="$cf_save_LIBS_$1"
3932 CFLAGS="$cf_save_CFLAGS_$1"
3933 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3935 dnl ---------------------------------------------------------------------------
3936 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3937 dnl ------------------
3938 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3939 dnl and libraries which do not update those variables.
3941 dnl $1 = name of current macro
3942 define([CF_SAVE_XTRA_FLAGS],
3944 cf_save_LIBS_$1="$LIBS"
3945 cf_save_CFLAGS_$1="$CFLAGS"
3946 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3947 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3948 for cf_X_CFLAGS in $X_CFLAGS
3950 case "x$cf_X_CFLAGS" in
3952 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3955 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3960 dnl ---------------------------------------------------------------------------
3961 dnl CF_SHARED_OPTS version: 111 updated: 2024/03/29 20:08:49
3964 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3968 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3969 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3970 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3971 dnl shared library since that can lead to unexpected results at runtime.
3972 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3973 dnl libraries are compiled in ../../lib
3975 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3976 dnl to install symbolic links to the rel/abi versions of shared libraries.
3978 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3979 dnl version when making symbolic links.
3981 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3982 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3983 dnl (ex: libncurses.so.<ver>).
3985 dnl Some loaders leave 'so_locations' lying around. It is nice to clean up.
3986 AC_DEFUN([CF_SHARED_OPTS],
3988 AC_REQUIRE([CF_LD_RPATH_OPT])
3994 INSTALL_LIB="-m 644"
3995 : ${rel_builddir:=.}
4003 cf_cv_do_symlinks=no
4005 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
4007 AC_MSG_CHECKING(whether to use release or ABI version in shared library file names)
4008 AC_ARG_WITH(shlib-version,
4009 [[ --with-shlib-version[={rel|abi}] use release or ABI version in shared library file names]],
4010 [test -z "$withval" && withval=auto
4013 cf_cv_shlib_version=auto
4016 cf_cv_shlib_version=$withval
4019 AC_MSG_RESULT($withval)
4020 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
4023 ],[cf_cv_shlib_version=auto])
4024 AC_MSG_RESULT($cf_cv_shlib_version)
4029 # Some less-capable ports of gcc support only -fpic
4033 if test "$GCC" = yes
4037 case "$cf_cv_system_name" in
4038 (*linux*) # e.g., PGI compiler
4044 if test "$cf_try_fPIC" = yes
4046 AC_MSG_CHECKING(which $CC option to use)
4047 cf_save_CFLAGS="$CFLAGS"
4048 for CC_SHARED_OPTS in -fPIC -fpic ''
4050 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
4051 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1; (void)x],[break],[])
4053 AC_MSG_RESULT($CC_SHARED_OPTS)
4054 CFLAGS="$cf_save_CFLAGS"
4057 cf_cv_shlib_version_infix=no
4059 case "$cf_cv_system_name" in
4060 (aix4.[3-9]*|aix[[5-7]]*)
4061 if test "$GCC" = yes; then
4062 CC_SHARED_OPTS='-Wl,-brtl'
4063 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
4065 CC_SHARED_OPTS='-brtl'
4066 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
4067 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
4071 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
4075 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4076 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4077 cf_cv_shlib_version=cygdll
4078 cf_cv_shlib_version_infix=cygdll
4081 cat >mk_shared_lib.sh <<-CF_EOF
4084 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4087 Linking shared library
4088 ** SHARED_LIB \[$]SHARED_LIB
4089 ** IMPORT_LIB \[$]IMPORT_LIB
4091 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4093 chmod +x mk_shared_lib.sh
4097 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4098 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4099 cf_cv_shlib_version=msysdll
4100 cf_cv_shlib_version_infix=msysdll
4103 cat >mk_shared_lib.sh <<-CF_EOF
4106 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4109 Linking shared library
4110 ** SHARED_LIB \[$]SHARED_LIB
4111 ** IMPORT_LIB \[$]IMPORT_LIB
4113 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4115 chmod +x mk_shared_lib.sh
4118 cf_try_cflags="no-cpp-precomp"
4119 CC_SHARED_OPTS="-dynamic"
4120 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4121 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4122 cf_cv_shlib_version_infix=yes
4123 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4124 cf_save_LDFLAGS=$LDFLAGS
4125 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4126 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4127 LDFLAGS=$cf_save_LDFLAGS])
4128 if test "$cf_cv_ldflags_search_paths_first" = yes; then
4129 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4134 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4137 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
4138 if test "$GCC" != yes; then
4141 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
4142 INSTALL_LIB="-m 555"
4145 # (tested with gcc 2.7.2 -- I don't have c89)
4146 if test "$GCC" = yes; then
4147 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4150 LD_SHARED_OPTS='-Wl,+b,${libdir}'
4152 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
4153 # HP-UX shared libraries must be executable, and should be
4154 # readonly to exploit a quirk in the memory manager.
4155 INSTALL_LIB="-m 555"
4158 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4159 if test "$cf_cv_shlib_version" = rel; then
4160 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4162 cf_shared_soname='`basename $[@]`'
4165 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
4168 if test "$cf_cv_enable_rpath" = yes ; then
4169 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4171 # tested with IRIX 5.2 and 'cc'.
4172 if test "$GCC" != yes; then
4173 CC_SHARED_OPTS='-KPIC'
4174 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4176 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4178 cf_cv_rm_so_locs=yes
4180 (linux*|gnu*|k*bsd*-gnu)
4181 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4182 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4183 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4185 if test "$cf_cv_enable_rpath" = yes ; then
4186 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4189 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4192 cf_cv_shlib_version=msvcdll
4193 cf_cv_shlib_version_infix=msvcdll
4196 if test "$DFT_LWR_MODEL" = "shared" ; then
4197 LOCAL_LDFLAGS="-link -dll"
4198 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4199 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
4202 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
4203 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
4204 cat >mk_shared_lib.sh <<-CF_EOF
4207 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
4212 Linking shared library
4213 ** SHARED LIB \$SHARED_LIB
4214 ** IMPORT_LIB \$IMPORT_LIB
4216 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
4217 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
4218 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
4220 chmod +x mk_shared_lib.sh
4221 cat >mk_prog.sh <<-CF_EOF
4224 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
4227 ldopts=("/subsystem:console")
4230 while test \[$]# -gt 0; do
4233 # ignore -link argument
4235 -M[[TD]] | -M[[TD]]d)
4236 # ignore runtime-library option
4251 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
4254 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
4260 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
4261 ldopts+=("\[$]{linkarg}")
4269 ldopts+=("-out:\[$]1")
4278 if [[ "\$isdll" -ne 0 ]]; then
4279 for lib in \[$]{libs[[*]]}; do
4280 ldopts+=("\[$]lib.dll.lib")
4283 for lib in \[$]{libs[[*]]}; do
4284 ldopts+=("\[$]lib.lib")
4289 ** ld options: "\[$]{ldopts[[@]]}"
4291 exec \[$]LD \[$]{ldopts[[@]]}
4294 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
4295 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
4298 cf_cv_shlib_version=mingw
4299 cf_cv_shlib_version_infix=mingw
4302 if test "$DFT_LWR_MODEL" = "shared" ; then
4303 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
4304 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4305 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
4308 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4309 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4310 cat >mk_shared_lib.sh <<-CF_EOF
4313 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4316 Linking shared library
4317 ** SHARED_LIB \[$]SHARED_LIB
4318 ** IMPORT_LIB \[$]IMPORT_LIB
4320 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4322 chmod +x mk_shared_lib.sh
4324 (openbsd[[2-9]].*|mirbsd*)
4325 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4326 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4327 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4329 if test "$cf_cv_enable_rpath" = yes ; then
4330 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4332 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4334 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4338 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4342 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4344 (nto-qnx*|openbsd*|freebsd[[12]].*)
4345 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4346 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4347 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4349 (dragonfly*|freebsd*)
4350 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4351 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4352 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4353 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4354 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4357 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4360 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4361 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4362 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4363 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4364 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4365 if test "$cf_cv_shlib_version" = auto; then
4366 if test -f /usr/libexec/ld.elf_so; then
4367 cf_cv_shlib_version=abi
4369 cf_cv_shlib_version=rel
4373 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4375 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4379 # tested with OSF/1 V3.2 and 'cc'
4380 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4381 # link with shared libs).
4382 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4385 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4388 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4389 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4390 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4391 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4393 cf_cv_rm_so_locs=yes
4395 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
4396 # tested with osr5.0.5
4397 if test "$GCC" != yes; then
4398 CC_SHARED_OPTS='-belf -KPIC'
4400 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4401 if test "$cf_cv_enable_rpath" = yes ; then
4402 # only way is to set LD_RUN_PATH but no switch for it
4405 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4406 LINK_PROGS='LD_RUN_PATH=${libdir}'
4407 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4410 # tested with SunOS 4.1.1 and gcc 2.7.0
4411 if test "$GCC" != yes; then
4412 CC_SHARED_OPTS='-KPIC'
4414 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4415 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4418 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4419 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4420 if test "$DFT_LWR_MODEL" = "shared" ; then
4421 LOCAL_LDFLAGS="-R\$(LOCAL_LIBDIR):\${libdir}"
4422 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4424 if test "$cf_cv_enable_rpath" = yes ; then
4425 EXTRA_LDFLAGS="-R\${libdir} $EXTRA_LDFLAGS"
4428 if test "$GCC" != yes; then
4429 cf_save_CFLAGS="$CFLAGS"
4430 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4432 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4433 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
4435 CFLAGS="$cf_save_CFLAGS"
4436 CC_SHARED_OPTS=$cf_shared_opts
4437 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -Wl,-h,'$cf_cv_shared_soname' -o $[@]'
4439 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -Wl,-h,'$cf_cv_shared_soname' -o $[@]'
4442 (sysv5uw7*|unix_sv*)
4443 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4444 if test "$GCC" != yes; then
4445 CC_SHARED_OPTS='-KPIC'
4447 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4450 CC_SHARED_OPTS='unknown'
4451 MK_SHARED_LIB='echo unknown'
4455 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4456 case "$cf_cv_shlib_version" in
4458 case "$MK_SHARED_LIB" in
4460 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4463 AC_MSG_WARN(ignored --with-shlib-version)
4469 if test -n "$cf_try_cflags"
4471 cat > conftest.$ac_ext <<EOF
4472 #line __oline__ "${as_me:-configure}"
4474 int main(int argc, char *argv[[]])
4477 return (argv[[argc-1]] == 0) ;
4480 cf_save_CFLAGS="$CFLAGS"
4481 for cf_opt in $cf_try_cflags
4483 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4484 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4485 if AC_TRY_EVAL(ac_compile); then
4487 cf_save_CFLAGS="$CFLAGS"
4492 CFLAGS="$cf_save_CFLAGS"
4496 # RPATH_LIST is a colon-separated list of directories
4497 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4498 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4500 test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4502 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4503 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4505 AC_SUBST(CC_SHARED_OPTS)
4506 AC_SUBST(LD_RPATH_OPT)
4507 AC_SUBST(LD_SHARED_OPTS)
4508 AC_SUBST(MK_SHARED_LIB)
4509 AC_SUBST(RM_SHARED_OPTS)
4511 AC_SUBST(LINK_PROGS)
4512 AC_SUBST(LINK_TESTS)
4514 AC_SUBST(EXTRA_LDFLAGS)
4515 AC_SUBST(LOCAL_LDFLAGS)
4516 AC_SUBST(LOCAL_LDFLAGS2)
4518 AC_SUBST(INSTALL_LIB)
4519 AC_SUBST(RPATH_LIST)
4521 dnl ---------------------------------------------------------------------------
4522 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4523 dnl ----------------
4524 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4525 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4528 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4529 dnl If missing, use "rel".
4530 define([CF_SHARED_SONAME],
4532 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4533 if test "$cf_cv_shlib_version" = rel; then
4534 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4536 cf_cv_shared_soname='`basename $[@]`'
4539 dnl ---------------------------------------------------------------------------
4540 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
4542 dnl Remove "-g" option from the compiler options
4543 AC_DEFUN([CF_STRIP_G_OPT],
4544 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
4545 dnl ---------------------------------------------------------------------------
4546 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4548 dnl Construct a search-list for a nonstandard header/lib-file
4549 dnl $1 = the variable to return as result
4550 dnl $2 = the package name
4551 dnl $3 = the subdirectory, e.g., bin, include or lib
4552 AC_DEFUN([CF_SUBDIR_PATH],
4556 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4558 for cf_subdir_prefix in \
4566 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4569 dnl ---------------------------------------------------------------------------
4570 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
4572 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4573 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4574 dnl but some packagers change this, breaking various applications.
4575 AC_DEFUN([CF_TERM_HEADER],[
4576 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4577 case "${cf_cv_ncurses_header}" in
4578 (*/ncurses.h|*/ncursesw.h)
4579 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4582 cf_term_header=term.h
4586 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4588 AC_TRY_COMPILE([#include <stdio.h>
4589 #include <${cf_cv_ncurses_header:-curses.h}>
4591 ],[int x = auto_left_margin; (void)x],[
4592 cf_cv_term_header="$cf_test"],[
4593 cf_cv_term_header=unknown
4595 test "$cf_cv_term_header" != unknown && break
4599 # Set definitions to allow ifdef'ing to accommodate subdirectories
4601 case "$cf_cv_term_header" in
4603 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4607 case "$cf_cv_term_header" in
4609 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4612 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4616 dnl ---------------------------------------------------------------------------
4617 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4619 dnl Define a top_builddir symbol, for applications that need an absolute path.
4620 AC_DEFUN([CF_TOP_BUILDDIR],
4622 top_builddir=ifelse($1,,`pwd`,$1)
4623 AC_SUBST(top_builddir)
4625 dnl ---------------------------------------------------------------------------
4626 dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16
4627 dnl -------------------
4628 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4629 dnl can define it successfully.
4630 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4631 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4632 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4633 [cf_cv_xopen_source=no],
4634 [cf_save="$CPPFLAGS"
4635 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4636 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4637 [cf_cv_xopen_source=no],
4638 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4643 if test "$cf_cv_xopen_source" != no ; then
4644 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4645 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4646 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4647 CF_APPEND_CFLAGS($cf_temp_xopen_source)
4650 dnl ---------------------------------------------------------------------------
4651 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4653 dnl Make an uppercase version of a variable
4654 dnl $1=uppercase($2)
4655 AC_DEFUN([CF_UPPER],
4657 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4659 dnl ---------------------------------------------------------------------------
4660 dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23
4662 dnl Check for multibyte support, and if not found, utf8 compatibility library
4663 AC_DEFUN([CF_UTF8_LIB],
4665 AC_HAVE_HEADERS(wchar.h)
4666 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4667 cf_save_LIBS="$LIBS"
4669 $ac_includes_default
4674 [cf_cv_utf8_lib=yes],
4676 #include <libutf8.h>],[putwc(0,0);],utf8,
4677 [cf_cv_utf8_lib=add-on],
4678 [cf_cv_utf8_lib=no])
4681 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4683 if test "$cf_cv_utf8_lib" = "add-on" ; then
4684 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4685 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4686 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4687 CF_ADD_LIBS($cf_cv_library_file_utf8)
4690 dnl ---------------------------------------------------------------------------
4691 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4693 dnl Use AC_VERBOSE w/o the warnings
4694 AC_DEFUN([CF_VERBOSE],
4695 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4698 dnl ---------------------------------------------------------------------------
4699 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4701 dnl Check for compiler-support for weak symbols.
4702 dnl This works with "recent" gcc.
4703 AC_DEFUN([CF_WEAK_SYMBOLS],[
4704 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4707 #include <stdio.h>],
4709 #if defined(__GNUC__)
4710 # if defined __USE_ISOC99
4711 # define _cat_pragma(exp) _Pragma(#exp)
4712 # define _weak_pragma(exp) _cat_pragma(weak name)
4714 # define _weak_pragma(exp)
4716 # define _declare(name) __extension__ extern __typeof__(name) name
4717 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4721 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4724 dnl ---------------------------------------------------------------------------
4725 dnl CF_WITH_ADA version: 1 updated: 2024/05/18 13:55:23
4727 dnl Check for the Ada compiler (unless requested to not do this), which causes
4728 dnl a further check for a C compiler which can work with the Ada compiler.
4729 AC_DEFUN([CF_WITH_ADA],[
4731 [ --without-ada suppress check for Ada compiler],
4732 [cf_with_ada=$withval],
4736 if test "x$cf_with_ada" = xyes
4739 if test "x$cf_cv_prog_gnat_correct" = xyes; then
4740 # gcc's developers chose to deprecate gnatgcc before making gprconfig
4741 # work. They replaced gnatgcc in gcc 13 with a script which spits out
4742 # a warning offering advice which could never work.
4744 # Here is a workaround.
4745 AC_PATH_PROG(cf_cv_path_gnatgcc,gnatgcc,no)
4746 if test "$cf_cv_path_gnatgcc" != no
4748 AC_MSG_CHECKING(for improvement)
4749 cf_file_gnatgcc=`file -L "$cf_cv_path_gnatgcc" 2>/dev/null`
4750 case "x$cf_file_gnatgcc" in
4752 cf_cv_path_gnatgcc=`sh -x "$cf_cv_path_gnatgcc" --version 2>&1 | grep -w exec | sed -e 's/^[[ ]]*+[[ ]]*//' -e 's/exec[[ ]]//' -e 's/ .*//'`
4755 cf_cv_path_gnatgcc=no
4758 AC_MSG_RESULT($cf_cv_path_gnatgcc)
4759 test "$cf_cv_path_gnatgcc" = no && cf_cv_path_gnatgcc=gnatgcc
4760 cf_prog_cc="$cf_cv_path_gnatgcc $cf_prog_cc"
4764 case "$cf_prog_cc" in
4770 CF_PROG_CC($cf_prog_cc)
4774 dnl ---------------------------------------------------------------------------
4775 dnl CF_WITH_ADA_COMPILER version: 3 updated: 2023/10/28 11:59:01
4776 dnl --------------------
4777 dnl Command-line option to specify the Ada95 compiler.
4778 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4779 AC_MSG_CHECKING(for Ada95 compiler)
4780 AC_ARG_WITH(ada-compiler,
4781 [[ --with-ada-compiler[=CMD] use CMD as Ada95 compiler (default: gnatmake)]],
4782 [cf_ada_compiler=$withval],
4783 [cf_ada_compiler=gnatmake])
4784 AC_SUBST(cf_ada_compiler)
4785 AC_MSG_RESULT($cf_ada_compiler)
4787 dnl ---------------------------------------------------------------------------
4788 dnl CF_WITH_ADA_INCLUDE version: 3 updated: 2023/10/28 11:59:01
4789 dnl -------------------
4790 dnl Command-line option to specify where Ada includes will install.
4791 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4792 AC_MSG_CHECKING(for Ada95 include directory)
4793 CF_WITH_PATH(ada-include,
4794 [ --with-ada-include=DIR find Ada95 includes in DIR],
4796 PREFIX/share/ada/adainclude,
4797 [$]prefix/share/ada/adainclude)
4798 AC_SUBST(ADA_INCLUDE)
4799 AC_MSG_RESULT($ADA_INCLUDE)
4801 dnl ---------------------------------------------------------------------------
4802 dnl CF_WITH_ADA_LIBNAME version: 3 updated: 2023/11/22 20:48:30
4803 dnl -------------------
4804 dnl CF_WITH_ADA_LIBNAME
4805 dnl -------------------
4806 dnl Command-line option to specify how to name the resulting Ada library.
4807 dnl $1 = default value
4808 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4809 AC_MSG_CHECKING(for Ada95 curses library name)
4810 AC_ARG_WITH(ada-libname,
4811 [[ --with-ada-libname[=XXX] use XXX as Ada95 library name]],
4812 ADA_LIBNAME=[$]withval,
4814 case "x$ADA_LIBNAME" in
4819 AC_SUBST(ADA_LIBNAME)
4820 AC_MSG_RESULT($ADA_LIBNAME)
4822 dnl ---------------------------------------------------------------------------
4823 dnl CF_WITH_ADA_OBJECTS version: 3 updated: 2023/10/28 11:59:01
4824 dnl -------------------
4825 dnl Command-line option to specify where Ada objects will install.
4826 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4827 AC_MSG_CHECKING(for Ada95 object directory)
4828 CF_WITH_PATH(ada-objects,
4829 [ --with-ada-objects=DIR find Ada95 objects in DIR],
4831 PREFIX/lib/ada/adalib,
4832 [$]prefix/lib/ada/adalib)
4833 AC_SUBST(ADA_OBJECTS)
4834 AC_MSG_RESULT($ADA_OBJECTS)
4836 dnl ---------------------------------------------------------------------------
4837 dnl CF_WITH_ADA_SHAREDLIB version: 6 updated: 2023/10/28 11:59:01
4838 dnl ---------------------
4839 dnl Command-line option to specify if an Ada95 shared library should be built,
4840 dnl and optionally what its soname should be.
4841 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4842 AC_REQUIRE([CF_GNAT_PROJECTS])
4843 AC_MSG_CHECKING(whether to build an Ada95 shared library)
4844 AC_ARG_WITH(ada-sharedlib,
4845 [ --with-ada-sharedlib build Ada95 shared library; requires GNAT project support],
4846 [with_ada_sharedlib=$withval],
4847 [with_ada_sharedlib=no])
4848 cf_ada_sharedlib_warn=no
4850 if test "x$with_ada_sharedlib" != xno
4852 if test "x$cf_gnat_projects" != xyes
4854 with_ada_sharedlib=no
4855 cf_ada_sharedlib_warn=yes
4859 AC_MSG_RESULT($with_ada_sharedlib)
4860 if test "x$cf_ada_sharedlib_warn" != xno
4862 AC_MSG_WARN(disabling Ada95 shared library since GNAT projects are not supported)
4865 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4866 MAKE_ADA_SHAREDLIB="#"
4868 if test "x$with_ada_sharedlib" != xno
4871 if test "x$with_ada_sharedlib" != xyes
4873 ADA_SHAREDLIB="$with_ada_sharedlib"
4877 AC_SUBST(ADA_SHAREDLIB)
4878 AC_SUBST(MAKE_ADA_SHAREDLIB)
4880 dnl ---------------------------------------------------------------------------
4881 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4882 dnl ------------------
4883 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4885 AC_DEFUN([CF_WITH_CURSES_DIR],[
4887 AC_MSG_CHECKING(for specific curses-directory)
4888 AC_ARG_WITH(curses-dir,
4889 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4890 [cf_cv_curses_dir=$withval],
4891 [cf_cv_curses_dir=no])
4892 AC_MSG_RESULT($cf_cv_curses_dir)
4894 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4896 CF_PATH_SYNTAX(withval)
4897 if test -d "$cf_cv_curses_dir"
4899 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4900 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4904 dnl ---------------------------------------------------------------------------
4905 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
4906 dnl ------------------
4907 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4908 dnl "lib" prefix, e.g., because it used the dll naming convention.
4910 dnl $1 = variable to set
4911 AC_DEFUN([CF_WITH_LIB_PREFIX],
4913 AC_MSG_CHECKING(if you want to have a library-prefix)
4914 AC_ARG_WITH(lib-prefix,
4915 [ --with-lib-prefix override library-prefix],
4916 [with_lib_prefix=$withval],
4917 [with_lib_prefix=auto])
4918 AC_MSG_RESULT($with_lib_prefix)
4920 if test "$with_lib_prefix" = auto
4923 elif test "$with_lib_prefix" = no
4927 LIB_PREFIX=$with_lib_prefix
4930 dnl ---------------------------------------------------------------------------
4931 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
4933 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4934 dnl defaulting to yes/no.
4936 dnl $1 = option name
4938 dnl $3 = environment variable to set
4939 dnl $4 = default value, shown in the help-message, must be a constant
4940 dnl $5 = default value, if it is an expression & cannot be in the help-message
4942 AC_DEFUN([CF_WITH_PATH],
4943 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4944 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4945 if ifelse([$5],,true,[test -n "$5"]) ; then
4946 CF_PATH_SYNTAX(withval)
4951 dnl ---------------------------------------------------------------------------
4952 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 23 updated: 2023/11/22 20:48:30
4953 dnl -------------------------
4954 dnl Allow the choice of the pkg-config library directory to be overridden.
4956 dnl pkg-config uses a search-list built from these colon-separated lists of
4958 dnl a) $PKG_CONFIG_PATH (tested first, added if set)
4959 dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
4960 dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
4962 dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
4963 dnl optionally ignores $PKG_CONFIG_LIBDIR. Very old versions of pkg-config,
4964 dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR.
4965 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4967 case "$PKG_CONFIG" in
4969 AC_MSG_CHECKING(for pkg-config library directory)
4972 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4976 # if $PKG_CONFIG_LIBDIR is set, try to use that
4977 if test -n "$PKG_CONFIG_PATH"; then
4978 cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
4979 elif test -n "$PKG_CONFIG_LIBDIR"; then
4980 cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
4985 # if the option is used, let that override. otherwise default to "libdir"
4986 AC_ARG_WITH(pkg-config-libdir,
4987 [[ --with-pkg-config-libdir[=XXX] use given directory for installing pc-files]],
4988 [cf_search_path=$withval],
4989 [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
4991 case "x$cf_search_path" in
4993 PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
4994 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
5003 PKG_CONFIG_LIBDIR="$cf_search_path"
5004 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
5010 # Look for the library directory using the same prefix as the executable
5011 AC_MSG_CHECKING(for search-list)
5012 if test "x$PKG_CONFIG" != xnone
5014 # works for pkg-config since version 0.24 (2009)
5015 # works for pkgconf since version 0.8.3 (2012)
5016 for cf_pkg_program in \
5017 `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
5021 cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
5022 test -n "$cf_search_path" && break
5025 # works for pkg-config since import in 2005 of original 2001 HP code.
5026 test -z "$cf_search_path" && \
5028 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
5029 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
5030 sub(\"^[[^']]*'\",\"\"); \
5031 sub(\"'.*\",\"\"); \
5032 printf \" %s\", \\[$]0; } \
5037 AC_MSG_RESULT($cf_search_path)
5040 AC_MSG_ERROR(Unexpected option value: $cf_search_path)
5044 if test -n "$cf_search_path"
5046 AC_MSG_CHECKING(for first directory)
5047 cf_pkg_config_path=none
5048 for cf_config in $cf_search_path
5050 if test -d "$cf_config"
5052 cf_pkg_config_path=$cf_config
5056 AC_MSG_RESULT($cf_pkg_config_path)
5058 if test "x$cf_pkg_config_path" != xnone ; then
5059 # limit this to the first directory found
5060 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
5063 if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
5065 AC_MSG_CHECKING(for workaround)
5066 if test "$prefix" = "NONE" ; then
5067 cf_prefix="$ac_default_prefix"
5071 eval cf_libdir=$libdir
5072 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
5074 for cf_config in $cf_search_path
5077 $cf_libdir/pkgconfig)
5078 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
5082 test -z "$cf_backup" && cf_backup=$cf_config
5086 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
5087 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
5091 AC_SUBST(PKG_CONFIG_LIBDIR)
5093 dnl ---------------------------------------------------------------------------
5094 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
5096 dnl Check for POSIX thread library.
5097 AC_DEFUN([CF_WITH_PTHREAD],
5099 AC_MSG_CHECKING(if you want to link with the pthread library)
5100 AC_ARG_WITH(pthread,
5101 [ --with-pthread use POSIX thread library],
5102 [with_pthread=$withval],
5104 AC_MSG_RESULT($with_pthread)
5106 if test "$with_pthread" != no ; then
5107 AC_CHECK_HEADER(pthread.h,[
5108 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
5110 for cf_lib_pthread in pthread c_r
5112 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
5113 cf_save_LIBS="$LIBS"
5114 CF_ADD_LIB($cf_lib_pthread)
5116 #include <pthread.h>
5118 int rc = pthread_create(0,0,0,0);
5119 int r2 = pthread_mutexattr_settype(0, 0);
5120 ],[with_pthread=yes],[with_pthread=no])
5121 LIBS="$cf_save_LIBS"
5122 AC_MSG_RESULT($with_pthread)
5123 test "$with_pthread" = yes && break
5126 if test "$with_pthread" = yes ; then
5127 CF_ADD_LIB($cf_lib_pthread)
5128 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
5130 AC_MSG_ERROR(Cannot link with pthread library)
5135 dnl ---------------------------------------------------------------------------
5136 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
5138 dnl For testing, override the derived host system-type which is used to decide
5139 dnl things such as the linker commands used to build shared libraries. This is
5140 dnl normally chosen automatically based on the type of system which you are
5141 dnl building on. We use it for testing the configure script.
5143 dnl This is different from the --host option: it is used only for testing parts
5144 dnl of the configure script which would not be reachable with --host since that
5145 dnl relies on the build environment being real, rather than mocked up.
5146 AC_DEFUN([CF_WITH_SYSTYPE],[
5147 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
5148 AC_ARG_WITH(system-type,
5149 [ --with-system-type=XXX test: override derived host system-type],
5150 [AC_MSG_WARN(overriding system type to $withval)
5151 cf_cv_system_name=$withval
5155 dnl ---------------------------------------------------------------------------
5156 dnl CF_XOPEN_SOURCE version: 67 updated: 2023/09/06 18:55:27
5158 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5159 dnl or adapt to the vendor's definitions to get equivalent functionality,
5160 dnl without losing the common non-POSIX features.
5163 dnl $1 is the nominal value for _XOPEN_SOURCE
5164 dnl $2 is the nominal value for _POSIX_C_SOURCE
5166 dnl The default case prefers _XOPEN_SOURCE over _POSIX_C_SOURCE if the
5167 dnl implementation predefines it, because X/Open and most implementations agree
5168 dnl that the latter is a legacy or "aligned" value.
5170 dnl Because _XOPEN_SOURCE is preferred, if defining _POSIX_C_SOURCE turns
5171 dnl that off, then refrain from setting _POSIX_C_SOURCE explicitly.
5174 dnl https://pubs.opengroup.org/onlinepubs/007904975/functions/xsh_chap02_02.html
5175 dnl https://docs.oracle.com/cd/E19253-01/816-5175/standards-5/index.html
5176 dnl https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
5177 AC_DEFUN([CF_XOPEN_SOURCE],[
5178 AC_REQUIRE([AC_CANONICAL_HOST])
5179 AC_REQUIRE([CF_POSIX_VISIBLE])
5181 if test "$cf_cv_posix_visible" = no; then
5183 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
5184 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
5189 cf_xopen_source="-D_ALL_SOURCE"
5192 cf_xopen_source="-D_APPLE_C_SOURCE"
5195 cf_xopen_source="-D_DARWIN_C_SOURCE"
5198 (freebsd*|dragonfly*|midnightbsd*)
5199 # 5.x headers associate
5200 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5201 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5202 cf_POSIX_C_SOURCE=200112L
5204 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5207 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
5210 cf_xopen_source="-D_HPUX_SOURCE"
5213 cf_xopen_source="-D_SGI_SOURCE"
5216 (linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys|mingw*|linux*uclibc)
5217 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
5220 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
5223 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
5225 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5228 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5231 # OpenBSD 6.x has broken locale support, both compile-time and runtime.
5232 # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
5233 # Abusing the conformance level is a workaround.
5234 AC_MSG_WARN(this system does not provide usable locale support)
5235 cf_xopen_source="-D_BSD_SOURCE"
5239 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
5240 cf_xopen_source="-D_BSD_SOURCE"
5244 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5247 cf_xopen_source="-D_OSF_SOURCE"
5250 cf_xopen_source="-D_QNX_SOURCE"
5253 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5256 cf_xopen_source="-D__EXTENSIONS__"
5257 cf_cv_xopen_source=broken
5259 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
5265 cf_save_xopen_cppflags="$CPPFLAGS"
5266 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5267 # Some of these niche implementations use copy/paste, double-check...
5268 if test "$cf_cv_xopen_source" = no ; then
5269 CF_VERBOSE(checking if _POSIX_C_SOURCE interferes with _XOPEN_SOURCE)
5270 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[
5271 AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
5272 CPPFLAGS="$cf_save_xopen_cppflags"])
5277 if test -n "$cf_xopen_source" ; then
5278 CF_APPEND_CFLAGS($cf_xopen_source,true)
5281 dnl In anything but the default case, we may have system-specific setting
5282 dnl which is still not guaranteed to provide all of the entrypoints that
5283 dnl _XOPEN_SOURCE would yield.
5284 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
5285 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
5286 AC_TRY_COMPILE([#include <stdlib.h>],[
5287 #ifndef _XOPEN_SOURCE
5288 #error _XOPEN_SOURCE is not defined
5290 [cf_XOPEN_SOURCE_set=yes],
5291 [cf_XOPEN_SOURCE_set=no])
5292 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
5293 if test "$cf_XOPEN_SOURCE_set" = yes
5295 AC_TRY_COMPILE([#include <stdlib.h>],[
5296 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
5297 #error (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
5299 [cf_XOPEN_SOURCE_set_ok=yes],
5300 [cf_XOPEN_SOURCE_set_ok=no])
5301 if test "$cf_XOPEN_SOURCE_set_ok" = no
5303 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
5309 fi # cf_cv_posix_visible
5311 dnl ---------------------------------------------------------------------------
5312 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
5313 dnl ------------------
5314 dnl Trim something using sed, then trim extra whitespace
5315 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
5316 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl
5317 dnl ---------------------------------------------------------------------------
5318 dnl CF__XOPEN_SOURCE_BODY version: 2 updated: 2023/02/18 17:41:25
5319 dnl ---------------------
5320 dnl body of test when test-compiling for _XOPEN_SOURCE check
5321 define([CF__XOPEN_SOURCE_BODY],
5323 #ifndef _XOPEN_SOURCE
5324 #error _XOPEN_SOURCE is not defined
5327 dnl ---------------------------------------------------------------------------
5328 dnl CF__XOPEN_SOURCE_HEAD version: 2 updated: 2023/02/18 17:41:25
5329 dnl ---------------------
5330 dnl headers to include when test-compiling for _XOPEN_SOURCE check
5331 define([CF__XOPEN_SOURCE_HEAD],
5333 $ac_includes_default