1 dnl***************************************************************************
2 dnl Copyright 2018-2022,2023 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.199 2023/01/22 18:37:42 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: 11 updated: 2022/12/04 15:40:08
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:='${CPPFLAGS}'}
581 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
582 : ${BUILD_LIBS:='${LIBS}'}
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: 3 updated: 2021/03/28 11:36:23
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,
613 #include <stdnoreturn.h>
614 static _Noreturn void giveup(void) { exit(0); }
616 [if (feof(stdin)) giveup()],
617 cf_cv_c11_noreturn=yes,
618 cf_cv_c11_noreturn=no)
621 cf_cv_c11_noreturn=no,
624 if test "$cf_cv_c11_noreturn" = yes; then
625 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
626 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
632 AC_SUBST(HAVE_STDNORETURN_H)
633 AC_SUBST(STDC_NORETURN)
635 dnl ---------------------------------------------------------------------------
636 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
638 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
639 dnl into CC. This will not help with broken scripts that wrap the compiler
640 dnl with options, but eliminates a more common category of user confusion.
642 dnl In particular, it addresses the problem of being able to run the C
643 dnl preprocessor in a consistent manner.
645 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
646 dnl the nuisance of having inconsistent settings for compiler and preprocessor
647 dnl outweighs that limitation.
648 AC_DEFUN([CF_CC_ENV_FLAGS],
650 # This should have been defined by AC_PROG_CC
653 AC_MSG_CHECKING(\$CFLAGS variable)
656 AC_MSG_RESULT(broken)
657 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
660 for cf_arg in $cf_flags
662 CF_ADD_CFLAGS($cf_arg)
670 AC_MSG_CHECKING(\$CC variable)
673 AC_MSG_RESULT(broken)
674 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
676 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
677 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
679 for cf_arg in $cf_flags
683 CF_ADD_CFLAGS($cf_arg)
690 CF_VERBOSE(resulting CC: '$CC')
691 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
692 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
699 dnl ---------------------------------------------------------------------------
700 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
702 dnl Determine the default configuration into which we'll install ncurses. This
703 dnl can be overridden by the user's command-line options. There's two items to
705 dnl 1. the prefix (e.g., /usr)
706 dnl 2. the header files (e.g., /usr/include/ncurses)
707 dnl We'll look for a previous installation of ncurses and use the same defaults.
709 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
710 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
711 dnl programs from a vendor's.
712 AC_DEFUN([CF_CFG_DEFAULTS],
713 [AC_REQUIRE([AC_PROG_FGREP])dnl
715 AC_MSG_CHECKING(for prefix)
716 if test "x$prefix" = "xNONE" ; then
717 case "$cf_cv_system_name" in
718 # non-vendor systems don't have a conflict
719 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
722 (*) prefix=$ac_default_prefix
726 AC_MSG_RESULT($prefix)
728 if test "x$prefix" = "xNONE" ; then
729 AC_MSG_CHECKING(for default include-directory)
730 test -n "$verbose" && echo 1>&AC_FD_MSG
733 "$includedir/ncurses" \
735 "$prefix/include/ncurses" \
737 /usr/local/include/ncurses \
741 cf_dir=`eval echo "$cf_symbol"`
742 if test -f "$cf_dir/curses.h" ; then
743 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
744 includedir="$cf_symbol"
745 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
749 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
751 AC_MSG_RESULT($includedir)
754 dnl ---------------------------------------------------------------------------
755 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
757 dnl Check if we're accidentally using a cache from a different machine.
758 dnl Derive the system name, as a check for reusing the autoconf cache.
760 dnl If we've packaged config.guess and config.sub, run that (since it does a
761 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
762 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
763 dnl which is useful in cross-compiles.
765 dnl Note: we would use $ac_config_sub, but that is one of the places where
766 dnl autoconf 2.5x broke compatibility with autoconf 2.13
767 AC_DEFUN([CF_CHECK_CACHE],
769 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
770 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
771 system_name="$host_os"
773 system_name="`(uname -s -r) 2>/dev/null`"
774 if test -z "$system_name" ; then
775 system_name="`(hostname) 2>/dev/null`"
778 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
779 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
781 test -z "$system_name" && system_name="$cf_cv_system_name"
782 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
784 if test ".$system_name" != ".$cf_cv_system_name" ; then
785 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
786 AC_MSG_ERROR("Please remove config.cache and try again.")
789 dnl ---------------------------------------------------------------------------
790 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
791 dnl ---------------------
792 AC_DEFUN([CF_CHECK_GNAT_VERSION],
794 AC_REQUIRE([CF_GNAT_VERSION])
795 case "$cf_cv_gnat_version" in
796 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
797 cf_cv_prog_gnat_correct=yes
800 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
801 cf_cv_prog_gnat_correct=no
805 dnl ---------------------------------------------------------------------------
806 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
808 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
809 dnl used in cross-compiling to MinGW.
810 AC_DEFUN([CF_CHECK_LIBSSP],[
811 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
813 #include <sys/types.h>
816 DIR *dp = opendir(".");
817 ],cf_cv_need_libssp=no,[
821 #include <sys/types.h>
824 DIR *dp = opendir(".");
825 ],cf_cv_need_libssp=yes,
826 cf_cv_need_libssp=maybe)
831 if test "x$cf_cv_need_libssp" = xyes
836 dnl ---------------------------------------------------------------------------
837 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
838 dnl -----------------
839 dnl Check if the given compiler is really clang. clang's C driver defines
840 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
841 dnl not ignore some gcc options.
843 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
844 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
845 dnl the wrappers for gcc and g++ warnings.
847 dnl $1 = GCC (default) or GXX
848 dnl $2 = CLANG_COMPILER (default)
849 dnl $3 = CFLAGS (default) or CXXFLAGS
850 AC_DEFUN([CF_CLANG_COMPILER],[
851 ifelse([$2],,CLANG_COMPILER,[$2])=no
853 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
854 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
855 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
861 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
863 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
864 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
869 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
871 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
872 AC_MSG_WARN(replacing broken compiler alias $CC)
873 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
878 AC_MSG_CHECKING(version of $CC)
879 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.]].*//'`"
880 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
881 AC_MSG_RESULT($CLANG_VERSION)
883 for cf_clang_opt in \
885 -Wno-error=implicit-function-declaration
887 AC_MSG_CHECKING(if option $cf_clang_opt works)
888 cf_save_CFLAGS="$CFLAGS"
889 CFLAGS="$CFLAGS $cf_clang_opt"
891 #include <stdio.h>],[
892 printf("hello!\\n");],[
893 cf_clang_optok=yes],[
895 AC_MSG_RESULT($cf_clang_optok)
896 CFLAGS="$cf_save_CFLAGS"
897 if test "$cf_clang_optok" = yes; then
898 CF_VERBOSE(adding option $cf_clang_opt)
899 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
904 dnl ---------------------------------------------------------------------------
905 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
906 dnl -----------------
907 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
908 dnl character-strings.
910 dnl It is ambiguous because the specification accommodated the pre-ANSI
911 dnl compilers bundled by more than one vendor in lieu of providing a standard C
912 dnl compiler other than by costly add-ons. Because of this, the specification
913 dnl did not take into account the use of const for telling the compiler that
914 dnl string literals would be in readonly memory.
916 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
917 dnl let the compiler decide how to represent Xt's strings which were #define'd.
918 dnl That does not solve the problem of using the block of Xt's strings which
919 dnl are compiled into the library (and is less efficient than one might want).
921 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
922 dnl when compiling the library and compiling using the library, to tell the
923 dnl compiler that String is const.
924 AC_DEFUN([CF_CONST_X_STRING],
926 AC_REQUIRE([AC_PATH_XTRA])
928 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
933 #include <X11/Intrinsic.h>
935 [String foo = malloc(1); free((void*)foo)],[
937 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
940 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
941 #undef XTSTRINGDEFINES /* X11R5 and later */
943 #include <X11/Intrinsic.h>
944 ],[String foo = malloc(1); *foo = 0],[
945 cf_cv_const_x_string=no
947 cf_cv_const_x_string=yes
951 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
953 case "$cf_cv_const_x_string" in
955 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
958 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
964 dnl ---------------------------------------------------------------------------
965 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
966 dnl -----------------
967 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
968 dnl character-strings.
970 dnl It is ambiguous because the specification accommodated the pre-ANSI
971 dnl compilers bundled by more than one vendor in lieu of providing a standard C
972 dnl compiler other than by costly add-ons. Because of this, the specification
973 dnl did not take into account the use of const for telling the compiler that
974 dnl string literals would be in readonly memory.
976 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
977 dnl let the compiler decide how to represent Xt's strings which were #define'd.
978 dnl That does not solve the problem of using the block of Xt's strings which
979 dnl are compiled into the library (and is less efficient than one might want).
981 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
982 dnl when compiling the library and compiling using the library, to tell the
983 dnl compiler that String is const.
984 AC_DEFUN([CF_CONST_X_STRING],
986 AC_REQUIRE([AC_PATH_XTRA])
988 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
993 #include <X11/Intrinsic.h>
995 [String foo = malloc(1); free((void*)foo)],[
997 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1000 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1001 #undef XTSTRINGDEFINES /* X11R5 and later */
1003 #include <X11/Intrinsic.h>
1004 ],[String foo = malloc(1); *foo = 0],[
1005 cf_cv_const_x_string=no
1007 cf_cv_const_x_string=yes
1011 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1013 case "$cf_cv_const_x_string" in
1015 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1018 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1024 dnl ---------------------------------------------------------------------------
1025 dnl CF_CURSES_HEADER version: 6 updated: 2022/12/02 20:06:52
1026 dnl ----------------
1027 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
1028 dnl variations of ncurses' installs.
1030 dnl $1 = ncurses when looking for ncurses, or is empty
1031 AC_DEFUN([CF_CURSES_HEADER],[
1032 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
1033 cf_cv_ncurses_header=none
1035 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
1036 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
1038 AC_TRY_COMPILE([#include <${cf_header}>],
1039 [initscr(); endwin()],
1040 [cf_cv_ncurses_header=$cf_header; break],[])
1044 if test "$cf_cv_ncurses_header" = none ; then
1045 AC_MSG_ERROR(No curses header-files found)
1048 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
1049 AC_CHECK_HEADERS($cf_cv_ncurses_header)
1051 dnl ---------------------------------------------------------------------------
1052 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1054 dnl "dirname" is not portable, so we fake it with a shell script.
1055 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1056 dnl ---------------------------------------------------------------------------
1057 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1059 dnl You can always use "make -n" to see the actual options, but it is hard to
1060 dnl pick out/analyze warning messages when the compile-line is long.
1063 dnl ECHO_LT - symbol to control if libtool is verbose
1064 dnl ECHO_LD - symbol to prefix "cc -o" lines
1065 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1066 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1067 dnl ECHO_CC - symbol to put before any "cc" line
1069 AC_DEFUN([CF_DISABLE_ECHO],[
1070 AC_MSG_CHECKING(if you want to see long compiling messages)
1071 CF_ARG_DISABLE(echo,
1072 [ --disable-echo do not display "compiling" commands],
1075 ECHO_LD='@echo linking [$]@;'
1076 RULE_CC='@echo compiling [$]<'
1077 SHOW_CC='@echo compiling [$]@'
1086 AC_MSG_RESULT($enableval)
1093 dnl ---------------------------------------------------------------------------
1094 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1095 dnl ------------------------
1096 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1097 AC_MSG_CHECKING(if we want to use GNAT projects)
1098 CF_ARG_DISABLE(gnat-projects,
1099 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1100 [enable_gnat_projects=no],
1101 [enable_gnat_projects=yes])
1102 AC_MSG_RESULT($enable_gnat_projects)
1104 dnl ---------------------------------------------------------------------------
1105 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
1106 dnl -----------------------
1107 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
1108 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1109 dnl an unconditional feature.
1110 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1112 AC_MSG_CHECKING(if you want broken-linker support code)
1113 AC_ARG_ENABLE(broken_linker,
1114 [ --enable-broken_linker compile with broken-linker support code],
1115 [with_broken_linker=$enableval],
1116 [with_broken_linker=no])
1117 AC_MSG_RESULT($with_broken_linker)
1119 : "${BROKEN_LINKER:=0}"
1120 if test "x$with_broken_linker" = xyes ; then
1121 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1124 AC_SUBST(BROKEN_LINKER)
1126 dnl ---------------------------------------------------------------------------
1127 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1128 dnl ------------------
1129 dnl Configure-option to enable gcc warnings
1131 dnl $1 = extra options to add, if supported
1132 dnl $2 = option for checking attributes. By default, this is done when
1133 dnl warnings are enabled. For other values:
1134 dnl yes: always do this, e.g., to use in generated library-headers
1135 dnl no: never do this
1136 AC_DEFUN([CF_ENABLE_WARNINGS],[
1137 if test "$GCC" = yes || test "$GXX" = yes
1139 CF_FIX_WARNINGS(CFLAGS)
1140 CF_FIX_WARNINGS(CPPFLAGS)
1141 CF_FIX_WARNINGS(LDFLAGS)
1142 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1143 CF_ARG_ENABLE(warnings,
1144 [ --enable-warnings test: turn on gcc compiler warnings],
1145 [enable_warnings=yes],
1146 [enable_warnings=no])
1147 AC_MSG_RESULT($enable_warnings)
1148 if test "$enable_warnings" = "yes"
1150 ifelse($2,,[CF_GCC_ATTRIBUTES])
1153 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1156 dnl ---------------------------------------------------------------------------
1157 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1159 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1160 dnl prefer a standard location, and use -L options only if we do not find the
1161 dnl library in the standard library location(s).
1162 dnl $1 = library name
1163 dnl $2 = library class, usually the same as library name
1165 dnl $4 = code fragment to compile/link
1166 dnl $5 = corresponding function-name
1167 dnl $6 = flag, nonnull if failure should not cause an error-exit
1169 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1170 dnl to use a -L option.
1171 AC_DEFUN([CF_FIND_LIBRARY],
1173 eval 'cf_cv_have_lib_'"$1"'=no'
1176 eval 'cf_cv_have_lib_'"$1"'=yes',[
1177 cf_save_LIBS="$LIBS"
1178 AC_MSG_CHECKING(for $5 in -l$1)
1180 AC_TRY_LINK([$3],[$4],
1182 eval 'cf_cv_have_lib_'"$1"'=yes'
1185 CF_LIBRARY_PATH(cf_search,$2)
1186 for cf_libdir in $cf_search
1188 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1189 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1190 AC_TRY_LINK([$3],[$4],
1192 eval 'cf_cv_have_lib_'"$1"'=yes'
1195 LIBS="$cf_save_LIBS"])
1199 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1201 if test "$cf_found_library" = no ; then
1202 AC_MSG_ERROR(Cannot link $1 library)
1206 dnl ---------------------------------------------------------------------------
1207 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1209 dnl Find a library (specifically the linkage used in the code fragment),
1210 dnl searching for it if it is not already in the library path.
1211 dnl See also CF_ADD_SEARCHPATH.
1213 dnl Parameters (4-on are optional):
1214 dnl $1 = headers for library entrypoint
1215 dnl $2 = code fragment for library entrypoint
1216 dnl $3 = the library name without the "-l" option or ".so" suffix.
1217 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1218 dnl $5 = action to perform if not successful
1219 dnl $6 = module name, if not the same as the library name
1220 dnl $7 = extra libraries
1222 dnl Sets these variables:
1223 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1224 dnl $cf_cv_header_path_$3 - include-directory if needed
1225 dnl $cf_cv_library_path_$3 - library-directory if needed
1226 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1227 AC_DEFUN([CF_FIND_LINKAGE],[
1229 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1230 # will be set on completion of the AC_TRY_LINK below.
1231 cf_cv_header_path_$3=
1232 cf_cv_library_path_$3=
1234 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1236 cf_save_LIBS="$LIBS"
1238 AC_TRY_LINK([$1],[$2],[
1239 cf_cv_find_linkage_$3=yes
1240 cf_cv_header_path_$3=/usr/include
1241 cf_cv_library_path_$3=/usr/lib
1244 LIBS="-l$3 $7 $cf_save_LIBS"
1246 AC_TRY_LINK([$1],[$2],[
1247 cf_cv_find_linkage_$3=yes
1248 cf_cv_header_path_$3=/usr/include
1249 cf_cv_library_path_$3=/usr/lib
1250 cf_cv_library_file_$3="-l$3"
1252 cf_cv_find_linkage_$3=no
1253 LIBS="$cf_save_LIBS"
1255 CF_VERBOSE(find linkage for $3 library)
1256 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1258 cf_save_CPPFLAGS="$CPPFLAGS"
1259 cf_test_CPPFLAGS="$CPPFLAGS"
1261 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1262 for cf_cv_header_path_$3 in $cf_search
1264 if test -d "$cf_cv_header_path_$3" ; then
1265 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1266 CPPFLAGS="$cf_save_CPPFLAGS"
1267 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1268 AC_TRY_COMPILE([$1],[$2],[
1269 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1270 cf_cv_find_linkage_$3=maybe
1271 cf_test_CPPFLAGS="$CPPFLAGS"
1273 CPPFLAGS="$cf_save_CPPFLAGS"
1278 if test "$cf_cv_find_linkage_$3" = maybe ; then
1280 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1282 cf_save_LIBS="$LIBS"
1283 cf_save_LDFLAGS="$LDFLAGS"
1286 CPPFLAGS="$cf_test_CPPFLAGS"
1287 LIBS="-l$3 $7 $cf_save_LIBS"
1288 AC_TRY_LINK([$1],[$2],[
1289 CF_VERBOSE(... found $3 library in system)
1290 cf_cv_find_linkage_$3=yes])
1291 CPPFLAGS="$cf_save_CPPFLAGS"
1292 LIBS="$cf_save_LIBS"
1295 if test "$cf_cv_find_linkage_$3" != yes ; then
1296 CF_LIBRARY_PATH(cf_search,$3)
1297 for cf_cv_library_path_$3 in $cf_search
1299 if test -d "$cf_cv_library_path_$3" ; then
1300 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1301 CPPFLAGS="$cf_test_CPPFLAGS"
1302 LIBS="-l$3 $7 $cf_save_LIBS"
1303 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1304 AC_TRY_LINK([$1],[$2],[
1305 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1306 cf_cv_find_linkage_$3=yes
1307 cf_cv_library_file_$3="-l$3"
1309 CPPFLAGS="$cf_save_CPPFLAGS"
1310 LIBS="$cf_save_LIBS"
1311 LDFLAGS="$cf_save_LDFLAGS"
1315 CPPFLAGS="$cf_save_CPPFLAGS"
1316 LDFLAGS="$cf_save_LDFLAGS"
1320 cf_cv_find_linkage_$3=no
1325 LIBS="$cf_save_LIBS"
1327 if test "$cf_cv_find_linkage_$3" = yes ; then
1329 CF_ADD_INCDIR($cf_cv_header_path_$3)
1330 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1334 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1337 dnl ---------------------------------------------------------------------------
1338 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1339 dnl -----------------
1340 dnl make ADAFLAGS consistent with CFLAGS
1341 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1342 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1350 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1351 CF_ADD_ADAFLAGS($cf_O_flag)
1354 AC_MSG_RESULT($ADAFLAGS)
1356 dnl ---------------------------------------------------------------------------
1357 dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31
1359 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1360 dnl "-Werror" flags can interfere with configure-checks. Those go into
1363 dnl $1 = variable name to repair
1364 define([CF_FIX_WARNINGS],[
1365 if test "$GCC" = yes || test "$GXX" = yes
1370 for cf_temp_scan in [$]$1
1372 case "x$cf_temp_scan" in
1374 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1377 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1380 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1384 if test "x[$]$1" != "x$cf_temp_flags"
1386 CF_VERBOSE(repairing $1: [$]$1)
1388 CF_VERBOSE(... fixed [$]$1)
1389 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1394 AC_SUBST(EXTRA_CFLAGS)
1396 dnl ---------------------------------------------------------------------------
1397 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1398 dnl -----------------
1399 dnl Test for availability of useful gcc __attribute__ directives to quiet
1400 dnl compiler warnings. Though useful, not all are supported -- and contrary
1401 dnl to documentation, unrecognized directives cause older compilers to barf.
1402 AC_DEFUN([CF_GCC_ATTRIBUTES],
1403 [AC_REQUIRE([AC_PROG_FGREP])dnl
1404 AC_REQUIRE([CF_C11_NORETURN])dnl
1406 if test "$GCC" = yes || test "$GXX" = yes
1408 cat > conftest.i <<EOF
1410 #define GCC_PRINTF 0
1415 #ifndef GCC_NORETURN
1416 #define GCC_NORETURN /* nothing */
1419 #define GCC_UNUSED /* nothing */
1422 if test "$GCC" = yes
1424 AC_CHECKING([for $CC __attribute__ directives])
1425 cat > "conftest.$ac_ext" <<EOF
1426 #line __oline__ "${as_me:-configure}"
1428 #include "confdefs.h"
1429 #include "conftest.h"
1430 #include "conftest.i"
1432 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1434 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1437 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1439 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1441 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1442 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1443 extern GCC_NORETURN void foo(void);
1444 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1446 cf_printf_attribute=no
1447 cf_scanf_attribute=no
1448 for cf_attribute in scanf printf unused noreturn
1450 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1451 cf_directive="__attribute__(($cf_attribute))"
1452 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1454 case "$cf_attribute" in
1456 cf_printf_attribute=yes
1457 cat >conftest.h <<EOF
1458 #define GCC_$cf_ATTRIBUTE 1
1462 cf_scanf_attribute=yes
1463 cat >conftest.h <<EOF
1464 #define GCC_$cf_ATTRIBUTE 1
1468 cat >conftest.h <<EOF
1469 #define GCC_$cf_ATTRIBUTE $cf_directive
1474 if AC_TRY_EVAL(ac_compile); then
1475 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1476 cat conftest.h >>confdefs.h
1477 case "$cf_attribute" in
1479 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1482 cf_value='/* nothing */'
1483 if test "$cf_printf_attribute" != no ; then
1484 cf_value='__attribute__((format(printf,fmt,var)))'
1485 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1487 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1490 cf_value='/* nothing */'
1491 if test "$cf_scanf_attribute" != no ; then
1492 cf_value='__attribute__((format(scanf,fmt,var)))'
1493 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1495 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1498 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1504 ${FGREP-fgrep} define conftest.i >>confdefs.h
1509 dnl ---------------------------------------------------------------------------
1510 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1512 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1513 dnl compatible), attempt to determine if icc/clang is actually used.
1514 AC_DEFUN([CF_GCC_VERSION],[
1515 AC_REQUIRE([AC_PROG_CC])
1517 if test "$GCC" = yes ; then
1518 AC_MSG_CHECKING(version of $CC)
1519 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1520 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1521 AC_MSG_RESULT($GCC_VERSION)
1523 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1524 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1526 dnl ---------------------------------------------------------------------------
1527 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1529 dnl Check if the compiler supports useful warning options. There's a few that
1530 dnl we don't use, simply because they're too noisy:
1532 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1533 dnl -Winline (usually not worthwhile)
1534 dnl -Wredundant-decls (system headers make this too noisy)
1535 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1536 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1537 dnl is enabled for ncurses using "--enable-const".
1541 dnl $1 is an optional list of gcc warning flags that a particular
1542 dnl application might want to use, e.g., "no-unused" for
1545 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1547 AC_DEFUN([CF_GCC_WARNINGS],
1549 AC_REQUIRE([CF_GCC_VERSION])
1550 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1551 cat > "conftest.$ac_ext" <<EOF
1552 #line __oline__ "${as_me:-configure}"
1553 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1555 if test "$INTEL_COMPILER" = yes
1557 # The "-wdXXX" options suppress warnings:
1558 # remark #1419: external declaration in primary source file
1559 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1560 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1561 # remark #193: zero used for undefined preprocessing identifier
1562 # remark #593: variable "curs_sb_left_arrow" was set but never used
1563 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1564 # remark #869: parameter "tw" was never referenced
1565 # remark #981: operands are evaluated in unspecified order
1566 # warning #279: controlling expression is constant
1568 AC_CHECKING([for $CC warning options])
1569 cf_save_CFLAGS="$CFLAGS"
1570 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1582 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1583 if AC_TRY_EVAL(ac_compile); then
1584 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1585 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1588 CFLAGS="$cf_save_CFLAGS"
1589 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1591 AC_CHECKING([for $CC warning options])
1592 cf_save_CFLAGS="$CFLAGS"
1594 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1595 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1596 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1597 for cf_opt in W Wall \
1598 Wbad-function-cast \
1601 Wdeclaration-after-statement \
1604 Wmissing-declarations \
1605 Wmissing-prototypes \
1609 Wstrict-prototypes \
1610 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1612 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1613 if AC_TRY_EVAL(ac_compile); then
1614 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1617 case "$GCC_VERSION" in
1619 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1624 case "$GCC_VERSION" in
1626 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1631 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1634 CFLAGS="$cf_save_CFLAGS"
1638 AC_SUBST(EXTRA_CFLAGS)
1640 dnl ---------------------------------------------------------------------------
1641 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1642 dnl -----------------
1643 AC_DEFUN([CF_GNATPREP_OPT_T],[
1644 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1645 cf_cv_gnatprep_opt_t=no
1646 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1648 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1649 AC_SUBST(GNATPREP_OPTS)
1651 dnl ---------------------------------------------------------------------------
1652 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1653 dnl ----------------
1654 AC_DEFUN([CF_GNAT_GENERICS],
1656 AC_REQUIRE([CF_GNAT_VERSION])
1658 AC_MSG_CHECKING(if GNAT supports generics)
1659 case "$cf_cv_gnat_version" in
1660 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1661 cf_gnat_generics=yes
1667 AC_MSG_RESULT($cf_gnat_generics)
1669 if test "$cf_gnat_generics" = yes
1671 cf_compile_generics=generics
1672 cf_generic_objects="\${GENOBJS}"
1674 cf_compile_generics=
1678 AC_SUBST(cf_compile_generics)
1679 AC_SUBST(cf_generic_objects)
1681 dnl ---------------------------------------------------------------------------
1682 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1683 dnl ----------------
1684 dnl GNAT projects are configured with ".gpr" project files.
1685 dnl GNAT libraries are a further development, using the project feature.
1686 AC_DEFUN([CF_GNAT_PROJECTS],
1688 AC_REQUIRE([CF_GNAT_VERSION])
1689 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1691 cf_gnat_libraries=no
1694 if test "$enable_gnat_projects" != no ; then
1695 AC_MSG_CHECKING(if GNAT supports project files)
1696 case "$cf_cv_gnat_version" in
1700 case "$cf_cv_system_name" in
1704 rm -rf ./conftest* ./*~conftest*
1705 if mkdir conftest.src conftest.bin conftest.lib
1708 rm -rf ./conftest* ./*~conftest*
1709 cat >>library.gpr <<CF_EOF
1711 Kind := External ("LIB_KIND");
1712 for Library_Name use "ConfTest";
1713 for Object_Dir use ".";
1714 for Library_ALI_Dir use External("LIBRARY_DIR");
1715 for Library_Version use External ("SONAME");
1716 for Library_Kind use Kind;
1717 for Library_Dir use External("BUILD_DIR");
1718 Source_Dir := External ("SOURCE_DIR");
1719 for Source_Dirs use (Source_Dir);
1722 cat >>confpackage.ads <<CF_EOF
1723 package ConfPackage is
1727 cat >>confpackage.adb <<CF_EOF
1729 package body ConfPackage is
1730 procedure conftest is
1732 Text_IO.Put ("Hello World");
1737 if ( "$cf_ada_make" $ADAFLAGS \
1739 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1740 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1741 -XSOURCE_DIR="`pwd`" \
1742 -XSONAME=libConfTest.so.1 \
1743 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1744 cf_gnat_projects=yes
1748 if test -f conftest.lib/confpackage.ali
1750 cf_gnat_libraries=yes
1752 rm -rf ./conftest* ./*~conftest*
1757 AC_MSG_RESULT($cf_gnat_projects)
1758 fi # enable_gnat_projects
1760 if test "$cf_gnat_projects" = yes
1762 AC_MSG_CHECKING(if GNAT supports libraries)
1763 AC_MSG_RESULT($cf_gnat_libraries)
1766 USE_OLD_MAKERULES=""
1767 USE_GNAT_PROJECTS="#"
1768 USE_GNAT_MAKE_GPR="#"
1769 USE_GNAT_GPRBUILD="#"
1771 if test "$cf_gnat_projects" = yes
1773 USE_OLD_MAKERULES="#"
1774 USE_GNAT_PROJECTS=""
1775 if test "$cf_cv_VERSION_GPRBUILD" != no
1777 USE_GNAT_GPRBUILD=""
1778 elif test "$cf_cv_VERSION_GNATMAKE" != no
1780 USE_GNAT_MAKE_GPR=""
1782 AC_MSG_WARN(use old makefile rules since tools are missing)
1786 if test "$cf_gnat_libraries" = yes
1788 USE_GNAT_LIBRARIES=""
1790 USE_GNAT_LIBRARIES="#"
1793 AC_SUBST(USE_OLD_MAKERULES)
1794 AC_SUBST(USE_GNAT_PROJECTS)
1795 AC_SUBST(USE_GNAT_LIBRARIES)
1796 AC_SUBST(USE_GNAT_MAKE_GPR)
1797 AC_SUBST(USE_GNAT_GPRBUILD)
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1802 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1803 dnl is noted that gnat may compile a tasking unit even for configurations which
1804 dnl fail at runtime.
1805 AC_DEFUN([CF_GNAT_SIGINT],[
1806 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1807 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1811 pragma Warnings (Off); -- the next pragma exists since 3.11p
1812 pragma Unreserve_All_Interrupts;
1813 pragma Warnings (On);
1815 protected Process is
1817 function Continue return Boolean;
1818 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1820 Done : Boolean := False;
1824 [package body ConfTest is
1825 protected body Process is
1830 function Continue return Boolean is
1836 [cf_cv_gnat_sigint=yes],
1837 [cf_cv_gnat_sigint=no])])
1839 if test "$cf_cv_gnat_sigint" = yes ; then
1844 AC_SUBST(USE_GNAT_SIGINT)
1846 dnl ---------------------------------------------------------------------------
1847 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1848 dnl ----------------
1849 dnl Verify that a test program compiles/links with GNAT.
1850 dnl $cf_ada_make is set to the program that compiles/links
1851 dnl $ADAFLAGS may be set to the GNAT flags.
1853 dnl $1 is the text of the spec
1854 dnl $2 is the text of the body
1855 dnl $3 is the shell command to execute if successful
1856 dnl $4 is the shell command to execute if not successful
1857 AC_DEFUN([CF_GNAT_TRY_LINK],
1859 rm -rf ./conftest* ./*~conftest*
1860 cat >>conftest.ads <<CF_EOF
1863 cat >>conftest.adb <<CF_EOF
1866 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1867 ifelse($3,, :,[ $3])
1871 rm -rf ./conftest* ./*~conftest*
1873 dnl ---------------------------------------------------------------------------
1874 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1876 dnl Verify that a test program compiles and runs with GNAT
1877 dnl $cf_ada_make is set to the program that compiles/links
1878 dnl $ADAFLAGS may be set to the GNAT flags.
1880 dnl $1 is the text of the spec
1881 dnl $2 is the text of the body
1882 dnl $3 is the shell command to execute if successful
1883 dnl $4 is the shell command to execute if not successful
1884 AC_DEFUN([CF_GNAT_TRY_RUN],
1886 rm -rf ./conftest* ./*~conftest*
1887 cat >>conftest.ads <<CF_EOF
1890 cat >>conftest.adb <<CF_EOF
1893 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1894 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1895 ifelse($3,, :,[ $3])
1902 rm -rf ./conftest* ./*~conftest*
1904 dnl ---------------------------------------------------------------------------
1905 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1907 dnl $1 = cache variable to update
1908 dnl $2 = program name
1909 dnl Verify version of GNAT or related tool
1910 AC_DEFUN([CF_GNAT_VERSION],
1912 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1913 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1914 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1915 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1917 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1918 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1920 dnl ---------------------------------------------------------------------------
1921 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1923 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1924 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1925 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1926 dnl since it is interwoven with GNU extensions.
1928 dnl Well, yes we could work around it...
1931 dnl $1 is the nominal value for _XOPEN_SOURCE
1932 AC_DEFUN([CF_GNU_SOURCE],
1934 cf_gnu_xopen_source=ifelse($1,,500,$1)
1936 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1937 AC_TRY_COMPILE([#include <sys/types.h>],[
1938 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1940 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1943 # error not GNU C library
1945 [cf_cv_gnu_library=yes],
1946 [cf_cv_gnu_library=no])
1949 if test x$cf_cv_gnu_library = xyes; then
1951 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1952 # was changed to help a little. newlib incorporated the change about 4
1954 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1956 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1957 AC_TRY_COMPILE([#include <sys/types.h>],[
1958 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1960 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1963 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1965 [cf_cv_gnu_library_219=yes],
1966 [cf_cv_gnu_library_219=no])
1970 if test "x$cf_cv_gnu_library_219" = xyes; then
1972 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1973 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1976 #include <sys/types.h>
1978 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1981 # error GNU C library is too old
1983 [cf_cv_gnu_dftsrc_219=yes],
1984 [cf_cv_gnu_dftsrc_219=no])
1986 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1988 cf_cv_gnu_dftsrc_219=maybe
1991 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1993 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1994 AC_TRY_COMPILE([#include <sys/types.h>],[
1995 #ifndef _XOPEN_SOURCE
1996 #error expected _XOPEN_SOURCE to be defined
1998 [cf_cv_gnu_source=no],
1999 [cf_save="$CPPFLAGS"
2000 CF_ADD_CFLAGS(-D_GNU_SOURCE)
2001 AC_TRY_COMPILE([#include <sys/types.h>],[
2002 #ifdef _XOPEN_SOURCE
2003 #error expected _XOPEN_SOURCE to be undefined
2005 [cf_cv_gnu_source=no],
2006 [cf_cv_gnu_source=yes])
2011 if test "$cf_cv_gnu_source" = yes
2013 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2014 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2015 AC_TRY_COMPILE([#include <sys/types.h>],[
2016 #ifdef _DEFAULT_SOURCE
2017 #error expected _DEFAULT_SOURCE to be undefined
2019 [cf_cv_default_source=no],
2020 [cf_cv_default_source=yes])
2022 if test "$cf_cv_default_source" = yes
2024 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2031 dnl ---------------------------------------------------------------------------
2032 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2034 dnl Construct a search-list of directories for a nonstandard header-file
2037 dnl $1 = the variable to return as result
2038 dnl $2 = the package name
2039 AC_DEFUN([CF_HEADER_PATH],
2043 # collect the current set of include-directories from compiler flags
2044 cf_header_path_list=""
2045 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2046 for cf_header_path in $CPPFLAGS $CFLAGS
2048 case "$cf_header_path" in
2050 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2051 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2052 cf_header_path_list="$cf_header_path_list [$]$1"
2058 # add the variations for the package we are looking for
2059 CF_SUBDIR_PATH($1,$2,include)
2061 test "$includedir" != NONE && \
2062 test "$includedir" != "/usr/include" && \
2063 test -d "$includedir" && {
2064 test -d "$includedir" && $1="[$]$1 $includedir"
2065 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2068 test "$oldincludedir" != NONE && \
2069 test "$oldincludedir" != "/usr/include" && \
2070 test -d "$oldincludedir" && {
2071 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2072 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2075 $1="[$]$1 $cf_header_path_list"
2077 dnl ---------------------------------------------------------------------------
2078 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2080 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2081 AC_DEFUN([CF_HELP_MESSAGE],
2082 [CF_ACVERSION_CHECK(2.53,[],[
2083 AC_DIVERT_HELP($1)])dnl
2085 dnl ---------------------------------------------------------------------------
2086 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2088 dnl Construct the list of include-options according to whether we're building
2089 dnl in the source directory or using '--srcdir=DIR' option.
2090 AC_DEFUN([CF_INCLUDE_DIRS],
2092 if test "$srcdir" != "."; then
2093 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2095 CPPFLAGS="-I../include $CPPFLAGS"
2096 if test "$srcdir" != "."; then
2097 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2099 CPPFLAGS="-I. $CPPFLAGS"
2102 dnl ---------------------------------------------------------------------------
2103 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2105 dnl prompt for/fill-in useful install-program options
2106 AC_DEFUN([CF_INSTALL_OPTS],
2112 dnl ---------------------------------------------------------------------------
2113 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2114 dnl ----------------
2115 dnl Almost all "install" programs default to the current user's ownership.
2116 dnl Almost - MINIX is an exception.
2117 AC_DEFUN([CF_INSTALL_OPT_O],
2119 AC_MSG_CHECKING(if install needs to be told about ownership)
2120 case `$ac_config_guess` in
2129 AC_MSG_RESULT($with_install_o)
2130 if test "x$with_install_o" = xyes
2132 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'`"
2137 AC_SUBST(INSTALL_OPT_O)
2139 dnl ---------------------------------------------------------------------------
2140 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2141 dnl ----------------
2142 dnl Some install-programs accept a "-p" option to preserve file modification
2143 dnl timestamps. That can be useful as an install option, as well as a way to
2144 dnl avoid the need for ranlib after copying a static archive.
2145 AC_DEFUN([CF_INSTALL_OPT_P],
2147 : "${INSTALL:=install}"
2148 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2153 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2155 if test -f conftest.out/conftest.in
2157 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2158 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2159 if test -s conftest.err
2174 dnl ---------------------------------------------------------------------------
2175 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2176 dnl ----------------
2177 dnl By default, we should strip executables which are installed, but leave the
2178 dnl ability to suppress that for unit-testing.
2179 AC_DEFUN([CF_INSTALL_OPT_S],
2181 AC_MSG_CHECKING(if you want to install stripped executables)
2182 CF_ARG_DISABLE(stripping,
2183 [ --disable-stripping do not strip (debug info) installed executables],
2184 [enable_stripping=no],
2185 [enable_stripping=yes])
2186 AC_MSG_RESULT($enable_stripping)
2188 if test "$enable_stripping" = yes
2194 AC_SUBST(INSTALL_OPT_S)
2196 dnl ---------------------------------------------------------------------------
2197 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2198 dnl -----------------
2199 dnl Check if the given compiler is really the Intel compiler for Linux. It
2200 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2201 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2203 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2204 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2205 dnl the wrappers for gcc and g++ warnings.
2207 dnl $1 = GCC (default) or GXX
2208 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2209 dnl $3 = CFLAGS (default) or CXXFLAGS
2210 AC_DEFUN([CF_INTEL_COMPILER],[
2211 AC_REQUIRE([AC_CANONICAL_HOST])
2212 ifelse([$2],,INTEL_COMPILER,[$2])=no
2214 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2217 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2218 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2219 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2221 #ifdef __INTEL_COMPILER
2225 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2226 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2228 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2229 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2237 dnl Add checks for large file support.
2238 AC_DEFUN([CF_LARGEFILE],[
2239 ifdef([AC_FUNC_FSEEKO],[
2241 if test "$enable_largefile" != no ; then
2244 # Normally we would collect these definitions in the config.h,
2245 # but (like _XOPEN_SOURCE), some environments rely on having these
2246 # defined before any of the system headers are included. Another
2247 # case comes up with C++, e.g., on AIX the compiler compiles the
2248 # header files by themselves before looking at the body files it is
2249 # told to compile. For ncurses, those header files do not include
2251 if test "$ac_cv_sys_large_files" != no
2253 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2255 if test "$ac_cv_sys_largefile_source" != no
2257 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2259 if test "$ac_cv_sys_file_offset_bits" != no
2261 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2264 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2266 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2267 #include <sys/types.h>
2270 /* if transitional largefile support is setup, this is true */
2271 extern struct dirent64 * readdir(DIR *);
2272 struct dirent64 *x = readdir((DIR *)0);
2273 struct dirent *y = readdir((DIR *)0);
2277 [cf_cv_struct_dirent64=yes],
2278 [cf_cv_struct_dirent64=no])
2280 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2284 dnl ---------------------------------------------------------------------------
2285 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2287 dnl For the given system and compiler, find the compiler flags to pass to the
2288 dnl loader to use the "rpath" feature.
2289 AC_DEFUN([CF_LD_RPATH_OPT],
2291 AC_REQUIRE([CF_CHECK_CACHE])
2294 if test "x$cf_cv_enable_rpath" != xno
2296 AC_MSG_CHECKING(for an rpath option)
2297 case "$cf_cv_system_name" in
2299 if test "$GCC" = yes; then
2300 LD_RPATH_OPT="-Wl,-rpath,"
2302 LD_RPATH_OPT="-rpath "
2305 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2306 LD_RPATH_OPT="-Wl,-rpath,"
2308 (openbsd[[2-9]].*|mirbsd*)
2309 LD_RPATH_OPT="-Wl,-rpath,"
2312 LD_RPATH_OPT="-rpath "
2315 LD_RPATH_OPT="-Wl,-rpath,"
2318 LD_RPATH_OPT="-rpath "
2326 AC_MSG_RESULT($LD_RPATH_OPT)
2328 case "x$LD_RPATH_OPT" in
2330 AC_MSG_CHECKING(if we need a space after rpath option)
2331 cf_save_LIBS="$LIBS"
2332 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2333 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2334 LIBS="$cf_save_LIBS"
2335 AC_MSG_RESULT($cf_rpath_space)
2336 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2341 dnl ---------------------------------------------------------------------------
2342 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2344 dnl Construct a search-list of directories for a nonstandard library-file
2347 dnl $1 = the variable to return as result
2348 dnl $2 = the package name
2349 AC_DEFUN([CF_LIBRARY_PATH],
2352 cf_library_path_list=""
2353 if test -n "${LDFLAGS}${LIBS}" ; then
2354 for cf_library_path in $LDFLAGS $LIBS
2356 case "$cf_library_path" in
2358 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2359 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2360 cf_library_path_list="$cf_library_path_list [$]$1"
2366 CF_SUBDIR_PATH($1,$2,lib)
2368 $1="$cf_library_path_list [$]$1"
2370 dnl ---------------------------------------------------------------------------
2371 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2373 dnl Compute the library-prefix for the given host system
2374 dnl $1 = variable to set
2375 define([CF_LIB_PREFIX],
2377 case "$cf_cv_system_name" in
2379 if test "$DFT_LWR_MODEL" = libtool; then
2388 (*) LIB_PREFIX='lib'
2391 ifelse($1,,,[$1=$LIB_PREFIX])
2392 AC_SUBST(LIB_PREFIX)
2394 dnl ---------------------------------------------------------------------------
2395 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2397 dnl Compute the library file-suffix from the given model name
2399 dnl $2 = variable to set (the nominal library suffix)
2400 dnl $3 = dependency variable to set (actual filename)
2401 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2402 AC_DEFUN([CF_LIB_SUFFIX],
2410 case "$cf_cv_system_name" in
2421 case "$cf_cv_system_name" in
2432 case "$cf_cv_system_name" in
2441 (cygwin*|msys*|mingw*)
2479 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2481 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2482 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2485 dnl ---------------------------------------------------------------------------
2486 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2488 dnl Compute the string to append to -library from the given model name
2490 dnl $2 = variable to set
2491 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2492 AC_DEFUN([CF_LIB_TYPE],
2498 (profile) $2='_p' ;;
2501 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2503 dnl ---------------------------------------------------------------------------
2504 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2505 dnl ----------------
2506 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2507 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2508 dnl have to provide wrappers for global tables to ensure they're linked
2510 AC_DEFUN([CF_LINK_DATAONLY],
2512 AC_MSG_CHECKING([if data-only library module links])
2513 AC_CACHE_VAL(cf_cv_link_dataonly,[
2515 cat >conftest.$ac_ext <<EOF
2516 #line __oline__ "configure"
2517 int testdata[[3]] = { 123, 456, 789 };
2519 if AC_TRY_EVAL(ac_compile) ; then
2520 mv conftest.o data.o && \
2521 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2523 rm -f conftest.$ac_ext data.o
2524 cat >conftest.$ac_ext <<EOF
2525 #line __oline__ "configure"
2529 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2531 extern int testdata[[3]];
2532 return testdata[[0]] == 123
2533 && testdata[[1]] == 456
2534 && testdata[[2]] == 789;
2538 if AC_TRY_EVAL(ac_compile); then
2539 mv conftest.o func.o && \
2540 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2542 rm -f conftest.$ac_ext func.o
2543 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2545 LIBS="conftest.a $LIBS"
2549 extern int testfunc();
2550 ${cf_cv_main_return:-return} (!testfunc());
2553 [cf_cv_link_dataonly=yes],
2554 [cf_cv_link_dataonly=no],
2555 [cf_cv_link_dataonly=unknown])
2558 AC_MSG_RESULT($cf_cv_link_dataonly)
2560 if test "$cf_cv_link_dataonly" = no ; then
2561 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2564 AC_SUBST(BROKEN_LINKER)
2567 dnl ---------------------------------------------------------------------------
2568 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2570 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2571 dnl options to lower-levels. It is very useful for "make -n" -- if we have it.
2572 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2573 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2574 AC_DEFUN([CF_MAKEFLAGS],
2575 [AC_REQUIRE([AC_PROG_FGREP])dnl
2577 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2579 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2581 cat >cf_makeflags.tmp <<CF_EOF
2584 @ echo '.$cf_option'
2586 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2587 case "$cf_result" in
2589 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2590 case "$cf_result" in
2591 (.*CC=*) cf_cv_makeflags=
2593 (*) cf_cv_makeflags=$cf_option
2601 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2605 rm -f cf_makeflags.tmp
2608 AC_SUBST(cf_cv_makeflags)
2610 dnl ---------------------------------------------------------------------------
2611 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2613 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2614 dnl acts as a placeholder.
2616 dnl The ".PHONY" feature was proposed in 2011 here
2617 dnl https://www.austingroupbugs.net/view.php?id=523
2618 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2620 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2621 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2623 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2624 dnl date unspecified).
2626 dnl + It was adopted in NetBSD make in June 1995.
2628 dnl + The other BSD make programs are derived from the NetBSD make (and for
2629 dnl that reason are not actually different "implementations").
2631 dnl + Some features of NetBSD make were actually adapted from pmake, which
2632 dnl began as a modified GNU make starting in 1993.
2634 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2635 dnl GNU make extension, but is less well known than the BSD make.
2636 AC_DEFUN([CF_MAKE_PHONY],[
2637 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2640 mkdir conftest || exit 1
2642 cat >makefile <<'CF_EOF'
2646 @echo "** making [$]@ [$](DATA)"
2648 @echo "** making [$]@ [$](DATA)"
2650 @echo "** making [$]@ [$](DATA)"
2651 echo [$](DATA) > [$]@
2653 @echo "** making [$]@ [$](DATA)"
2654 echo [$](DATA) > [$]@
2656 for cf_data in 1 2 3
2658 ${MAKE:-make} always DATA=$cf_data
2659 ${MAKE:-make} once DATA=$cf_data
2660 ${MAKE:-make} -t always once
2661 if test -f always ; then
2662 echo "no (case 1)" > ../conftest.tmp
2663 elif test ! -f always.out ; then
2664 echo "no (case 2)" > ../conftest.tmp
2665 elif test ! -f once.out ; then
2666 echo "no (case 3)" > ../conftest.tmp
2667 elif ! cmp -s always.out once.out ; then
2668 echo "no (case 4)" > ../conftest.tmp
2669 diff always.out once.out
2671 cf_check="`cat always.out`"
2672 if test "x$cf_check" != "x$cf_data" ; then
2673 echo "no (case 5)" > ../conftest.tmp
2675 echo yes > ../conftest.tmp
2683 cf_cv_make_PHONY="`cat conftest.tmp`"
2688 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2689 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2690 AC_SUBST(MAKE_NO_PHONY)
2691 AC_SUBST(MAKE_PHONY)
2693 dnl ---------------------------------------------------------------------------
2694 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2696 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2697 dnl a monocase filesystem.
2698 AC_DEFUN([CF_MAKE_TAGS],[
2699 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2701 AC_CHECK_PROGS(CTAGS, exctags ctags)
2702 AC_CHECK_PROGS(ETAGS, exetags etags)
2704 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2706 if test "$cf_cv_mixedcase" = yes ; then
2707 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2712 if test "$MAKE_UPPER_TAGS" = yes ; then
2718 if test "$MAKE_LOWER_TAGS" = yes ; then
2727 AC_SUBST(MAKE_UPPER_TAGS)
2728 AC_SUBST(MAKE_LOWER_TAGS)
2730 dnl ---------------------------------------------------------------------------
2731 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2732 dnl ----------------------
2733 dnl Check if the file-system supports mixed-case filenames. If we're able to
2734 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2735 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2737 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2738 if test "$cross_compiling" = yes ; then
2739 case "$target_alias" in
2740 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2748 rm -f conftest CONFTEST
2750 if test -f CONFTEST ; then
2755 rm -f conftest CONFTEST
2758 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2760 dnl ---------------------------------------------------------------------------
2761 dnl CF_MKSTEMP version: 12 updated: 2023/01/05 17:53:11
2763 dnl Check for a working mkstemp. This creates two files, checks that they are
2764 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2765 AC_DEFUN([CF_MKSTEMP],[
2769 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2772 $ac_includes_default
2776 char *tmpl = "conftestXXXXXX";
2784 for (n = 0; n < 2; ++n) {
2785 strcpy(name[n], tmpl);
2786 if ((fd = mkstemp(name[n])) >= 0) {
2787 if (!strcmp(name[n], tmpl)
2788 || stat(name[n], &sb) != 0
2789 || (sb.st_mode & S_IFMT) != S_IFREG
2790 || (sb.st_mode & 077) != 0) {
2797 && !strcmp(name[0], name[1]))
2799 ${cf_cv_main_return:-return}(result);
2801 ],[cf_cv_func_mkstemp=yes
2802 ],[cf_cv_func_mkstemp=no
2803 ],[cf_cv_func_mkstemp=maybe])
2805 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2806 AC_CHECK_FUNC(mkstemp)
2808 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2809 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2812 dnl ---------------------------------------------------------------------------
2813 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2815 dnl Write a debug message to config.log, along with the line number in the
2816 dnl configure script.
2817 AC_DEFUN([CF_MSG_LOG],[
2818 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2820 dnl ---------------------------------------------------------------------------
2821 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2822 dnl ----------------
2823 dnl Configure an ncurses add-on, built outside the ncurses tree.
2824 AC_DEFUN([CF_NCURSES_ADDON],[
2825 AC_REQUIRE([CF_NCURSES_CONFIG])
2827 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2829 AC_MSG_CHECKING(if you want wide-character code)
2830 AC_ARG_ENABLE(widec,
2831 [ --enable-widec compile with wide-char/UTF-8 code],
2832 [with_widec=$enableval],
2834 AC_MSG_RESULT($with_widec)
2835 if test "$with_widec" = yes ; then
2837 CF_NCURSES_CONFIG(ncursesw)
2839 CF_NCURSES_CONFIG(ncurses)
2842 if test "$NCURSES_CONFIG_PKG" != none ; then
2843 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2845 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2846 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2847 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2849 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2850 if test -z "$cf_cv_abi_version"
2852 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2855 elif test "$NCURSES_CONFIG" != none ; then
2857 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2859 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2860 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2861 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2863 # ABI version is not available from headers
2864 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2868 for cf_name in MAJOR MINOR PATCH
2870 cat >conftest.$ac_ext <<CF_EOF
2871 #include <${cf_cv_ncurses_header:-curses.h}>
2872 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2874 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2876 if test -f conftest.out ; then
2877 cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
2878 eval NCURSES_$cf_name=\"$cf_result\"
2879 # cat conftest.$ac_ext
2884 cf_cv_abi_version=${NCURSES_MAJOR}
2888 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2890 dnl Show the computed version, for logging
2891 cf_cv_timestamp=`date`
2893 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2895 dnl We need these values in the generated headers
2896 AC_SUBST(NCURSES_MAJOR)
2897 AC_SUBST(NCURSES_MINOR)
2898 AC_SUBST(NCURSES_PATCH)
2900 dnl We need these values in the generated makefiles
2901 AC_SUBST(cf_cv_rel_version)
2902 AC_SUBST(cf_cv_abi_version)
2904 dnl FIXME - not needed for Ada95
2905 AC_SUBST(cf_cv_builtin_bool)
2906 AC_SUBST(cf_cv_header_stdbool_h)
2907 AC_SUBST(cf_cv_type_of_bool)dnl
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2912 dnl -------------------
2913 dnl Check if we can compile with ncurses' header file
2914 dnl $1 is the cache variable to set
2915 dnl $2 is the header-file to include
2916 dnl $3 is the root name (ncurses or ncursesw)
2917 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2919 ]ifelse($3,ncursesw,[
2920 #define _XOPEN_SOURCE_EXTENDED
2921 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2922 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2925 #ifdef NCURSES_VERSION
2926 ]ifelse($3,ncursesw,[
2931 printf("%s\\n", NCURSES_VERSION);
2943 dnl ---------------------------------------------------------------------------
2944 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2945 dnl -----------------
2946 dnl Tie together the configure-script macros for ncurses, preferring these in
2948 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2949 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2950 dnl c) just plain libraries
2952 dnl $1 is the root library name (default: "ncurses")
2953 AC_DEFUN([CF_NCURSES_CONFIG],[
2954 AC_REQUIRE([CF_PKG_CONFIG])
2955 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2956 cf_have_ncuconfig=no
2958 if test "x${PKG_CONFIG:=none}" != xnone; then
2959 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2960 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2963 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2964 cf_have_ncuconfig=unknown
2966 cf_save_CFLAGS="$CFLAGS"
2967 cf_save_CPPFLAGS="$CPPFLAGS"
2968 cf_save_LIBS="$LIBS"
2970 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2971 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2973 # while -W for passing linker flags is prevalent, it is not "standard".
2974 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2975 # incompatible _and_ non-standard -W option which gives an error. Work
2976 # around that pitfall.
2977 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2979 CF_ADD_CFLAGS($cf_pkg_cflags)
2980 CF_ADD_LIBS($cf_pkg_libs)
2982 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2983 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2984 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2986 { const char *xx = curses_version(); return (xx == 0); }],
2987 [cf_test_ncuconfig=yes],
2988 [cf_test_ncuconfig=no],
2989 [cf_test_ncuconfig=maybe])],
2990 [cf_test_ncuconfig=no])
2992 CFLAGS="$cf_save_CFLAGS"
2993 CPPFLAGS="$cf_save_CPPFLAGS"
2994 LIBS="$cf_save_LIBS"
2996 if test "x$cf_test_ncuconfig" != xyes; then
2997 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2998 cf_pkg_cflags="$cf_temp"
2999 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
3000 cf_pkg_libs="$cf_temp"
3005 CF_APPEND_CFLAGS($cf_pkg_cflags)
3006 CF_ADD_LIBS($cf_pkg_libs)
3008 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3009 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3010 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
3012 { const char *xx = curses_version(); return (xx == 0); }],
3013 [cf_have_ncuconfig=yes],
3014 [cf_have_ncuconfig=no],
3015 [cf_have_ncuconfig=maybe])],
3016 [cf_have_ncuconfig=no])
3017 AC_MSG_RESULT($cf_have_ncuconfig)
3018 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
3019 if test "$cf_have_ncuconfig" != "yes"
3021 CPPFLAGS="$cf_save_CPPFLAGS"
3022 LIBS="$cf_save_LIBS"
3023 NCURSES_CONFIG_PKG=none
3025 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3026 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
3032 NCURSES_CONFIG_PKG=none
3035 NCURSES_CONFIG_PKG=none
3038 if test "x$cf_have_ncuconfig" = "xno"; then
3039 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
3041 CF_ACVERSION_CHECK(2.52,
3042 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
3043 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
3045 if test "$NCURSES_CONFIG" != none ; then
3047 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
3048 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
3050 # even with config script, some packages use no-override for curses.h
3051 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
3053 dnl like CF_NCURSES_CPPFLAGS
3054 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3056 dnl like CF_NCURSES_LIBS
3057 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
3058 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3060 dnl like CF_NCURSES_VERSION
3061 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3065 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3066 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3073 dnl ---------------------------------------------------------------------------
3074 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3075 dnl -------------------
3076 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3077 dnl the CPPFLAGS variable so we can include its header.
3079 dnl The header files may be installed as either curses.h, or ncurses.h (would
3080 dnl be obsolete, except that some packagers prefer this name to distinguish it
3081 dnl from a "native" curses implementation). If not installed for overwrite,
3082 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3083 dnl /usr/include/ncurses), but someone may have installed overwriting the
3084 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
3085 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3088 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3089 dnl is already in the include-path, don't even bother with this, since we cannot
3090 dnl easily determine which file it is. In this case, it has to be <curses.h>.
3092 dnl The optional parameter gives the root name of the library, in case it is
3093 dnl not installed as the default curses library. That is how the
3094 dnl wide-character version of ncurses is installed.
3095 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3096 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3098 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3099 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3101 test -n "$cf_cv_curses_dir" && \
3102 test "$cf_cv_curses_dir" != "no" && { \
3103 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3106 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3107 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3108 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3109 for cf_header in $cf_header_list
3111 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3112 test "$cf_cv_ncurses_h" != no && break
3119 # some applications need this, but should check for NCURSES_VERSION
3120 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3124 dnl ---------------------------------------------------------------------------
3125 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3126 dnl -----------------
3127 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3128 dnl variations of ncurses' installs.
3130 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3131 AC_DEFUN([CF_NCURSES_HEADER],[
3133 if test "$cf_cv_ncurses_h" != no ; then
3134 cf_cv_ncurses_header=$cf_cv_ncurses_h
3137 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3138 test -n "$verbose" && echo
3139 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3140 test -n "$verbose" && echo "search path $cf_search"
3141 cf_save2_CPPFLAGS="$CPPFLAGS"
3142 for cf_incdir in $cf_search
3144 CF_ADD_INCDIR($cf_incdir)
3149 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3150 if test "$cf_cv_ncurses_h2" != no ; then
3151 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3152 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
3155 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3157 CPPFLAGS="$cf_save2_CPPFLAGS"
3158 test "$cf_cv_ncurses_h2" != no && break
3160 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3163 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3164 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3165 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3166 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3168 CF_ADD_INCDIR($cf_1st_incdir)
3172 # Set definitions to allow ifdef'ing for ncurses.h
3174 case "$cf_cv_ncurses_header" in
3176 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3180 case "$cf_cv_ncurses_header" in
3181 (ncurses/curses.h|ncurses/ncurses.h)
3182 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3184 (ncursesw/curses.h|ncursesw/ncurses.h)
3185 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3190 dnl ---------------------------------------------------------------------------
3191 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3193 dnl Look for the ncurses library. This is a little complicated on Linux,
3194 dnl because it may be linked with the gpm (general purpose mouse) library.
3195 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3196 dnl unusable with ncurses. However, we don't want to link with gpm unless
3197 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3198 dnl and the linker will record a dependency.
3200 dnl The optional parameter gives the root name of the library, in case it is
3201 dnl not installed as the default curses library. That is how the
3202 dnl wide-character version of ncurses is installed.
3203 AC_DEFUN([CF_NCURSES_LIBS],
3204 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3206 cf_nculib_root=ifelse($1,,ncurses,$1)
3207 # This works, except for the special case where we find gpm, but
3208 # ncurses is in a nonstandard location via $LIBS, and we really want
3211 cf_ncurses_SAVE="$LIBS"
3212 AC_CHECK_LIB(gpm,Gpm_Open,
3213 [AC_CHECK_LIB(gpm,initscr,
3214 [LIBS="$cf_ncurses_SAVE"],
3215 [cf_ncurses_LIBS="-lgpm"])])
3219 # This is only necessary if you are linking against an obsolete
3220 # version of ncurses (but it should do no harm, since it is static).
3221 if test "$cf_nculib_root" = ncurses ; then
3222 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3227 CF_ADD_LIBS($cf_ncurses_LIBS)
3229 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3231 CF_ADD_LIBS(-l$cf_nculib_root)
3233 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3234 [#include <${cf_cv_ncurses_header:-curses.h}>],
3239 if test -n "$cf_ncurses_LIBS" ; then
3240 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3241 cf_ncurses_SAVE="$LIBS"
3242 for p in $cf_ncurses_LIBS ; do
3243 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3244 if test "$q" != "$LIBS" ; then
3248 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3249 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3250 [AC_MSG_RESULT(yes)],
3252 LIBS="$cf_ncurses_SAVE"])
3255 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3256 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3258 dnl ---------------------------------------------------------------------------
3259 dnl CF_NCURSES_VERSION version: 17 updated: 2023/01/05 18:54:02
3260 dnl ------------------
3261 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3262 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3263 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3264 AC_DEFUN([CF_NCURSES_VERSION],
3266 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3267 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3268 cf_cv_ncurses_version=no
3270 rm -f "$cf_tempfile"
3272 $ac_includes_default
3274 #include <${cf_cv_ncurses_header:-curses.h}>
3278 FILE *fp = fopen("$cf_tempfile", "w");
3279 #ifdef NCURSES_VERSION
3280 # ifdef NCURSES_VERSION_PATCH
3281 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3283 fprintf(fp, "%s\\n", NCURSES_VERSION);
3287 fprintf(fp, "old\\n");
3292 ${cf_cv_main_return:-return}(0);
3294 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3296 # This will not work if the preprocessor splits the line after the
3297 # Autoconf token. The 'unproto' program does that.
3298 cat > "conftest.$ac_ext" <<EOF
3299 #include <${cf_cv_ncurses_header:-curses.h}>
3301 #ifdef NCURSES_VERSION
3302 Autoconf NCURSES_VERSION
3310 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3312 if test -f conftest.out ; then
3313 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3314 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3318 rm -f "$cf_tempfile"
3320 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3322 dnl ---------------------------------------------------------------------------
3323 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3325 dnl Compute the object-directory name from the given model name
3326 AC_DEFUN([CF_OBJ_SUBDIR],
3329 (libtool) $2='obj_lo' ;;
3330 (normal) $2='objects' ;;
3331 (debug) $2='obj_g' ;;
3332 (profile) $2='obj_p' ;;
3334 case "$cf_cv_system_name" in
3342 dnl ---------------------------------------------------------------------------
3343 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3345 dnl Provide a value for the $PATH and similar separator (or amend the value
3346 dnl as provided in autoconf 2.5x).
3347 AC_DEFUN([CF_PATHSEP],
3349 AC_MSG_CHECKING(for PATH separator)
3350 case "$cf_cv_system_name" in
3351 (os2*) PATH_SEPARATOR=';' ;;
3352 (*) ${PATH_SEPARATOR:=':'} ;;
3354 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3355 AC_SUBST(PATH_SEPARATOR)
3356 AC_MSG_RESULT($PATH_SEPARATOR)
3358 dnl ---------------------------------------------------------------------------
3359 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3361 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3362 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3363 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3364 dnl delayed evaluation of those symbols.
3365 AC_DEFUN([CF_PATH_SYNTAX],[
3366 if test "x$prefix" != xNONE; then
3367 cf_path_syntax="$prefix"
3369 cf_path_syntax="$ac_default_prefix"
3373 (.\[$]\(*\)*|.\'*\'*)
3377 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3379 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3383 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3388 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3391 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3395 dnl ---------------------------------------------------------------------------
3396 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
3398 dnl Check for the package-config program, unless disabled by command-line.
3400 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3401 AC_DEFUN([CF_PKG_CONFIG],
3403 AC_MSG_CHECKING(if you want to use pkg-config)
3404 AC_ARG_WITH(pkg-config,
3405 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3406 [cf_pkg_config=$withval],
3407 [cf_pkg_config=yes])
3408 AC_MSG_RESULT($cf_pkg_config)
3410 case "$cf_pkg_config" in
3415 CF_ACVERSION_CHECK(2.52,
3416 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3417 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3424 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3425 if test "$PKG_CONFIG" != none ; then
3426 CF_PATH_SYNTAX(PKG_CONFIG)
3427 elif test "x$cf_pkg_config" != xno ; then
3428 AC_MSG_WARN(pkg-config is not installed)
3431 AC_SUBST(PKG_CONFIG)
3433 dnl ---------------------------------------------------------------------------
3434 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3435 dnl -----------------
3436 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3438 dnl POSIX.1-1990 _POSIX_SOURCE
3439 dnl POSIX.1-1990 and _POSIX_SOURCE and
3440 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3442 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3443 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3444 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3447 dnl $1 is the nominal value for _POSIX_C_SOURCE
3448 AC_DEFUN([CF_POSIX_C_SOURCE],
3449 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3451 if test "$cf_cv_posix_visible" = no; then
3453 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3455 cf_save_CFLAGS="$CFLAGS"
3456 cf_save_CPPFLAGS="$CPPFLAGS"
3458 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3459 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3461 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3462 CF_MSG_LOG(if the symbol is already defined go no further)
3463 AC_TRY_COMPILE([#include <sys/types.h>],[
3464 #ifndef _POSIX_C_SOURCE
3467 [cf_cv_posix_c_source=no],
3468 [cf_want_posix_source=no
3469 case .$cf_POSIX_C_SOURCE in
3471 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3474 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3475 cf_want_posix_source=yes
3478 cf_want_posix_source=yes
3481 if test "$cf_want_posix_source" = yes ; then
3482 AC_TRY_COMPILE([#include <sys/types.h>],[
3483 #ifdef _POSIX_SOURCE
3486 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3488 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3489 CFLAGS="$cf_trim_CFLAGS"
3490 CPPFLAGS="$cf_trim_CPPFLAGS"
3491 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3492 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3493 AC_TRY_COMPILE([#include <sys/types.h>],[
3494 #ifndef _POSIX_C_SOURCE
3497 [cf_cv_posix_c_source=no])
3498 CFLAGS="$cf_save_CFLAGS"
3499 CPPFLAGS="$cf_save_CPPFLAGS"
3503 if test "$cf_cv_posix_c_source" != no ; then
3504 CFLAGS="$cf_trim_CFLAGS"
3505 CPPFLAGS="$cf_trim_CPPFLAGS"
3506 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3509 fi # cf_cv_posix_visible
3512 dnl ---------------------------------------------------------------------------
3513 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3514 dnl ----------------
3515 dnl POSIX documents test-macros which an application may set before any system
3516 dnl headers are included to make features available.
3518 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3519 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3520 dnl recent features visible in the system header files unless the application
3521 dnl overrides the corresponding test-macros. Doing that introduces portability
3524 dnl This macro makes a special check for the symbols used for this, to avoid a
3525 dnl conflicting definition.
3526 AC_DEFUN([CF_POSIX_VISIBLE],
3528 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3529 AC_TRY_COMPILE([#include <stdio.h>],[
3530 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3531 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3532 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3533 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3534 #error conflicting symbols found
3536 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3539 dnl ---------------------------------------------------------------------------
3540 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3542 dnl Check for archiver "ar".
3543 AC_DEFUN([CF_PROG_AR],[
3544 AC_CHECK_TOOL(AR, ar, ar)
3546 dnl ---------------------------------------------------------------------------
3547 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3549 dnl Check for awk, ensure that the check found something.
3550 AC_DEFUN([CF_PROG_AWK],
3553 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3555 dnl ---------------------------------------------------------------------------
3556 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3558 dnl standard check for CC, plus followup sanity checks
3559 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3560 AC_DEFUN([CF_PROG_CC],[
3561 CF_ACVERSION_CHECK(2.53,
3562 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3563 AC_REQUIRE([AC_PROG_CC])],
3565 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3567 CF_ACVERSION_CHECK(2.52,
3572 dnl ---------------------------------------------------------------------------
3573 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3575 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3576 dnl the output file can be renamed, and allows for a shell variable that can
3577 dnl be used later. The parameter is either CC or CXX. The result is the
3579 dnl $cf_cv_prog_CC_c_o
3580 dnl $cf_cv_prog_CXX_c_o
3583 dnl $2 = compiler options, if any
3584 AC_DEFUN([CF_PROG_CC_C_O],
3585 [AC_REQUIRE([AC_PROG_CC])dnl
3586 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3587 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3589 cat > conftest.$ac_ext <<CF_EOF
3592 ${cf_cv_main_return:-return}(0);
3595 # We do the test twice because some compilers refuse to overwrite an
3596 # existing .o file with -o, though they will create one.
3597 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3598 if AC_TRY_EVAL(ac_try) &&
3599 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3601 eval cf_cv_prog_$1_c_o=yes
3603 eval cf_cv_prog_$1_c_o=no
3607 if test "$cf_cv_prog_$1_c_o" = yes; then
3608 AC_MSG_RESULT([yes])
3613 dnl ---------------------------------------------------------------------------
3614 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3616 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3617 dnl This macro adds a check to ensure the script found something.
3618 AC_DEFUN([CF_PROG_EGREP],
3619 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3620 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3621 then ac_cv_prog_egrep='grep -E'
3622 else ac_cv_prog_egrep='egrep'
3624 EGREP=$ac_cv_prog_egrep
3626 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3631 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3632 AC_DEFUN([CF_PROG_EXT],
3634 AC_REQUIRE([CF_CHECK_CACHE])
3635 case "$cf_cv_system_name" in
3637 CFLAGS="$CFLAGS -Zmt"
3638 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3639 CXXFLAGS="$CXXFLAGS -Zmt"
3640 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3641 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3651 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3653 dnl ---------------------------------------------------------------------------
3654 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
3656 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3657 AC_DEFUN([CF_PROG_GNAT],[
3658 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3660 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3662 unset ac_cv_path_cf_TEMP_gnat
3664 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3665 eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
3667 if test "x$cf_TEMP_gnat" != xno; then
3668 unset cf_cv_gnat_version
3670 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3672 eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
3675 unset cf_cv_gnat_version
3676 unset ac_cv_path_cf_TEMP_gnat
3679 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3681 cf_cv_prog_gnat_correct=no
3683 cf_ada_make=gnatmake
3684 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3685 # gprconfig is newer than gnatmake; we can continue...
3688 rm -rf ./conftest* ./*~conftest*
3689 if mkdir conftest.src
3693 for cf_gprconfig in Ada C
3695 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3696 if test "$cf_gprconfig" = C
3698 for cf_gprconfig_param in \
3699 "$cf_gprconfig,,,,GNATGCC" \
3700 "$cf_gprconfig,,,,GCC" \
3703 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3704 test -n "$cf_gprconfig_value" && break
3707 cf_gprconfig_param=$cf_gprconfig
3708 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3710 if test -n "$cf_gprconfig_value"
3712 eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
3713 AC_MSG_RESULT($cf_gprconfig_value)
3715 AC_MSG_RESULT(missing)
3721 rm -rf ./conftest* ./*~conftest*
3724 if test "x$cf_ada_config" != "x#"
3727 CF_CHECK_GNAT_VERSION
3728 AC_CHECK_PROG(M4_exists, m4, yes, no)
3729 if test "$ac_cv_prog_M4_exists" = no; then
3730 cf_cv_prog_gnat_correct=no
3731 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3733 if test "$cf_cv_prog_gnat_correct" = yes; then
3734 AC_MSG_CHECKING(if GNAT works)
3735 CF_GNAT_TRY_RUN([procedure conftest;],
3738 procedure conftest is
3740 Text_IO.Put ("Hello World");
3742 GNAT.OS_Lib.OS_Exit (0);
3744 [cf_cv_prog_gnat_correct=yes],
3745 [cf_cv_prog_gnat_correct=no])
3746 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3749 cf_cv_prog_gnat_correct=no
3753 AC_SUBST(cf_ada_make)
3754 AC_SUBST(cf_ada_config)
3755 AC_SUBST(cf_ada_config_Ada)
3756 AC_SUBST(cf_ada_config_C)
3758 dnl ---------------------------------------------------------------------------
3759 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3761 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3762 dnl misc/tabset install won't work properly. Usually this happens only when
3763 dnl using the fallback mkinstalldirs script
3764 AC_DEFUN([CF_PROG_INSTALL],
3770 CF_DIRNAME(cf_dir,$INSTALL)
3771 test -z "$cf_dir" && cf_dir=.
3772 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3776 dnl ---------------------------------------------------------------------------
3777 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3779 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3780 dnl option if it is supported.
3781 AC_DEFUN([CF_PROG_LN_S],[
3783 AC_MSG_CHECKING(if $LN_S -f options work)
3785 rm -f conf$$.src conf$$dst
3787 echo first >conf$$.src
3788 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3793 rm -f conf$$.dst conf$$src
3794 AC_MSG_RESULT($cf_prog_ln_sf)
3796 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3798 dnl ---------------------------------------------------------------------------
3799 dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40
3800 dnl ----------------
3801 dnl Remove a given option from CFLAGS/CPPFLAGS
3802 dnl $1 = option to remove
3803 dnl $2 = variable to update
3804 dnl $3 = nonempty to allow verbose message
3805 define([CF_REMOVE_CFLAGS],
3807 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3810 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'`
3811 test "[$]$2" != "$cf_old_cflag" || break
3812 ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3816 dnl ---------------------------------------------------------------------------
3817 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3818 dnl ----------------
3819 dnl Remove all -U and -D options that refer to the given symbol from a list
3820 dnl of C compiler options. This works around the problem that not all
3821 dnl compilers process -U and -D options from left-to-right, so a -U option
3822 dnl cannot be used to cancel the effect of a preceding -D option.
3824 dnl $1 = target (which could be the same as the source variable)
3825 dnl $2 = source (including '$')
3826 dnl $3 = symbol to remove
3827 define([CF_REMOVE_DEFINE],
3830 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3831 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3833 dnl ---------------------------------------------------------------------------
3834 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3836 dnl Remove the given library from the symbol
3838 dnl $1 = target (which could be the same as the source variable)
3839 dnl $2 = source (including '$')
3840 dnl $3 = library to remove
3841 define([CF_REMOVE_LIB],
3843 # remove $3 library from $2
3844 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3846 dnl ---------------------------------------------------------------------------
3847 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3848 dnl ---------------------
3849 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3850 dnl $1 = name of current macro
3851 define([CF_RESTORE_XTRA_FLAGS],
3853 LIBS="$cf_save_LIBS_$1"
3854 CFLAGS="$cf_save_CFLAGS_$1"
3855 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3857 dnl ---------------------------------------------------------------------------
3858 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3859 dnl ------------------
3860 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3861 dnl and libraries which do not update those variables.
3863 dnl $1 = name of current macro
3864 define([CF_SAVE_XTRA_FLAGS],
3866 cf_save_LIBS_$1="$LIBS"
3867 cf_save_CFLAGS_$1="$CFLAGS"
3868 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3869 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3870 for cf_X_CFLAGS in $X_CFLAGS
3872 case "x$cf_X_CFLAGS" in
3874 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3877 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3882 dnl ---------------------------------------------------------------------------
3883 dnl CF_SHARED_OPTS version: 107 updated: 2021/09/04 06:47:34
3886 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3890 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3891 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3892 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3893 dnl shared library since that can lead to unexpected results at runtime.
3894 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3895 dnl libraries are compiled in ../../lib
3897 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3898 dnl to install symbolic links to the rel/abi versions of shared libraries.
3900 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3901 dnl version when making symbolic links.
3903 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3904 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3905 dnl (ex: libncurses.so.<ver>).
3907 dnl Some loaders leave 'so_locations' lying around. It is nice to clean up.
3908 AC_DEFUN([CF_SHARED_OPTS],
3910 AC_REQUIRE([CF_LD_RPATH_OPT])
3916 INSTALL_LIB="-m 644"
3917 : ${rel_builddir:=.}
3925 cf_cv_do_symlinks=no
3927 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3929 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3930 AC_ARG_WITH(shlib-version,
3931 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3932 [test -z "$withval" && withval=auto
3935 cf_cv_shlib_version=auto
3938 cf_cv_shlib_version=$withval
3941 AC_MSG_RESULT($withval)
3942 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3945 ],[cf_cv_shlib_version=auto])
3946 AC_MSG_RESULT($cf_cv_shlib_version)
3951 # Some less-capable ports of gcc support only -fpic
3955 if test "$GCC" = yes
3959 case "$cf_cv_system_name" in
3960 (*linux*) # e.g., PGI compiler
3966 if test "$cf_try_fPIC" = yes
3968 AC_MSG_CHECKING(which $CC option to use)
3969 cf_save_CFLAGS="$CFLAGS"
3970 for CC_SHARED_OPTS in -fPIC -fpic ''
3972 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3973 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3975 AC_MSG_RESULT($CC_SHARED_OPTS)
3976 CFLAGS="$cf_save_CFLAGS"
3979 cf_cv_shlib_version_infix=no
3981 case "$cf_cv_system_name" in
3982 (aix4.[3-9]*|aix[[5-7]]*)
3983 if test "$GCC" = yes; then
3984 CC_SHARED_OPTS='-Wl,-brtl'
3985 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3987 CC_SHARED_OPTS='-brtl'
3988 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3989 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3993 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3997 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3998 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3999 cf_cv_shlib_version=cygdll
4000 cf_cv_shlib_version_infix=cygdll
4003 cat >mk_shared_lib.sh <<-CF_EOF
4006 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4009 Linking shared library
4010 ** SHARED_LIB \[$]SHARED_LIB
4011 ** IMPORT_LIB \[$]IMPORT_LIB
4013 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4015 chmod +x mk_shared_lib.sh
4019 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4020 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4021 cf_cv_shlib_version=msysdll
4022 cf_cv_shlib_version_infix=msysdll
4025 cat >mk_shared_lib.sh <<-CF_EOF
4028 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4031 Linking shared library
4032 ** SHARED_LIB \[$]SHARED_LIB
4033 ** IMPORT_LIB \[$]IMPORT_LIB
4035 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4037 chmod +x mk_shared_lib.sh
4040 cf_try_cflags="no-cpp-precomp"
4041 CC_SHARED_OPTS="-dynamic"
4042 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
4043 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
4044 cf_cv_shlib_version_infix=yes
4045 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
4046 cf_save_LDFLAGS=$LDFLAGS
4047 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4048 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
4049 LDFLAGS=$cf_save_LDFLAGS])
4050 if test "$cf_cv_ldflags_search_paths_first" = yes; then
4051 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
4056 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4059 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
4060 if test "$GCC" != yes; then
4063 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
4064 INSTALL_LIB="-m 555"
4067 # (tested with gcc 2.7.2 -- I don't have c89)
4068 if test "$GCC" = yes; then
4069 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
4072 LD_SHARED_OPTS='-Wl,+b,${libdir}'
4074 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
4075 # HP-UX shared libraries must be executable, and should be
4076 # readonly to exploit a quirk in the memory manager.
4077 INSTALL_LIB="-m 555"
4080 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4081 if test "$cf_cv_shlib_version" = rel; then
4082 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4084 cf_shared_soname='`basename $[@]`'
4087 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
4090 if test "$cf_cv_enable_rpath" = yes ; then
4091 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4093 # tested with IRIX 5.2 and 'cc'.
4094 if test "$GCC" != yes; then
4095 CC_SHARED_OPTS='-KPIC'
4096 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
4098 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
4100 cf_cv_rm_so_locs=yes
4102 (linux*|gnu*|k*bsd*-gnu)
4103 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4104 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4105 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4107 if test "$cf_cv_enable_rpath" = yes ; then
4108 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4111 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4114 cf_cv_shlib_version=msvcdll
4115 cf_cv_shlib_version_infix=msvcdll
4118 if test "$DFT_LWR_MODEL" = "shared" ; then
4119 LOCAL_LDFLAGS="-link -dll"
4120 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4121 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
4124 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
4125 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
4126 cat >mk_shared_lib.sh <<-CF_EOF
4129 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
4134 Linking shared library
4135 ** SHARED LIB \$SHARED_LIB
4136 ** IMPORT_LIB \$IMPORT_LIB
4138 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
4139 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
4140 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
4142 chmod +x mk_shared_lib.sh
4143 cat >mk_prog.sh <<-CF_EOF
4146 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
4149 ldopts=("/subsystem:console")
4152 while test \[$]# -gt 0; do
4155 # ignore -link argument
4157 -M[[TD]] | -M[[TD]]d)
4158 # ignore runtime-library option
4173 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
4176 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
4182 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
4183 ldopts+=("\[$]{linkarg}")
4191 ldopts+=("-out:\[$]1")
4200 if [[ "\$isdll" -ne 0 ]]; then
4201 for lib in \[$]{libs[[*]]}; do
4202 ldopts+=("\[$]lib.dll.lib")
4205 for lib in \[$]{libs[[*]]}; do
4206 ldopts+=("\[$]lib.lib")
4211 ** ld options: "\[$]{ldopts[[@]]}"
4213 exec \[$]LD \[$]{ldopts[[@]]}
4216 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
4217 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
4220 cf_cv_shlib_version=mingw
4221 cf_cv_shlib_version_infix=mingw
4224 if test "$DFT_LWR_MODEL" = "shared" ; then
4225 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
4226 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4227 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
4230 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4231 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4232 cat >mk_shared_lib.sh <<-CF_EOF
4235 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4238 Linking shared library
4239 ** SHARED_LIB \[$]SHARED_LIB
4240 ** IMPORT_LIB \[$]IMPORT_LIB
4242 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4244 chmod +x mk_shared_lib.sh
4246 (openbsd[[2-9]].*|mirbsd*)
4247 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4248 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4249 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4251 if test "$cf_cv_enable_rpath" = yes ; then
4252 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4254 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4256 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4260 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4264 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4266 (nto-qnx*|openbsd*|freebsd[[12]].*)
4267 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4268 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4269 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4271 (dragonfly*|freebsd*)
4272 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4273 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4274 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4275 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4276 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4279 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4282 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4283 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4284 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4285 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4286 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4287 if test "$cf_cv_shlib_version" = auto; then
4288 if test -f /usr/libexec/ld.elf_so; then
4289 cf_cv_shlib_version=abi
4291 cf_cv_shlib_version=rel
4295 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4297 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4301 # tested with OSF/1 V3.2 and 'cc'
4302 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4303 # link with shared libs).
4304 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4307 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4310 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4311 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4312 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4313 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4315 cf_cv_rm_so_locs=yes
4317 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
4318 # tested with osr5.0.5
4319 if test "$GCC" != yes; then
4320 CC_SHARED_OPTS='-belf -KPIC'
4322 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4323 if test "$cf_cv_enable_rpath" = yes ; then
4324 # only way is to set LD_RUN_PATH but no switch for it
4327 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4328 LINK_PROGS='LD_RUN_PATH=${libdir}'
4329 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4332 # tested with SunOS 4.1.1 and gcc 2.7.0
4333 if test "$GCC" != yes; then
4334 CC_SHARED_OPTS='-KPIC'
4336 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4337 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4340 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4341 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4342 if test "$DFT_LWR_MODEL" = "shared" ; then
4343 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4344 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4346 if test "$cf_cv_enable_rpath" = yes ; then
4347 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
4350 if test "$GCC" != yes; then
4351 cf_save_CFLAGS="$CFLAGS"
4352 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4354 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4355 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
4357 CFLAGS="$cf_save_CFLAGS"
4358 CC_SHARED_OPTS=$cf_shared_opts
4359 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4361 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4364 (sysv5uw7*|unix_sv*)
4365 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4366 if test "$GCC" != yes; then
4367 CC_SHARED_OPTS='-KPIC'
4369 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4372 CC_SHARED_OPTS='unknown'
4373 MK_SHARED_LIB='echo unknown'
4377 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4378 case "$cf_cv_shlib_version" in
4380 case "$MK_SHARED_LIB" in
4382 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4385 AC_MSG_WARN(ignored --with-shlib-version)
4391 if test -n "$cf_try_cflags"
4393 cat > conftest.$ac_ext <<EOF
4394 #line __oline__ "${as_me:-configure}"
4396 int main(int argc, char *argv[[]])
4399 return (argv[[argc-1]] == 0) ;
4402 cf_save_CFLAGS="$CFLAGS"
4403 for cf_opt in $cf_try_cflags
4405 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4406 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4407 if AC_TRY_EVAL(ac_compile); then
4409 cf_save_CFLAGS="$CFLAGS"
4414 CFLAGS="$cf_save_CFLAGS"
4418 # RPATH_LIST is a colon-separated list of directories
4419 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4420 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4422 test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4424 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4425 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4427 AC_SUBST(CC_SHARED_OPTS)
4428 AC_SUBST(LD_RPATH_OPT)
4429 AC_SUBST(LD_SHARED_OPTS)
4430 AC_SUBST(MK_SHARED_LIB)
4431 AC_SUBST(RM_SHARED_OPTS)
4433 AC_SUBST(LINK_PROGS)
4434 AC_SUBST(LINK_TESTS)
4436 AC_SUBST(EXTRA_LDFLAGS)
4437 AC_SUBST(LOCAL_LDFLAGS)
4438 AC_SUBST(LOCAL_LDFLAGS2)
4440 AC_SUBST(INSTALL_LIB)
4441 AC_SUBST(RPATH_LIST)
4443 dnl ---------------------------------------------------------------------------
4444 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4445 dnl ----------------
4446 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4447 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4450 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4451 dnl If missing, use "rel".
4452 define([CF_SHARED_SONAME],
4454 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4455 if test "$cf_cv_shlib_version" = rel; then
4456 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4458 cf_cv_shared_soname='`basename $[@]`'
4461 dnl ---------------------------------------------------------------------------
4462 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
4464 dnl Remove "-g" option from the compiler options
4465 AC_DEFUN([CF_STRIP_G_OPT],
4466 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
4467 dnl ---------------------------------------------------------------------------
4468 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4470 dnl Construct a search-list for a nonstandard header/lib-file
4471 dnl $1 = the variable to return as result
4472 dnl $2 = the package name
4473 dnl $3 = the subdirectory, e.g., bin, include or lib
4474 AC_DEFUN([CF_SUBDIR_PATH],
4478 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4480 for cf_subdir_prefix in \
4488 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4491 dnl ---------------------------------------------------------------------------
4492 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
4494 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4495 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4496 dnl but some packagers change this, breaking various applications.
4497 AC_DEFUN([CF_TERM_HEADER],[
4498 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4499 case "${cf_cv_ncurses_header}" in
4500 (*/ncurses.h|*/ncursesw.h)
4501 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4504 cf_term_header=term.h
4508 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4510 AC_TRY_COMPILE([#include <stdio.h>
4511 #include <${cf_cv_ncurses_header:-curses.h}>
4513 ],[int x = auto_left_margin; (void)x],[
4514 cf_cv_term_header="$cf_test"],[
4515 cf_cv_term_header=unknown
4517 test "$cf_cv_term_header" != unknown && break
4521 # Set definitions to allow ifdef'ing to accommodate subdirectories
4523 case "$cf_cv_term_header" in
4525 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4529 case "$cf_cv_term_header" in
4531 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4534 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4538 dnl ---------------------------------------------------------------------------
4539 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4541 dnl Define a top_builddir symbol, for applications that need an absolute path.
4542 AC_DEFUN([CF_TOP_BUILDDIR],
4544 top_builddir=ifelse($1,,`pwd`,$1)
4545 AC_SUBST(top_builddir)
4547 dnl ---------------------------------------------------------------------------
4548 dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16
4549 dnl -------------------
4550 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4551 dnl can define it successfully.
4552 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4553 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4554 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4555 [cf_cv_xopen_source=no],
4556 [cf_save="$CPPFLAGS"
4557 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4558 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,
4559 [cf_cv_xopen_source=no],
4560 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4565 if test "$cf_cv_xopen_source" != no ; then
4566 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4567 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4568 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4569 CF_APPEND_CFLAGS($cf_temp_xopen_source)
4572 dnl ---------------------------------------------------------------------------
4573 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4575 dnl Make an uppercase version of a variable
4576 dnl $1=uppercase($2)
4577 AC_DEFUN([CF_UPPER],
4579 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4581 dnl ---------------------------------------------------------------------------
4582 dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23
4584 dnl Check for multibyte support, and if not found, utf8 compatibility library
4585 AC_DEFUN([CF_UTF8_LIB],
4587 AC_HAVE_HEADERS(wchar.h)
4588 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4589 cf_save_LIBS="$LIBS"
4591 $ac_includes_default
4596 [cf_cv_utf8_lib=yes],
4598 #include <libutf8.h>],[putwc(0,0);],utf8,
4599 [cf_cv_utf8_lib=add-on],
4600 [cf_cv_utf8_lib=no])
4603 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4605 if test "$cf_cv_utf8_lib" = "add-on" ; then
4606 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4607 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4608 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4609 CF_ADD_LIBS($cf_cv_library_file_utf8)
4612 dnl ---------------------------------------------------------------------------
4613 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4615 dnl Use AC_VERBOSE w/o the warnings
4616 AC_DEFUN([CF_VERBOSE],
4617 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4620 dnl ---------------------------------------------------------------------------
4621 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4623 dnl Check for compiler-support for weak symbols.
4624 dnl This works with "recent" gcc.
4625 AC_DEFUN([CF_WEAK_SYMBOLS],[
4626 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4629 #include <stdio.h>],
4631 #if defined(__GNUC__)
4632 # if defined __USE_ISOC99
4633 # define _cat_pragma(exp) _Pragma(#exp)
4634 # define _weak_pragma(exp) _cat_pragma(weak name)
4636 # define _weak_pragma(exp)
4638 # define _declare(name) __extension__ extern __typeof__(name) name
4639 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4643 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4646 dnl ---------------------------------------------------------------------------
4647 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4648 dnl --------------------
4649 dnl Command-line option to specify the Ada95 compiler.
4650 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4651 AC_MSG_CHECKING(for ada-compiler)
4652 AC_ARG_WITH(ada-compiler,
4653 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4654 [cf_ada_compiler=$withval],
4655 [cf_ada_compiler=gnatmake])
4656 AC_SUBST(cf_ada_compiler)
4657 AC_MSG_RESULT($cf_ada_compiler)
4659 dnl ---------------------------------------------------------------------------
4660 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4661 dnl -------------------
4662 dnl Command-line option to specify where Ada includes will install.
4663 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4664 AC_MSG_CHECKING(for ada-include)
4665 CF_WITH_PATH(ada-include,
4666 [ --with-ada-include=DIR Ada includes are in DIR],
4668 PREFIX/share/ada/adainclude,
4669 [$]prefix/share/ada/adainclude)
4670 AC_SUBST(ADA_INCLUDE)
4671 AC_MSG_RESULT($ADA_INCLUDE)
4673 dnl ---------------------------------------------------------------------------
4674 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4675 dnl -------------------
4676 dnl CF_WITH_ADA_LIBNAME
4677 dnl -------------------
4678 dnl Command-line option to specify how to name the resulting Ada library.
4679 dnl $1 = default value
4680 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4681 AC_MSG_CHECKING(for ada-libname)
4682 AC_ARG_WITH(ada-libname,
4683 [ --with-ada-libname=XXX override default Ada library-name],
4684 ADA_LIBNAME=[$]withval,
4686 case "x$ADA_LIBNAME" in
4691 AC_SUBST(ADA_LIBNAME)
4692 AC_MSG_RESULT($ADA_LIBNAME)
4694 dnl ---------------------------------------------------------------------------
4695 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4696 dnl -------------------
4697 dnl Command-line option to specify where Ada objects will install.
4698 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4699 AC_MSG_CHECKING(for ada-objects)
4700 CF_WITH_PATH(ada-objects,
4701 [ --with-ada-objects=DIR Ada objects are in DIR],
4703 PREFIX/lib/ada/adalib,
4704 [$]prefix/lib/ada/adalib)
4705 AC_SUBST(ADA_OBJECTS)
4706 AC_MSG_RESULT($ADA_OBJECTS)
4708 dnl ---------------------------------------------------------------------------
4709 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4710 dnl ---------------------
4711 dnl Command-line option to specify if an Ada95 shared-library should be built,
4712 dnl and optionally what its soname should be.
4713 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4714 AC_REQUIRE([CF_GNAT_PROJECTS])
4715 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4716 AC_ARG_WITH(ada-sharedlib,
4717 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4718 [with_ada_sharedlib=$withval],
4719 [with_ada_sharedlib=no])
4720 AC_MSG_RESULT($with_ada_sharedlib)
4722 if test "x$with_ada_sharedlib" != xno
4724 if test "x$cf_gnat_projects" != xyes
4726 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4727 with_ada_sharedlib=no
4731 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4732 MAKE_ADA_SHAREDLIB="#"
4734 if test "x$with_ada_sharedlib" != xno
4737 if test "x$with_ada_sharedlib" != xyes
4739 ADA_SHAREDLIB="$with_ada_sharedlib"
4743 AC_SUBST(ADA_SHAREDLIB)
4744 AC_SUBST(MAKE_ADA_SHAREDLIB)
4746 dnl ---------------------------------------------------------------------------
4747 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4748 dnl ------------------
4749 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4751 AC_DEFUN([CF_WITH_CURSES_DIR],[
4753 AC_MSG_CHECKING(for specific curses-directory)
4754 AC_ARG_WITH(curses-dir,
4755 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4756 [cf_cv_curses_dir=$withval],
4757 [cf_cv_curses_dir=no])
4758 AC_MSG_RESULT($cf_cv_curses_dir)
4760 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4762 CF_PATH_SYNTAX(withval)
4763 if test -d "$cf_cv_curses_dir"
4765 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4766 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4770 dnl ---------------------------------------------------------------------------
4771 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
4772 dnl ------------------
4773 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4774 dnl "lib" prefix, e.g., because it used the dll naming convention.
4776 dnl $1 = variable to set
4777 AC_DEFUN([CF_WITH_LIB_PREFIX],
4779 AC_MSG_CHECKING(if you want to have a library-prefix)
4780 AC_ARG_WITH(lib-prefix,
4781 [ --with-lib-prefix override library-prefix],
4782 [with_lib_prefix=$withval],
4783 [with_lib_prefix=auto])
4784 AC_MSG_RESULT($with_lib_prefix)
4786 if test "$with_lib_prefix" = auto
4789 elif test "$with_lib_prefix" = no
4793 LIB_PREFIX=$with_lib_prefix
4796 dnl ---------------------------------------------------------------------------
4797 dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04
4799 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4800 dnl defaulting to yes/no.
4802 dnl $1 = option name
4804 dnl $3 = environment variable to set
4805 dnl $4 = default value, shown in the help-message, must be a constant
4806 dnl $5 = default value, if it is an expression & cannot be in the help-message
4808 AC_DEFUN([CF_WITH_PATH],
4809 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4810 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4811 if ifelse([$5],,true,[test -n "$5"]) ; then
4812 CF_PATH_SYNTAX(withval)
4817 dnl ---------------------------------------------------------------------------
4818 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 21 updated: 2023/01/22 13:37:42
4819 dnl -------------------------
4820 dnl Allow the choice of the pkg-config library directory to be overridden.
4822 dnl pkg-config uses a search-list built from these colon-separated lists of
4824 dnl a) $PKG_CONFIG_PATH (tested first, added if set)
4825 dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set)
4826 dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set)
4828 dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config)
4829 dnl optionally ignores $PKG_CONFIG_LIBDIR. Very old versions of pkg-config,
4830 dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR.
4831 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4833 case "$PKG_CONFIG" in
4835 AC_MSG_CHECKING(for pkg-config library directory)
4838 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4842 # if $PKG_CONFIG_LIBDIR is set, try to use that
4843 if test -n "$PKG_CONFIG_PATH"; then
4844 cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
4845 elif test -n "$PKG_CONFIG_LIBDIR"; then
4846 cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'`
4851 # if the option is used, let that override. otherwise default to "libdir"
4852 AC_ARG_WITH(pkg-config-libdir,
4853 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4854 [cf_search_path=$withval],
4855 [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir])
4857 case "x$cf_search_path" in
4859 PKG_CONFIG_LIBDIR='${libdir}/pkgconfig'
4860 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4869 PKG_CONFIG_LIBDIR="$cf_search_path"
4870 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4876 # Look for the library directory using the same prefix as the executable
4877 AC_MSG_CHECKING(for search-list)
4878 if test "x$PKG_CONFIG" != xnone
4880 # works for pkg-config since version 0.24 (2009)
4881 # works for pkgconf since version 0.8.3 (2012)
4882 for cf_pkg_program in \
4883 `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \
4887 cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '`
4888 test -n "$cf_search_path" && break
4891 # works for pkg-config since import in 2005 of original 2001 HP code.
4892 test -z "$cf_search_path" && \
4894 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\
4895 /^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \
4896 sub(\"^[[^']]*'\",\"\"); \
4897 sub(\"'.*\",\"\"); \
4898 printf \" %s\", \\[$]0; } \
4903 AC_MSG_RESULT($cf_search_path)
4906 AC_MSG_ERROR(Unexpected option value: $cf_search_path)
4910 if test -n "$cf_search_path"
4912 AC_MSG_CHECKING(for first directory)
4913 cf_pkg_config_path=none
4914 for cf_config in $cf_search_path
4916 if test -d "$cf_config"
4918 cf_pkg_config_path=$cf_config
4922 AC_MSG_RESULT($cf_pkg_config_path)
4924 if test "x$cf_pkg_config_path" != xnone ; then
4925 # limit this to the first directory found
4926 PKG_CONFIG_LIBDIR="$cf_pkg_config_path"
4929 if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path"
4931 AC_MSG_CHECKING(for workaround)
4932 if test "$prefix" = "NONE" ; then
4933 cf_prefix="$ac_default_prefix"
4937 eval cf_libdir=$libdir
4938 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"`
4940 for cf_config in $cf_search_path
4943 $cf_libdir/pkgconfig)
4944 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig
4948 test -z "$cf_backup" && cf_backup=$cf_config
4952 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup
4953 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4957 AC_SUBST(PKG_CONFIG_LIBDIR)
4959 dnl ---------------------------------------------------------------------------
4960 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4962 dnl Check for POSIX thread library.
4963 AC_DEFUN([CF_WITH_PTHREAD],
4965 AC_MSG_CHECKING(if you want to link with the pthread library)
4966 AC_ARG_WITH(pthread,
4967 [ --with-pthread use POSIX thread library],
4968 [with_pthread=$withval],
4970 AC_MSG_RESULT($with_pthread)
4972 if test "$with_pthread" != no ; then
4973 AC_CHECK_HEADER(pthread.h,[
4974 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4976 for cf_lib_pthread in pthread c_r
4978 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4979 cf_save_LIBS="$LIBS"
4980 CF_ADD_LIB($cf_lib_pthread)
4982 #include <pthread.h>
4984 int rc = pthread_create(0,0,0,0);
4985 int r2 = pthread_mutexattr_settype(0, 0);
4986 ],[with_pthread=yes],[with_pthread=no])
4987 LIBS="$cf_save_LIBS"
4988 AC_MSG_RESULT($with_pthread)
4989 test "$with_pthread" = yes && break
4992 if test "$with_pthread" = yes ; then
4993 CF_ADD_LIB($cf_lib_pthread)
4994 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4996 AC_MSG_ERROR(Cannot link with pthread library)
5001 dnl ---------------------------------------------------------------------------
5002 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
5004 dnl For testing, override the derived host system-type which is used to decide
5005 dnl things such as the linker commands used to build shared libraries. This is
5006 dnl normally chosen automatically based on the type of system which you are
5007 dnl building on. We use it for testing the configure script.
5009 dnl This is different from the --host option: it is used only for testing parts
5010 dnl of the configure script which would not be reachable with --host since that
5011 dnl relies on the build environment being real, rather than mocked up.
5012 AC_DEFUN([CF_WITH_SYSTYPE],[
5013 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
5014 AC_ARG_WITH(system-type,
5015 [ --with-system-type=XXX test: override derived host system-type],
5016 [AC_MSG_WARN(overriding system type to $withval)
5017 cf_cv_system_name=$withval
5021 dnl ---------------------------------------------------------------------------
5022 dnl CF_XOPEN_SOURCE version: 63 updated: 2022/12/29 10:10:26
5024 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
5025 dnl or adapt to the vendor's definitions to get equivalent functionality,
5026 dnl without losing the common non-POSIX features.
5029 dnl $1 is the nominal value for _XOPEN_SOURCE
5030 dnl $2 is the nominal value for _POSIX_C_SOURCE
5031 AC_DEFUN([CF_XOPEN_SOURCE],[
5032 AC_REQUIRE([AC_CANONICAL_HOST])
5033 AC_REQUIRE([CF_POSIX_VISIBLE])
5035 if test "$cf_cv_posix_visible" = no; then
5037 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
5038 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
5043 cf_xopen_source="-D_ALL_SOURCE"
5049 cf_xopen_source="-D_APPLE_C_SOURCE"
5052 cf_xopen_source="-D_DARWIN_C_SOURCE"
5055 (freebsd*|dragonfly*|midnightbsd*)
5056 # 5.x headers associate
5057 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
5058 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
5059 cf_POSIX_C_SOURCE=200112L
5061 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
5064 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
5067 cf_xopen_source="-D_HPUX_SOURCE"
5070 cf_xopen_source="-D_SGI_SOURCE"
5073 (linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
5074 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
5077 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
5080 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
5082 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5085 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
5088 # OpenBSD 6.x has broken locale support, both compile-time and runtime.
5089 # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
5090 # Abusing the conformance level is a workaround.
5091 AC_MSG_WARN(this system does not provide usable locale support)
5092 cf_xopen_source="-D_BSD_SOURCE"
5096 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
5097 cf_xopen_source="-D_BSD_SOURCE"
5101 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
5104 cf_xopen_source="-D_OSF_SOURCE"
5107 cf_xopen_source="-D_QNX_SOURCE"
5110 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
5113 cf_xopen_source="-D__EXTENSIONS__"
5114 cf_cv_xopen_source=broken
5116 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
5122 cf_save_xopen_cppflags="$CPPFLAGS"
5123 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
5124 # Some of these niche implementations use copy/paste, double-check...
5125 if test "$cf_cv_xopen_source" != no ; then
5126 CF_VERBOSE(checking if _POSIX_C_SOURCE inteferes)
5127 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[
5128 AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable)
5129 CPPFLAGS="$cf_save_xopen_cppflags"])
5134 if test -n "$cf_xopen_source" ; then
5135 CF_APPEND_CFLAGS($cf_xopen_source,true)
5138 dnl In anything but the default case, we may have system-specific setting
5139 dnl which is still not guaranteed to provide all of the entrypoints that
5140 dnl _XOPEN_SOURCE would yield.
5141 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
5142 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
5143 AC_TRY_COMPILE([#include <stdlib.h>],[
5144 #ifndef _XOPEN_SOURCE
5147 [cf_XOPEN_SOURCE_set=yes],
5148 [cf_XOPEN_SOURCE_set=no])
5149 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
5150 if test "$cf_XOPEN_SOURCE_set" = yes
5152 AC_TRY_COMPILE([#include <stdlib.h>],[
5153 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
5156 [cf_XOPEN_SOURCE_set_ok=yes],
5157 [cf_XOPEN_SOURCE_set_ok=no])
5158 if test "$cf_XOPEN_SOURCE_set_ok" = no
5160 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
5166 fi # cf_cv_posix_visible
5168 dnl ---------------------------------------------------------------------------
5169 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
5170 dnl ------------------
5171 dnl Trim something using sed, then trim extra whitespace
5172 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
5173 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl
5174 dnl ---------------------------------------------------------------------------
5175 dnl CF__XOPEN_SOURCE_BODY version: 1 updated: 2022/09/10 15:17:35
5176 dnl ---------------------
5177 dnl body of test when test-compiling for _XOPEN_SOURCE check
5178 define([CF__XOPEN_SOURCE_BODY],
5180 #ifndef _XOPEN_SOURCE
5184 dnl ---------------------------------------------------------------------------
5185 dnl CF__XOPEN_SOURCE_HEAD version: 1 updated: 2022/09/10 15:17:03
5186 dnl ---------------------
5187 dnl headers to include when test-compiling for _XOPEN_SOURCE check
5188 define([CF__XOPEN_SOURCE_HEAD],
5192 #include <sys/types.h>