1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey *
3 dnl Copyright 2010-2017,2018 Free Software Foundation, Inc. *
5 dnl Permission is hereby granted, free of charge, to any person obtaining a *
6 dnl copy of this software and associated documentation files (the *
7 dnl "Software"), to deal in the Software without restriction, including *
8 dnl without limitation the rights to use, copy, modify, merge, publish, *
9 dnl distribute, distribute with modifications, sublicense, and/or sell *
10 dnl copies of the Software, and to permit persons to whom the Software is *
11 dnl furnished to do so, subject to the following conditions: *
13 dnl The above copyright notice and this permission notice shall be included *
14 dnl in all copies or substantial portions of the Software. *
16 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
17 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
18 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
19 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
20 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
21 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
22 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
24 dnl Except as contained in this notice, the name(s) of the above copyright *
25 dnl holders shall not be used in advertising or otherwise to promote the *
26 dnl sale, use or other dealings in this Software without prior written *
28 dnl***************************************************************************
30 dnl Author: Thomas E. Dickey
32 dnl $Id: aclocal.m4,v 1.188 2021/10/30 20:49:04 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: 9 updated: 2021/01/02 09:31:20
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 if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
547 AC_MSG_ERROR([Cross-build requires two compilers.
548 Use --with-build-cc to specify the native compiler.])
552 : ${BUILD_CC:='${CC}'}
553 : ${BUILD_CPP:='${CPP}'}
554 : ${BUILD_CFLAGS:='${CFLAGS}'}
555 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
556 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
557 : ${BUILD_LIBS:='${LIBS}'}
558 : ${BUILD_EXEEXT:='$x'}
559 : ${BUILD_OBJEXT:='o'}
564 AC_SUBST(BUILD_CFLAGS)
565 AC_SUBST(BUILD_CPPFLAGS)
566 AC_SUBST(BUILD_LDFLAGS)
568 AC_SUBST(BUILD_EXEEXT)
569 AC_SUBST(BUILD_OBJEXT)
571 dnl ---------------------------------------------------------------------------
572 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
574 AC_DEFUN([CF_C11_NORETURN],
576 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
577 CF_ARG_ENABLE(stdnoreturn,
578 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
579 [enable_stdnoreturn=yes],
580 [enable_stdnoreturn=no])
581 AC_MSG_RESULT($enable_stdnoreturn)
583 if test $enable_stdnoreturn = yes; then
584 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
588 #include <stdnoreturn.h>
589 static _Noreturn void giveup(void) { exit(0); }
591 [if (feof(stdin)) giveup()],
592 cf_cv_c11_noreturn=yes,
593 cf_cv_c11_noreturn=no)
596 cf_cv_c11_noreturn=no,
599 if test "$cf_cv_c11_noreturn" = yes; then
600 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
601 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
607 AC_SUBST(HAVE_STDNORETURN_H)
608 AC_SUBST(STDC_NORETURN)
610 dnl ---------------------------------------------------------------------------
611 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
613 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
614 dnl into CC. This will not help with broken scripts that wrap the compiler
615 dnl with options, but eliminates a more common category of user confusion.
617 dnl In particular, it addresses the problem of being able to run the C
618 dnl preprocessor in a consistent manner.
620 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
621 dnl the nuisance of having inconsistent settings for compiler and preprocessor
622 dnl outweighs that limitation.
623 AC_DEFUN([CF_CC_ENV_FLAGS],
625 # This should have been defined by AC_PROG_CC
628 AC_MSG_CHECKING(\$CFLAGS variable)
631 AC_MSG_RESULT(broken)
632 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
635 for cf_arg in $cf_flags
637 CF_ADD_CFLAGS($cf_arg)
645 AC_MSG_CHECKING(\$CC variable)
648 AC_MSG_RESULT(broken)
649 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
651 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
652 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
654 for cf_arg in $cf_flags
658 CF_ADD_CFLAGS($cf_arg)
665 CF_VERBOSE(resulting CC: '$CC')
666 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
667 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
674 dnl ---------------------------------------------------------------------------
675 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
677 dnl Determine the default configuration into which we'll install ncurses. This
678 dnl can be overridden by the user's command-line options. There's two items to
680 dnl 1. the prefix (e.g., /usr)
681 dnl 2. the header files (e.g., /usr/include/ncurses)
682 dnl We'll look for a previous installation of ncurses and use the same defaults.
684 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
685 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
686 dnl programs from a vendor's.
687 AC_DEFUN([CF_CFG_DEFAULTS],
688 [AC_REQUIRE([AC_PROG_FGREP])dnl
690 AC_MSG_CHECKING(for prefix)
691 if test "x$prefix" = "xNONE" ; then
692 case "$cf_cv_system_name" in
693 # non-vendor systems don't have a conflict
694 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
697 (*) prefix=$ac_default_prefix
701 AC_MSG_RESULT($prefix)
703 if test "x$prefix" = "xNONE" ; then
704 AC_MSG_CHECKING(for default include-directory)
705 test -n "$verbose" && echo 1>&AC_FD_MSG
708 "$includedir/ncurses" \
710 "$prefix/include/ncurses" \
712 /usr/local/include/ncurses \
716 cf_dir=`eval echo "$cf_symbol"`
717 if test -f "$cf_dir/curses.h" ; then
718 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
719 includedir="$cf_symbol"
720 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
724 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
726 AC_MSG_RESULT($includedir)
729 dnl ---------------------------------------------------------------------------
730 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
732 dnl Check if we're accidentally using a cache from a different machine.
733 dnl Derive the system name, as a check for reusing the autoconf cache.
735 dnl If we've packaged config.guess and config.sub, run that (since it does a
736 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
737 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
738 dnl which is useful in cross-compiles.
740 dnl Note: we would use $ac_config_sub, but that is one of the places where
741 dnl autoconf 2.5x broke compatibility with autoconf 2.13
742 AC_DEFUN([CF_CHECK_CACHE],
744 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
745 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
746 system_name="$host_os"
748 system_name="`(uname -s -r) 2>/dev/null`"
749 if test -z "$system_name" ; then
750 system_name="`(hostname) 2>/dev/null`"
753 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
754 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
756 test -z "$system_name" && system_name="$cf_cv_system_name"
757 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
759 if test ".$system_name" != ".$cf_cv_system_name" ; then
760 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
761 AC_MSG_ERROR("Please remove config.cache and try again.")
764 dnl ---------------------------------------------------------------------------
765 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
766 dnl ---------------------
767 AC_DEFUN([CF_CHECK_GNAT_VERSION],
769 AC_REQUIRE([CF_GNAT_VERSION])
770 case "$cf_cv_gnat_version" in
771 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
772 cf_cv_prog_gnat_correct=yes
775 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
776 cf_cv_prog_gnat_correct=no
780 dnl ---------------------------------------------------------------------------
781 dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19
783 dnl Check if libssp is needed, e.g., to work around misconfigured libraries
784 dnl used in cross-compiling to MinGW.
785 AC_DEFUN([CF_CHECK_LIBSSP],[
786 AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[
788 #include <sys/types.h>
791 DIR *dp = opendir(".");
792 ],cf_cv_need_libssp=no,[
796 #include <sys/types.h>
799 DIR *dp = opendir(".");
800 ],cf_cv_need_libssp=yes,
801 cf_cv_need_libssp=maybe)
806 if test "x$cf_cv_need_libssp" = xyes
811 dnl ---------------------------------------------------------------------------
812 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
813 dnl -----------------
814 dnl Check if the given compiler is really clang. clang's C driver defines
815 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
816 dnl not ignore some gcc options.
818 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
819 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
820 dnl the wrappers for gcc and g++ warnings.
822 dnl $1 = GCC (default) or GXX
823 dnl $2 = CLANG_COMPILER (default)
824 dnl $3 = CFLAGS (default) or CXXFLAGS
825 AC_DEFUN([CF_CLANG_COMPILER],[
826 ifelse([$2],,CLANG_COMPILER,[$2])=no
828 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
829 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
830 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
836 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
838 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
839 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
844 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
846 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
847 AC_MSG_WARN(replacing broken compiler alias $CC)
848 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
853 AC_MSG_CHECKING(version of $CC)
854 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.]].*//'`"
855 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
856 AC_MSG_RESULT($CLANG_VERSION)
858 for cf_clang_opt in \
860 -Wno-error=implicit-function-declaration
862 AC_MSG_CHECKING(if option $cf_clang_opt works)
863 cf_save_CFLAGS="$CFLAGS"
864 CFLAGS="$CFLAGS $cf_clang_opt"
866 #include <stdio.h>],[
867 printf("hello!\\n");],[
868 cf_clang_optok=yes],[
870 AC_MSG_RESULT($cf_clang_optok)
871 CFLAGS="$cf_save_CFLAGS"
872 if test "$cf_clang_optok" = yes; then
873 CF_VERBOSE(adding option $cf_clang_opt)
874 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
879 dnl ---------------------------------------------------------------------------
880 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
881 dnl -----------------
882 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
883 dnl character-strings.
885 dnl It is ambiguous because the specification accommodated the pre-ANSI
886 dnl compilers bundled by more than one vendor in lieu of providing a standard C
887 dnl compiler other than by costly add-ons. Because of this, the specification
888 dnl did not take into account the use of const for telling the compiler that
889 dnl string literals would be in readonly memory.
891 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
892 dnl let the compiler decide how to represent Xt's strings which were #define'd.
893 dnl That does not solve the problem of using the block of Xt's strings which
894 dnl are compiled into the library (and is less efficient than one might want).
896 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
897 dnl when compiling the library and compiling using the library, to tell the
898 dnl compiler that String is const.
899 AC_DEFUN([CF_CONST_X_STRING],
901 AC_REQUIRE([AC_PATH_XTRA])
903 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
908 #include <X11/Intrinsic.h>
910 [String foo = malloc(1); free((void*)foo)],[
912 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
915 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
916 #undef XTSTRINGDEFINES /* X11R5 and later */
918 #include <X11/Intrinsic.h>
919 ],[String foo = malloc(1); *foo = 0],[
920 cf_cv_const_x_string=no
922 cf_cv_const_x_string=yes
926 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
928 case "$cf_cv_const_x_string" in
930 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
933 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
939 dnl ---------------------------------------------------------------------------
940 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
941 dnl -----------------
942 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
943 dnl character-strings.
945 dnl It is ambiguous because the specification accommodated the pre-ANSI
946 dnl compilers bundled by more than one vendor in lieu of providing a standard C
947 dnl compiler other than by costly add-ons. Because of this, the specification
948 dnl did not take into account the use of const for telling the compiler that
949 dnl string literals would be in readonly memory.
951 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
952 dnl let the compiler decide how to represent Xt's strings which were #define'd.
953 dnl That does not solve the problem of using the block of Xt's strings which
954 dnl are compiled into the library (and is less efficient than one might want).
956 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
957 dnl when compiling the library and compiling using the library, to tell the
958 dnl compiler that String is const.
959 AC_DEFUN([CF_CONST_X_STRING],
961 AC_REQUIRE([AC_PATH_XTRA])
963 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
968 #include <X11/Intrinsic.h>
970 [String foo = malloc(1); free((void*)foo)],[
972 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
975 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
976 #undef XTSTRINGDEFINES /* X11R5 and later */
978 #include <X11/Intrinsic.h>
979 ],[String foo = malloc(1); *foo = 0],[
980 cf_cv_const_x_string=no
982 cf_cv_const_x_string=yes
986 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
988 case "$cf_cv_const_x_string" in
990 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
993 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
999 dnl ---------------------------------------------------------------------------
1000 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
1001 dnl ----------------
1002 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
1003 dnl variations of ncurses' installs.
1005 dnl $1 = ncurses when looking for ncurses, or is empty
1006 AC_DEFUN([CF_CURSES_HEADER],[
1007 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
1008 cf_cv_ncurses_header=none
1010 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
1011 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
1013 AC_TRY_COMPILE([#include <${cf_header}>],
1014 [initscr(); tgoto("?", 0,0)],
1015 [cf_cv_ncurses_header=$cf_header; break],[])
1019 if test "$cf_cv_ncurses_header" = none ; then
1020 AC_MSG_ERROR(No curses header-files found)
1023 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
1024 AC_CHECK_HEADERS($cf_cv_ncurses_header)
1026 dnl ---------------------------------------------------------------------------
1027 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1029 dnl "dirname" is not portable, so we fake it with a shell script.
1030 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1031 dnl ---------------------------------------------------------------------------
1032 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1034 dnl You can always use "make -n" to see the actual options, but it is hard to
1035 dnl pick out/analyze warning messages when the compile-line is long.
1038 dnl ECHO_LT - symbol to control if libtool is verbose
1039 dnl ECHO_LD - symbol to prefix "cc -o" lines
1040 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1041 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1042 dnl ECHO_CC - symbol to put before any "cc" line
1044 AC_DEFUN([CF_DISABLE_ECHO],[
1045 AC_MSG_CHECKING(if you want to see long compiling messages)
1046 CF_ARG_DISABLE(echo,
1047 [ --disable-echo do not display "compiling" commands],
1050 ECHO_LD='@echo linking [$]@;'
1051 RULE_CC='@echo compiling [$]<'
1052 SHOW_CC='@echo compiling [$]@'
1061 AC_MSG_RESULT($enableval)
1068 dnl ---------------------------------------------------------------------------
1069 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1070 dnl ------------------------
1071 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1072 AC_MSG_CHECKING(if we want to use GNAT projects)
1073 CF_ARG_DISABLE(gnat-projects,
1074 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1075 [enable_gnat_projects=no],
1076 [enable_gnat_projects=yes])
1077 AC_MSG_RESULT($enable_gnat_projects)
1079 dnl ---------------------------------------------------------------------------
1080 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
1081 dnl -----------------------
1082 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
1083 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1084 dnl an unconditional feature.
1085 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1087 AC_MSG_CHECKING(if you want broken-linker support code)
1088 AC_ARG_ENABLE(broken_linker,
1089 [ --enable-broken_linker compile with broken-linker support code],
1090 [with_broken_linker=$enableval],
1091 [with_broken_linker=no])
1092 AC_MSG_RESULT($with_broken_linker)
1094 : "${BROKEN_LINKER:=0}"
1095 if test "x$with_broken_linker" = xyes ; then
1096 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1099 AC_SUBST(BROKEN_LINKER)
1101 dnl ---------------------------------------------------------------------------
1102 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1103 dnl ------------------
1104 dnl Configure-option to enable gcc warnings
1106 dnl $1 = extra options to add, if supported
1107 dnl $2 = option for checking attributes. By default, this is done when
1108 dnl warnings are enabled. For other values:
1109 dnl yes: always do this, e.g., to use in generated library-headers
1110 dnl no: never do this
1111 AC_DEFUN([CF_ENABLE_WARNINGS],[
1112 if test "$GCC" = yes || test "$GXX" = yes
1114 CF_FIX_WARNINGS(CFLAGS)
1115 CF_FIX_WARNINGS(CPPFLAGS)
1116 CF_FIX_WARNINGS(LDFLAGS)
1117 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1118 CF_ARG_ENABLE(warnings,
1119 [ --enable-warnings test: turn on gcc compiler warnings],
1120 [enable_warnings=yes],
1121 [enable_warnings=no])
1122 AC_MSG_RESULT($enable_warnings)
1123 if test "$enable_warnings" = "yes"
1125 ifelse($2,,[CF_GCC_ATTRIBUTES])
1128 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1131 dnl ---------------------------------------------------------------------------
1132 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1134 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1135 dnl prefer a standard location, and use -L options only if we do not find the
1136 dnl library in the standard library location(s).
1137 dnl $1 = library name
1138 dnl $2 = library class, usually the same as library name
1140 dnl $4 = code fragment to compile/link
1141 dnl $5 = corresponding function-name
1142 dnl $6 = flag, nonnull if failure should not cause an error-exit
1144 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1145 dnl to use a -L option.
1146 AC_DEFUN([CF_FIND_LIBRARY],
1148 eval 'cf_cv_have_lib_'"$1"'=no'
1151 eval 'cf_cv_have_lib_'"$1"'=yes',[
1152 cf_save_LIBS="$LIBS"
1153 AC_MSG_CHECKING(for $5 in -l$1)
1155 AC_TRY_LINK([$3],[$4],
1157 eval 'cf_cv_have_lib_'"$1"'=yes'
1160 CF_LIBRARY_PATH(cf_search,$2)
1161 for cf_libdir in $cf_search
1163 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1164 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1165 AC_TRY_LINK([$3],[$4],
1167 eval 'cf_cv_have_lib_'"$1"'=yes'
1170 LIBS="$cf_save_LIBS"])
1174 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1176 if test "$cf_found_library" = no ; then
1177 AC_MSG_ERROR(Cannot link $1 library)
1181 dnl ---------------------------------------------------------------------------
1182 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1184 dnl Find a library (specifically the linkage used in the code fragment),
1185 dnl searching for it if it is not already in the library path.
1186 dnl See also CF_ADD_SEARCHPATH.
1188 dnl Parameters (4-on are optional):
1189 dnl $1 = headers for library entrypoint
1190 dnl $2 = code fragment for library entrypoint
1191 dnl $3 = the library name without the "-l" option or ".so" suffix.
1192 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1193 dnl $5 = action to perform if not successful
1194 dnl $6 = module name, if not the same as the library name
1195 dnl $7 = extra libraries
1197 dnl Sets these variables:
1198 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1199 dnl $cf_cv_header_path_$3 - include-directory if needed
1200 dnl $cf_cv_library_path_$3 - library-directory if needed
1201 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1202 AC_DEFUN([CF_FIND_LINKAGE],[
1204 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1205 # will be set on completion of the AC_TRY_LINK below.
1206 cf_cv_header_path_$3=
1207 cf_cv_library_path_$3=
1209 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1211 cf_save_LIBS="$LIBS"
1213 AC_TRY_LINK([$1],[$2],[
1214 cf_cv_find_linkage_$3=yes
1215 cf_cv_header_path_$3=/usr/include
1216 cf_cv_library_path_$3=/usr/lib
1219 LIBS="-l$3 $7 $cf_save_LIBS"
1221 AC_TRY_LINK([$1],[$2],[
1222 cf_cv_find_linkage_$3=yes
1223 cf_cv_header_path_$3=/usr/include
1224 cf_cv_library_path_$3=/usr/lib
1225 cf_cv_library_file_$3="-l$3"
1227 cf_cv_find_linkage_$3=no
1228 LIBS="$cf_save_LIBS"
1230 CF_VERBOSE(find linkage for $3 library)
1231 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1233 cf_save_CPPFLAGS="$CPPFLAGS"
1234 cf_test_CPPFLAGS="$CPPFLAGS"
1236 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1237 for cf_cv_header_path_$3 in $cf_search
1239 if test -d "$cf_cv_header_path_$3" ; then
1240 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1241 CPPFLAGS="$cf_save_CPPFLAGS"
1242 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1243 AC_TRY_COMPILE([$1],[$2],[
1244 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1245 cf_cv_find_linkage_$3=maybe
1246 cf_test_CPPFLAGS="$CPPFLAGS"
1248 CPPFLAGS="$cf_save_CPPFLAGS"
1253 if test "$cf_cv_find_linkage_$3" = maybe ; then
1255 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1257 cf_save_LIBS="$LIBS"
1258 cf_save_LDFLAGS="$LDFLAGS"
1261 CPPFLAGS="$cf_test_CPPFLAGS"
1262 LIBS="-l$3 $7 $cf_save_LIBS"
1263 AC_TRY_LINK([$1],[$2],[
1264 CF_VERBOSE(... found $3 library in system)
1265 cf_cv_find_linkage_$3=yes])
1266 CPPFLAGS="$cf_save_CPPFLAGS"
1267 LIBS="$cf_save_LIBS"
1270 if test "$cf_cv_find_linkage_$3" != yes ; then
1271 CF_LIBRARY_PATH(cf_search,$3)
1272 for cf_cv_library_path_$3 in $cf_search
1274 if test -d "$cf_cv_library_path_$3" ; then
1275 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1276 CPPFLAGS="$cf_test_CPPFLAGS"
1277 LIBS="-l$3 $7 $cf_save_LIBS"
1278 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1279 AC_TRY_LINK([$1],[$2],[
1280 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1281 cf_cv_find_linkage_$3=yes
1282 cf_cv_library_file_$3="-l$3"
1284 CPPFLAGS="$cf_save_CPPFLAGS"
1285 LIBS="$cf_save_LIBS"
1286 LDFLAGS="$cf_save_LDFLAGS"
1290 CPPFLAGS="$cf_save_CPPFLAGS"
1291 LDFLAGS="$cf_save_LDFLAGS"
1295 cf_cv_find_linkage_$3=no
1300 LIBS="$cf_save_LIBS"
1302 if test "$cf_cv_find_linkage_$3" = yes ; then
1304 CF_ADD_INCDIR($cf_cv_header_path_$3)
1305 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1309 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1312 dnl ---------------------------------------------------------------------------
1313 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1314 dnl -----------------
1315 dnl make ADAFLAGS consistent with CFLAGS
1316 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1317 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1325 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1326 CF_ADD_ADAFLAGS($cf_O_flag)
1329 AC_MSG_RESULT($ADAFLAGS)
1331 dnl ---------------------------------------------------------------------------
1332 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1334 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1335 dnl "-Werror" flags can interfere with configure-checks. Those go into
1338 dnl $1 = variable name to repair
1339 define([CF_FIX_WARNINGS],[
1340 if test "$GCC" = yes || test "$GXX" = yes
1344 CF_VERBOSE(repairing $1: [$]$1)
1346 for cf_temp_scan in [$]$1
1348 case "x$cf_temp_scan" in
1350 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1353 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1358 CF_VERBOSE(... fixed [$]$1)
1359 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1363 AC_SUBST(EXTRA_CFLAGS)
1365 dnl ---------------------------------------------------------------------------
1366 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1367 dnl -----------------
1368 dnl Test for availability of useful gcc __attribute__ directives to quiet
1369 dnl compiler warnings. Though useful, not all are supported -- and contrary
1370 dnl to documentation, unrecognized directives cause older compilers to barf.
1371 AC_DEFUN([CF_GCC_ATTRIBUTES],
1372 [AC_REQUIRE([AC_PROG_FGREP])dnl
1373 AC_REQUIRE([CF_C11_NORETURN])dnl
1375 if test "$GCC" = yes || test "$GXX" = yes
1377 cat > conftest.i <<EOF
1379 #define GCC_PRINTF 0
1384 #ifndef GCC_NORETURN
1385 #define GCC_NORETURN /* nothing */
1388 #define GCC_UNUSED /* nothing */
1391 if test "$GCC" = yes
1393 AC_CHECKING([for $CC __attribute__ directives])
1394 cat > "conftest.$ac_ext" <<EOF
1395 #line __oline__ "${as_me:-configure}"
1396 #include "confdefs.h"
1397 #include "conftest.h"
1398 #include "conftest.i"
1400 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1402 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1405 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1407 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1409 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1410 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1411 extern GCC_NORETURN void foo(void);
1412 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1414 cf_printf_attribute=no
1415 cf_scanf_attribute=no
1416 for cf_attribute in scanf printf unused noreturn
1418 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1419 cf_directive="__attribute__(($cf_attribute))"
1420 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1422 case "$cf_attribute" in
1424 cf_printf_attribute=yes
1425 cat >conftest.h <<EOF
1426 #define GCC_$cf_ATTRIBUTE 1
1430 cf_scanf_attribute=yes
1431 cat >conftest.h <<EOF
1432 #define GCC_$cf_ATTRIBUTE 1
1436 cat >conftest.h <<EOF
1437 #define GCC_$cf_ATTRIBUTE $cf_directive
1442 if AC_TRY_EVAL(ac_compile); then
1443 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1444 cat conftest.h >>confdefs.h
1445 case "$cf_attribute" in
1447 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1450 cf_value='/* nothing */'
1451 if test "$cf_printf_attribute" != no ; then
1452 cf_value='__attribute__((format(printf,fmt,var)))'
1453 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1455 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1458 cf_value='/* nothing */'
1459 if test "$cf_scanf_attribute" != no ; then
1460 cf_value='__attribute__((format(scanf,fmt,var)))'
1461 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1463 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1466 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1472 ${FGREP-fgrep} define conftest.i >>confdefs.h
1477 dnl ---------------------------------------------------------------------------
1478 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1480 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1481 dnl compatible), attempt to determine if icc/clang is actually used.
1482 AC_DEFUN([CF_GCC_VERSION],[
1483 AC_REQUIRE([AC_PROG_CC])
1485 if test "$GCC" = yes ; then
1486 AC_MSG_CHECKING(version of $CC)
1487 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.]].*//'`"
1488 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1489 AC_MSG_RESULT($GCC_VERSION)
1491 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1492 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1494 dnl ---------------------------------------------------------------------------
1495 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1497 dnl Check if the compiler supports useful warning options. There's a few that
1498 dnl we don't use, simply because they're too noisy:
1500 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1501 dnl -Winline (usually not worthwhile)
1502 dnl -Wredundant-decls (system headers make this too noisy)
1503 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1504 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1505 dnl is enabled for ncurses using "--enable-const".
1509 dnl $1 is an optional list of gcc warning flags that a particular
1510 dnl application might want to use, e.g., "no-unused" for
1513 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1515 AC_DEFUN([CF_GCC_WARNINGS],
1517 AC_REQUIRE([CF_GCC_VERSION])
1518 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1519 cat > "conftest.$ac_ext" <<EOF
1520 #line __oline__ "${as_me:-configure}"
1521 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1523 if test "$INTEL_COMPILER" = yes
1525 # The "-wdXXX" options suppress warnings:
1526 # remark #1419: external declaration in primary source file
1527 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1528 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1529 # remark #193: zero used for undefined preprocessing identifier
1530 # remark #593: variable "curs_sb_left_arrow" was set but never used
1531 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1532 # remark #869: parameter "tw" was never referenced
1533 # remark #981: operands are evaluated in unspecified order
1534 # warning #279: controlling expression is constant
1536 AC_CHECKING([for $CC warning options])
1537 cf_save_CFLAGS="$CFLAGS"
1538 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1550 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1551 if AC_TRY_EVAL(ac_compile); then
1552 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1553 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1556 CFLAGS="$cf_save_CFLAGS"
1557 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1559 AC_CHECKING([for $CC warning options])
1560 cf_save_CFLAGS="$CFLAGS"
1562 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1563 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1564 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1565 for cf_opt in W Wall \
1566 Wbad-function-cast \
1569 Wdeclaration-after-statement \
1572 Wmissing-declarations \
1573 Wmissing-prototypes \
1577 Wstrict-prototypes \
1578 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1580 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1581 if AC_TRY_EVAL(ac_compile); then
1582 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1585 case "$GCC_VERSION" in
1587 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1592 case "$GCC_VERSION" in
1594 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1599 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1602 CFLAGS="$cf_save_CFLAGS"
1606 AC_SUBST(EXTRA_CFLAGS)
1608 dnl ---------------------------------------------------------------------------
1609 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1610 dnl -----------------
1611 AC_DEFUN([CF_GNATPREP_OPT_T],[
1612 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1613 cf_cv_gnatprep_opt_t=no
1614 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1616 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1617 AC_SUBST(GNATPREP_OPTS)
1619 dnl ---------------------------------------------------------------------------
1620 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1621 dnl ----------------
1622 AC_DEFUN([CF_GNAT_GENERICS],
1624 AC_REQUIRE([CF_GNAT_VERSION])
1626 AC_MSG_CHECKING(if GNAT supports generics)
1627 case "$cf_cv_gnat_version" in
1628 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1629 cf_gnat_generics=yes
1635 AC_MSG_RESULT($cf_gnat_generics)
1637 if test "$cf_gnat_generics" = yes
1639 cf_compile_generics=generics
1640 cf_generic_objects="\${GENOBJS}"
1642 cf_compile_generics=
1646 AC_SUBST(cf_compile_generics)
1647 AC_SUBST(cf_generic_objects)
1649 dnl ---------------------------------------------------------------------------
1650 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1651 dnl ----------------
1652 dnl GNAT projects are configured with ".gpr" project files.
1653 dnl GNAT libraries are a further development, using the project feature.
1654 AC_DEFUN([CF_GNAT_PROJECTS],
1656 AC_REQUIRE([CF_GNAT_VERSION])
1657 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1659 cf_gnat_libraries=no
1662 if test "$enable_gnat_projects" != no ; then
1663 AC_MSG_CHECKING(if GNAT supports project files)
1664 case "$cf_cv_gnat_version" in
1668 case "$cf_cv_system_name" in
1672 rm -rf ./conftest* ./*~conftest*
1673 if mkdir conftest.src conftest.bin conftest.lib
1676 rm -rf ./conftest* ./*~conftest*
1677 cat >>library.gpr <<CF_EOF
1679 Kind := External ("LIB_KIND");
1680 for Library_Name use "ConfTest";
1681 for Object_Dir use ".";
1682 for Library_ALI_Dir use External("LIBRARY_DIR");
1683 for Library_Version use External ("SONAME");
1684 for Library_Kind use Kind;
1685 for Library_Dir use External("BUILD_DIR");
1686 Source_Dir := External ("SOURCE_DIR");
1687 for Source_Dirs use (Source_Dir);
1690 cat >>confpackage.ads <<CF_EOF
1691 package ConfPackage is
1695 cat >>confpackage.adb <<CF_EOF
1697 package body ConfPackage is
1698 procedure conftest is
1700 Text_IO.Put ("Hello World");
1705 if ( "$cf_ada_make" $ADAFLAGS \
1707 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1708 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1709 -XSOURCE_DIR="`pwd`" \
1710 -XSONAME=libConfTest.so.1 \
1711 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1712 cf_gnat_projects=yes
1716 if test -f conftest.lib/confpackage.ali
1718 cf_gnat_libraries=yes
1720 rm -rf ./conftest* ./*~conftest*
1725 AC_MSG_RESULT($cf_gnat_projects)
1726 fi # enable_gnat_projects
1728 if test "$cf_gnat_projects" = yes
1730 AC_MSG_CHECKING(if GNAT supports libraries)
1731 AC_MSG_RESULT($cf_gnat_libraries)
1734 USE_OLD_MAKERULES=""
1735 USE_GNAT_PROJECTS="#"
1736 USE_GNAT_MAKE_GPR="#"
1737 USE_GNAT_GPRBUILD="#"
1739 if test "$cf_gnat_projects" = yes
1741 USE_OLD_MAKERULES="#"
1742 USE_GNAT_PROJECTS=""
1743 if test "$cf_cv_VERSION_GPRBUILD" != no
1745 USE_GNAT_GPRBUILD=""
1746 elif test "$cf_cv_VERSION_GNATMAKE" != no
1748 USE_GNAT_MAKE_GPR=""
1750 AC_MSG_WARN(use old makefile rules since tools are missing)
1754 if test "$cf_gnat_libraries" = yes
1756 USE_GNAT_LIBRARIES=""
1758 USE_GNAT_LIBRARIES="#"
1761 AC_SUBST(USE_OLD_MAKERULES)
1762 AC_SUBST(USE_GNAT_PROJECTS)
1763 AC_SUBST(USE_GNAT_LIBRARIES)
1764 AC_SUBST(USE_GNAT_MAKE_GPR)
1765 AC_SUBST(USE_GNAT_GPRBUILD)
1767 dnl ---------------------------------------------------------------------------
1768 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1770 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1771 dnl is noted that gnat may compile a tasking unit even for configurations which
1772 dnl fail at runtime.
1773 AC_DEFUN([CF_GNAT_SIGINT],[
1774 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1775 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1779 pragma Warnings (Off); -- the next pragma exists since 3.11p
1780 pragma Unreserve_All_Interrupts;
1781 pragma Warnings (On);
1783 protected Process is
1785 function Continue return Boolean;
1786 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1788 Done : Boolean := False;
1792 [package body ConfTest is
1793 protected body Process is
1798 function Continue return Boolean is
1804 [cf_cv_gnat_sigint=yes],
1805 [cf_cv_gnat_sigint=no])])
1807 if test "$cf_cv_gnat_sigint" = yes ; then
1812 AC_SUBST(USE_GNAT_SIGINT)
1814 dnl ---------------------------------------------------------------------------
1815 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1816 dnl ----------------
1817 dnl Verify that a test program compiles/links with GNAT.
1818 dnl $cf_ada_make is set to the program that compiles/links
1819 dnl $ADAFLAGS may be set to the GNAT flags.
1821 dnl $1 is the text of the spec
1822 dnl $2 is the text of the body
1823 dnl $3 is the shell command to execute if successful
1824 dnl $4 is the shell command to execute if not successful
1825 AC_DEFUN([CF_GNAT_TRY_LINK],
1827 rm -rf ./conftest* ./*~conftest*
1828 cat >>conftest.ads <<CF_EOF
1831 cat >>conftest.adb <<CF_EOF
1834 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1835 ifelse($3,, :,[ $3])
1839 rm -rf ./conftest* ./*~conftest*
1841 dnl ---------------------------------------------------------------------------
1842 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1844 dnl Verify that a test program compiles and runs with GNAT
1845 dnl $cf_ada_make is set to the program that compiles/links
1846 dnl $ADAFLAGS may be set to the GNAT flags.
1848 dnl $1 is the text of the spec
1849 dnl $2 is the text of the body
1850 dnl $3 is the shell command to execute if successful
1851 dnl $4 is the shell command to execute if not successful
1852 AC_DEFUN([CF_GNAT_TRY_RUN],
1854 rm -rf ./conftest* ./*~conftest*
1855 cat >>conftest.ads <<CF_EOF
1858 cat >>conftest.adb <<CF_EOF
1861 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1862 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1863 ifelse($3,, :,[ $3])
1870 rm -rf ./conftest* ./*~conftest*
1872 dnl ---------------------------------------------------------------------------
1873 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1875 dnl $1 = cache variable to update
1876 dnl $2 = program name
1877 dnl Verify version of GNAT or related tool
1878 AC_DEFUN([CF_GNAT_VERSION],
1880 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1881 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1882 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1883 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1885 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1886 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1888 dnl ---------------------------------------------------------------------------
1889 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1891 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1892 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1893 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1894 dnl since it is interwoven with GNU extensions.
1896 dnl Well, yes we could work around it...
1899 dnl $1 is the nominal value for _XOPEN_SOURCE
1900 AC_DEFUN([CF_GNU_SOURCE],
1902 cf_gnu_xopen_source=ifelse($1,,500,$1)
1904 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1905 AC_TRY_COMPILE([#include <sys/types.h>],[
1906 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1908 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1911 # error not GNU C library
1913 [cf_cv_gnu_library=yes],
1914 [cf_cv_gnu_library=no])
1917 if test x$cf_cv_gnu_library = xyes; then
1919 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1920 # was changed to help a little. newlib incorporated the change about 4
1922 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1924 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1925 AC_TRY_COMPILE([#include <sys/types.h>],[
1926 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1928 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1931 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1933 [cf_cv_gnu_library_219=yes],
1934 [cf_cv_gnu_library_219=no])
1938 if test "x$cf_cv_gnu_library_219" = xyes; then
1940 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1941 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1944 #include <sys/types.h>
1946 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1949 # error GNU C library is too old
1951 [cf_cv_gnu_dftsrc_219=yes],
1952 [cf_cv_gnu_dftsrc_219=no])
1954 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1956 cf_cv_gnu_dftsrc_219=maybe
1959 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1961 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1962 AC_TRY_COMPILE([#include <sys/types.h>],[
1963 #ifndef _XOPEN_SOURCE
1964 #error expected _XOPEN_SOURCE to be defined
1966 [cf_cv_gnu_source=no],
1967 [cf_save="$CPPFLAGS"
1968 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1969 AC_TRY_COMPILE([#include <sys/types.h>],[
1970 #ifdef _XOPEN_SOURCE
1971 #error expected _XOPEN_SOURCE to be undefined
1973 [cf_cv_gnu_source=no],
1974 [cf_cv_gnu_source=yes])
1979 if test "$cf_cv_gnu_source" = yes
1981 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1982 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1983 AC_TRY_COMPILE([#include <sys/types.h>],[
1984 #ifdef _DEFAULT_SOURCE
1985 #error expected _DEFAULT_SOURCE to be undefined
1987 [cf_cv_default_source=no],
1988 [cf_cv_default_source=yes])
1990 if test "$cf_cv_default_source" = yes
1992 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1999 dnl ---------------------------------------------------------------------------
2000 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2002 dnl Construct a search-list of directories for a nonstandard header-file
2005 dnl $1 = the variable to return as result
2006 dnl $2 = the package name
2007 AC_DEFUN([CF_HEADER_PATH],
2011 # collect the current set of include-directories from compiler flags
2012 cf_header_path_list=""
2013 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2014 for cf_header_path in $CPPFLAGS $CFLAGS
2016 case "$cf_header_path" in
2018 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2019 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2020 cf_header_path_list="$cf_header_path_list [$]$1"
2026 # add the variations for the package we are looking for
2027 CF_SUBDIR_PATH($1,$2,include)
2029 test "$includedir" != NONE && \
2030 test "$includedir" != "/usr/include" && \
2031 test -d "$includedir" && {
2032 test -d "$includedir" && $1="[$]$1 $includedir"
2033 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2036 test "$oldincludedir" != NONE && \
2037 test "$oldincludedir" != "/usr/include" && \
2038 test -d "$oldincludedir" && {
2039 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2040 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2043 $1="[$]$1 $cf_header_path_list"
2045 dnl ---------------------------------------------------------------------------
2046 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2048 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2049 AC_DEFUN([CF_HELP_MESSAGE],
2050 [CF_ACVERSION_CHECK(2.53,[],[
2051 AC_DIVERT_HELP($1)])dnl
2053 dnl ---------------------------------------------------------------------------
2054 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
2056 dnl Construct the list of include-options according to whether we're building
2057 dnl in the source directory or using '--srcdir=DIR' option.
2058 AC_DEFUN([CF_INCLUDE_DIRS],
2060 if test "$srcdir" != "."; then
2061 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
2063 CPPFLAGS="-I../include $CPPFLAGS"
2064 if test "$srcdir" != "."; then
2065 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
2067 CPPFLAGS="-I. $CPPFLAGS"
2070 dnl ---------------------------------------------------------------------------
2071 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2073 dnl prompt for/fill-in useful install-program options
2074 AC_DEFUN([CF_INSTALL_OPTS],
2080 dnl ---------------------------------------------------------------------------
2081 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2082 dnl ----------------
2083 dnl Almost all "install" programs default to the current user's ownership.
2084 dnl Almost - MINIX is an exception.
2085 AC_DEFUN([CF_INSTALL_OPT_O],
2087 AC_MSG_CHECKING(if install needs to be told about ownership)
2088 case `$ac_config_guess` in
2097 AC_MSG_RESULT($with_install_o)
2098 if test "x$with_install_o" = xyes
2100 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'`"
2105 AC_SUBST(INSTALL_OPT_O)
2107 dnl ---------------------------------------------------------------------------
2108 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2109 dnl ----------------
2110 dnl Some install-programs accept a "-p" option to preserve file modification
2111 dnl timestamps. That can be useful as an install option, as well as a way to
2112 dnl avoid the need for ranlib after copying a static archive.
2113 AC_DEFUN([CF_INSTALL_OPT_P],
2115 : "${INSTALL:=install}"
2116 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2121 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2123 if test -f conftest.out/conftest.in
2125 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2126 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2127 if test -s conftest.err
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2144 dnl ----------------
2145 dnl By default, we should strip executables which are installed, but leave the
2146 dnl ability to suppress that for unit-testing.
2147 AC_DEFUN([CF_INSTALL_OPT_S],
2149 AC_MSG_CHECKING(if you want to install stripped executables)
2150 CF_ARG_DISABLE(stripping,
2151 [ --disable-stripping do not strip (debug info) installed executables],
2152 [enable_stripping=no],
2153 [enable_stripping=yes])
2154 AC_MSG_RESULT($enable_stripping)
2156 if test "$enable_stripping" = yes
2162 AC_SUBST(INSTALL_OPT_S)
2164 dnl ---------------------------------------------------------------------------
2165 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2166 dnl -----------------
2167 dnl Check if the given compiler is really the Intel compiler for Linux. It
2168 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2169 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2171 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2172 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2173 dnl the wrappers for gcc and g++ warnings.
2175 dnl $1 = GCC (default) or GXX
2176 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2177 dnl $3 = CFLAGS (default) or CXXFLAGS
2178 AC_DEFUN([CF_INTEL_COMPILER],[
2179 AC_REQUIRE([AC_CANONICAL_HOST])
2180 ifelse([$2],,INTEL_COMPILER,[$2])=no
2182 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2185 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2186 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2187 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2189 #ifdef __INTEL_COMPILER
2193 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2194 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2196 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2197 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2202 dnl ---------------------------------------------------------------------------
2203 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2205 dnl Add checks for large file support.
2206 AC_DEFUN([CF_LARGEFILE],[
2207 ifdef([AC_FUNC_FSEEKO],[
2209 if test "$enable_largefile" != no ; then
2212 # Normally we would collect these definitions in the config.h,
2213 # but (like _XOPEN_SOURCE), some environments rely on having these
2214 # defined before any of the system headers are included. Another
2215 # case comes up with C++, e.g., on AIX the compiler compiles the
2216 # header files by themselves before looking at the body files it is
2217 # told to compile. For ncurses, those header files do not include
2219 if test "$ac_cv_sys_large_files" != no
2221 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2223 if test "$ac_cv_sys_largefile_source" != no
2225 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2227 if test "$ac_cv_sys_file_offset_bits" != no
2229 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2232 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2234 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2235 #include <sys/types.h>
2238 /* if transitional largefile support is setup, this is true */
2239 extern struct dirent64 * readdir(DIR *);
2240 struct dirent64 *x = readdir((DIR *)0);
2241 struct dirent *y = readdir((DIR *)0);
2245 [cf_cv_struct_dirent64=yes],
2246 [cf_cv_struct_dirent64=no])
2248 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2252 dnl ---------------------------------------------------------------------------
2253 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2255 dnl For the given system and compiler, find the compiler flags to pass to the
2256 dnl loader to use the "rpath" feature.
2257 AC_DEFUN([CF_LD_RPATH_OPT],
2259 AC_REQUIRE([CF_CHECK_CACHE])
2262 if test "x$cf_cv_enable_rpath" != xno
2264 AC_MSG_CHECKING(for an rpath option)
2265 case "$cf_cv_system_name" in
2267 if test "$GCC" = yes; then
2268 LD_RPATH_OPT="-Wl,-rpath,"
2270 LD_RPATH_OPT="-rpath "
2273 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2274 LD_RPATH_OPT="-Wl,-rpath,"
2276 (openbsd[[2-9]].*|mirbsd*)
2277 LD_RPATH_OPT="-Wl,-rpath,"
2280 LD_RPATH_OPT="-rpath "
2283 LD_RPATH_OPT="-Wl,-rpath,"
2286 LD_RPATH_OPT="-rpath "
2294 AC_MSG_RESULT($LD_RPATH_OPT)
2296 case "x$LD_RPATH_OPT" in
2298 AC_MSG_CHECKING(if we need a space after rpath option)
2299 cf_save_LIBS="$LIBS"
2300 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2301 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2302 LIBS="$cf_save_LIBS"
2303 AC_MSG_RESULT($cf_rpath_space)
2304 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2309 dnl ---------------------------------------------------------------------------
2310 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2312 dnl Construct a search-list of directories for a nonstandard library-file
2315 dnl $1 = the variable to return as result
2316 dnl $2 = the package name
2317 AC_DEFUN([CF_LIBRARY_PATH],
2320 cf_library_path_list=""
2321 if test -n "${LDFLAGS}${LIBS}" ; then
2322 for cf_library_path in $LDFLAGS $LIBS
2324 case "$cf_library_path" in
2326 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2327 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2328 cf_library_path_list="$cf_library_path_list [$]$1"
2334 CF_SUBDIR_PATH($1,$2,lib)
2336 $1="$cf_library_path_list [$]$1"
2338 dnl ---------------------------------------------------------------------------
2339 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2341 dnl Compute the library-prefix for the given host system
2342 dnl $1 = variable to set
2343 define([CF_LIB_PREFIX],
2345 case "$cf_cv_system_name" in
2347 if test "$DFT_LWR_MODEL" = libtool; then
2356 (*) LIB_PREFIX='lib'
2359 ifelse($1,,,[$1=$LIB_PREFIX])
2360 AC_SUBST(LIB_PREFIX)
2362 dnl ---------------------------------------------------------------------------
2363 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2365 dnl Compute the library file-suffix from the given model name
2367 dnl $2 = variable to set (the nominal library suffix)
2368 dnl $3 = dependency variable to set (actual filename)
2369 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2370 AC_DEFUN([CF_LIB_SUFFIX],
2378 case "$cf_cv_system_name" in
2389 case "$cf_cv_system_name" in
2400 case "$cf_cv_system_name" in
2409 (cygwin*|msys*|mingw*)
2447 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2449 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2450 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2453 dnl ---------------------------------------------------------------------------
2454 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2456 dnl Compute the string to append to -library from the given model name
2458 dnl $2 = variable to set
2459 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2460 AC_DEFUN([CF_LIB_TYPE],
2466 (profile) $2='_p' ;;
2469 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2471 dnl ---------------------------------------------------------------------------
2472 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2473 dnl ----------------
2474 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2475 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2476 dnl have to provide wrappers for global tables to ensure they're linked
2478 AC_DEFUN([CF_LINK_DATAONLY],
2480 AC_MSG_CHECKING([if data-only library module links])
2481 AC_CACHE_VAL(cf_cv_link_dataonly,[
2483 cat >conftest.$ac_ext <<EOF
2484 #line __oline__ "configure"
2485 int testdata[[3]] = { 123, 456, 789 };
2487 if AC_TRY_EVAL(ac_compile) ; then
2488 mv conftest.o data.o && \
2489 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2491 rm -f conftest.$ac_ext data.o
2492 cat >conftest.$ac_ext <<EOF
2493 #line __oline__ "configure"
2497 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2499 extern int testdata[[3]];
2500 return testdata[[0]] == 123
2501 && testdata[[1]] == 456
2502 && testdata[[2]] == 789;
2506 if AC_TRY_EVAL(ac_compile); then
2507 mv conftest.o func.o && \
2508 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2510 rm -f conftest.$ac_ext func.o
2511 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2513 LIBS="conftest.a $LIBS"
2517 extern int testfunc();
2518 ${cf_cv_main_return:-return} (!testfunc());
2521 [cf_cv_link_dataonly=yes],
2522 [cf_cv_link_dataonly=no],
2523 [cf_cv_link_dataonly=unknown])
2526 AC_MSG_RESULT($cf_cv_link_dataonly)
2528 if test "$cf_cv_link_dataonly" = no ; then
2529 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2532 AC_SUBST(BROKEN_LINKER)
2535 dnl ---------------------------------------------------------------------------
2536 dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34
2538 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2539 dnl options to lower-levels. It is very useful for "make -n" -- if we have it.
2540 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2541 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2542 AC_DEFUN([CF_MAKEFLAGS],
2543 [AC_REQUIRE([AC_PROG_FGREP])dnl
2545 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2547 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2549 cat >cf_makeflags.tmp <<CF_EOF
2552 @ echo '.$cf_option'
2554 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2555 case "$cf_result" in
2557 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2558 case "$cf_result" in
2559 (.*CC=*) cf_cv_makeflags=
2561 (*) cf_cv_makeflags=$cf_option
2569 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2573 rm -f cf_makeflags.tmp
2576 AC_SUBST(cf_cv_makeflags)
2578 dnl ---------------------------------------------------------------------------
2579 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2581 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2582 dnl acts as a placeholder.
2584 dnl The ".PHONY" feature was proposed in 2011 here
2585 dnl https://www.austingroupbugs.net/view.php?id=523
2586 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2588 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2589 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2591 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2592 dnl date unspecified).
2594 dnl + It was adopted in NetBSD make in June 1995.
2596 dnl + The other BSD make programs are derived from the NetBSD make (and for
2597 dnl that reason are not actually different "implementations").
2599 dnl + Some features of NetBSD make were actually adapted from pmake, which
2600 dnl began as a modified GNU make starting in 1993.
2602 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2603 dnl GNU make extension, but is less well known than the BSD make.
2604 AC_DEFUN([CF_MAKE_PHONY],[
2605 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2608 mkdir conftest || exit 1
2610 cat >makefile <<'CF_EOF'
2614 @echo "** making [$]@ [$](DATA)"
2616 @echo "** making [$]@ [$](DATA)"
2618 @echo "** making [$]@ [$](DATA)"
2619 echo [$](DATA) > [$]@
2621 @echo "** making [$]@ [$](DATA)"
2622 echo [$](DATA) > [$]@
2624 for cf_data in 1 2 3
2626 ${MAKE:-make} always DATA=$cf_data
2627 ${MAKE:-make} once DATA=$cf_data
2628 ${MAKE:-make} -t always once
2629 if test -f always ; then
2630 echo "no (case 1)" > ../conftest.tmp
2631 elif test ! -f always.out ; then
2632 echo "no (case 2)" > ../conftest.tmp
2633 elif test ! -f once.out ; then
2634 echo "no (case 3)" > ../conftest.tmp
2635 elif ! cmp -s always.out once.out ; then
2636 echo "no (case 4)" > ../conftest.tmp
2637 diff always.out once.out
2639 cf_check="`cat always.out`"
2640 if test "x$cf_check" != "x$cf_data" ; then
2641 echo "no (case 5)" > ../conftest.tmp
2643 echo yes > ../conftest.tmp
2651 cf_cv_make_PHONY="`cat conftest.tmp`"
2656 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2657 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2658 AC_SUBST(MAKE_NO_PHONY)
2659 AC_SUBST(MAKE_PHONY)
2661 dnl ---------------------------------------------------------------------------
2662 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2664 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2665 dnl a monocase filesystem.
2666 AC_DEFUN([CF_MAKE_TAGS],[
2667 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2669 AC_CHECK_PROGS(CTAGS, exctags ctags)
2670 AC_CHECK_PROGS(ETAGS, exetags etags)
2672 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2674 if test "$cf_cv_mixedcase" = yes ; then
2675 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2680 if test "$MAKE_UPPER_TAGS" = yes ; then
2686 if test "$MAKE_LOWER_TAGS" = yes ; then
2695 AC_SUBST(MAKE_UPPER_TAGS)
2696 AC_SUBST(MAKE_LOWER_TAGS)
2698 dnl ---------------------------------------------------------------------------
2699 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2700 dnl ----------------------
2701 dnl Check if the file-system supports mixed-case filenames. If we're able to
2702 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2703 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2705 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2706 if test "$cross_compiling" = yes ; then
2707 case "$target_alias" in
2708 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2716 rm -f conftest CONFTEST
2718 if test -f CONFTEST ; then
2723 rm -f conftest CONFTEST
2726 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2728 dnl ---------------------------------------------------------------------------
2729 dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
2731 dnl Check for a working mkstemp. This creates two files, checks that they are
2732 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2733 AC_DEFUN([CF_MKSTEMP],[
2737 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2740 #include <sys/types.h>
2741 #ifdef HAVE_UNISTD_H
2747 #include <sys/stat.h>
2750 char *tmpl = "conftestXXXXXX";
2758 for (n = 0; n < 2; ++n) {
2759 strcpy(name[n], tmpl);
2760 if ((fd = mkstemp(name[n])) >= 0) {
2761 if (!strcmp(name[n], tmpl)
2762 || stat(name[n], &sb) != 0
2763 || (sb.st_mode & S_IFMT) != S_IFREG
2764 || (sb.st_mode & 077) != 0) {
2771 && !strcmp(name[0], name[1]))
2773 ${cf_cv_main_return:-return}(result);
2775 ],[cf_cv_func_mkstemp=yes
2776 ],[cf_cv_func_mkstemp=no
2777 ],[cf_cv_func_mkstemp=maybe])
2779 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2780 AC_CHECK_FUNC(mkstemp)
2782 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2783 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2786 dnl ---------------------------------------------------------------------------
2787 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2789 dnl Write a debug message to config.log, along with the line number in the
2790 dnl configure script.
2791 AC_DEFUN([CF_MSG_LOG],[
2792 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2794 dnl ---------------------------------------------------------------------------
2795 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2796 dnl ----------------
2797 dnl Configure an ncurses add-on, built outside the ncurses tree.
2798 AC_DEFUN([CF_NCURSES_ADDON],[
2799 AC_REQUIRE([CF_NCURSES_CONFIG])
2801 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2803 AC_MSG_CHECKING(if you want wide-character code)
2804 AC_ARG_ENABLE(widec,
2805 [ --enable-widec compile with wide-char/UTF-8 code],
2806 [with_widec=$enableval],
2808 AC_MSG_RESULT($with_widec)
2809 if test "$with_widec" = yes ; then
2811 CF_NCURSES_CONFIG(ncursesw)
2813 CF_NCURSES_CONFIG(ncurses)
2816 if test "$NCURSES_CONFIG_PKG" != none ; then
2817 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2819 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2820 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2821 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2823 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2824 if test -z "$cf_cv_abi_version"
2826 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2829 elif test "$NCURSES_CONFIG" != none ; then
2831 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2833 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2834 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2835 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2837 # ABI version is not available from headers
2838 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2842 for cf_name in MAJOR MINOR PATCH
2844 cat >conftest.$ac_ext <<CF_EOF
2845 #include <${cf_cv_ncurses_header:-curses.h}>
2846 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2848 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2850 if test -f conftest.out ; then
2851 cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
2852 eval NCURSES_$cf_name=\"$cf_result\"
2853 # cat conftest.$ac_ext
2858 cf_cv_abi_version=${NCURSES_MAJOR}
2862 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2864 dnl Show the computed version, for logging
2865 cf_cv_timestamp=`date`
2867 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2869 dnl We need these values in the generated headers
2870 AC_SUBST(NCURSES_MAJOR)
2871 AC_SUBST(NCURSES_MINOR)
2872 AC_SUBST(NCURSES_PATCH)
2874 dnl We need these values in the generated makefiles
2875 AC_SUBST(cf_cv_rel_version)
2876 AC_SUBST(cf_cv_abi_version)
2878 dnl FIXME - not needed for Ada95
2879 AC_SUBST(cf_cv_builtin_bool)
2880 AC_SUBST(cf_cv_header_stdbool_h)
2881 AC_SUBST(cf_cv_type_of_bool)dnl
2884 dnl ---------------------------------------------------------------------------
2885 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2886 dnl -------------------
2887 dnl Check if we can compile with ncurses' header file
2888 dnl $1 is the cache variable to set
2889 dnl $2 is the header-file to include
2890 dnl $3 is the root name (ncurses or ncursesw)
2891 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2893 ]ifelse($3,ncursesw,[
2894 #define _XOPEN_SOURCE_EXTENDED
2895 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2896 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2899 #ifdef NCURSES_VERSION
2900 ]ifelse($3,ncursesw,[
2905 printf("%s\\n", NCURSES_VERSION);
2917 dnl ---------------------------------------------------------------------------
2918 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2919 dnl -----------------
2920 dnl Tie together the configure-script macros for ncurses, preferring these in
2922 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2923 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2924 dnl c) just plain libraries
2926 dnl $1 is the root library name (default: "ncurses")
2927 AC_DEFUN([CF_NCURSES_CONFIG],[
2928 AC_REQUIRE([CF_PKG_CONFIG])
2929 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2930 cf_have_ncuconfig=no
2932 if test "x${PKG_CONFIG:=none}" != xnone; then
2933 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2934 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2937 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2938 cf_have_ncuconfig=unknown
2940 cf_save_CFLAGS="$CFLAGS"
2941 cf_save_CPPFLAGS="$CPPFLAGS"
2942 cf_save_LIBS="$LIBS"
2944 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2945 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2947 # while -W for passing linker flags is prevalent, it is not "standard".
2948 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2949 # incompatible _and_ non-standard -W option which gives an error. Work
2950 # around that pitfall.
2951 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2953 CF_ADD_CFLAGS($cf_pkg_cflags)
2954 CF_ADD_LIBS($cf_pkg_libs)
2956 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2957 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2958 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2960 { const char *xx = curses_version(); return (xx == 0); }],
2961 [cf_test_ncuconfig=yes],
2962 [cf_test_ncuconfig=no],
2963 [cf_test_ncuconfig=maybe])],
2964 [cf_test_ncuconfig=no])
2966 CFLAGS="$cf_save_CFLAGS"
2967 CPPFLAGS="$cf_save_CPPFLAGS"
2968 LIBS="$cf_save_LIBS"
2970 if test "x$cf_test_ncuconfig" != xyes; then
2971 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2972 cf_pkg_cflags="$cf_temp"
2973 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2974 cf_pkg_libs="$cf_temp"
2979 CF_APPEND_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_have_ncuconfig=yes],
2988 [cf_have_ncuconfig=no],
2989 [cf_have_ncuconfig=maybe])],
2990 [cf_have_ncuconfig=no])
2991 AC_MSG_RESULT($cf_have_ncuconfig)
2992 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2993 if test "$cf_have_ncuconfig" != "yes"
2995 CPPFLAGS="$cf_save_CPPFLAGS"
2996 LIBS="$cf_save_LIBS"
2997 NCURSES_CONFIG_PKG=none
2999 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3000 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
3006 NCURSES_CONFIG_PKG=none
3009 NCURSES_CONFIG_PKG=none
3012 if test "x$cf_have_ncuconfig" = "xno"; then
3013 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
3015 CF_ACVERSION_CHECK(2.52,
3016 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
3017 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
3019 if test "$NCURSES_CONFIG" != none ; then
3021 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
3022 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
3024 # even with config script, some packages use no-override for curses.h
3025 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
3027 dnl like CF_NCURSES_CPPFLAGS
3028 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3030 dnl like CF_NCURSES_LIBS
3031 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
3032 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3034 dnl like CF_NCURSES_VERSION
3035 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
3039 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
3040 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
3047 dnl ---------------------------------------------------------------------------
3048 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
3049 dnl -------------------
3050 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
3051 dnl the CPPFLAGS variable so we can include its header.
3053 dnl The header files may be installed as either curses.h, or ncurses.h (would
3054 dnl be obsolete, except that some packagers prefer this name to distinguish it
3055 dnl from a "native" curses implementation). If not installed for overwrite,
3056 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
3057 dnl /usr/include/ncurses), but someone may have installed overwriting the
3058 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
3059 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
3062 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
3063 dnl is already in the include-path, don't even bother with this, since we cannot
3064 dnl easily determine which file it is. In this case, it has to be <curses.h>.
3066 dnl The optional parameter gives the root name of the library, in case it is
3067 dnl not installed as the default curses library. That is how the
3068 dnl wide-character version of ncurses is installed.
3069 AC_DEFUN([CF_NCURSES_CPPFLAGS],
3070 [AC_REQUIRE([CF_WITH_CURSES_DIR])
3072 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
3073 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
3075 test -n "$cf_cv_curses_dir" && \
3076 test "$cf_cv_curses_dir" != "no" && { \
3077 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
3080 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
3081 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
3082 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
3083 for cf_header in $cf_header_list
3085 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
3086 test "$cf_cv_ncurses_h" != no && break
3093 # some applications need this, but should check for NCURSES_VERSION
3094 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3098 dnl ---------------------------------------------------------------------------
3099 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
3100 dnl -----------------
3101 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
3102 dnl variations of ncurses' installs.
3104 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
3105 AC_DEFUN([CF_NCURSES_HEADER],[
3107 if test "$cf_cv_ncurses_h" != no ; then
3108 cf_cv_ncurses_header=$cf_cv_ncurses_h
3111 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
3112 test -n "$verbose" && echo
3113 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
3114 test -n "$verbose" && echo "search path $cf_search"
3115 cf_save2_CPPFLAGS="$CPPFLAGS"
3116 for cf_incdir in $cf_search
3118 CF_ADD_INCDIR($cf_incdir)
3123 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
3124 if test "$cf_cv_ncurses_h2" != no ; then
3125 cf_cv_ncurses_h2=$cf_incdir/$cf_header
3126 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
3129 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
3131 CPPFLAGS="$cf_save2_CPPFLAGS"
3132 test "$cf_cv_ncurses_h2" != no && break
3134 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
3137 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
3138 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
3139 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
3140 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
3142 CF_ADD_INCDIR($cf_1st_incdir)
3146 # Set definitions to allow ifdef'ing for ncurses.h
3148 case "$cf_cv_ncurses_header" in
3150 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
3154 case "$cf_cv_ncurses_header" in
3155 (ncurses/curses.h|ncurses/ncurses.h)
3156 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
3158 (ncursesw/curses.h|ncursesw/ncurses.h)
3159 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
3164 dnl ---------------------------------------------------------------------------
3165 dnl CF_NCURSES_LIBS version: 21 updated: 2021/09/04 06:37:12
3167 dnl Look for the ncurses library. This is a little complicated on Linux,
3168 dnl because it may be linked with the gpm (general purpose mouse) library.
3169 dnl Some distributions have gpm linked with (bsd) curses, which makes it
3170 dnl unusable with ncurses. However, we don't want to link with gpm unless
3171 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
3172 dnl and the linker will record a dependency.
3174 dnl The optional parameter gives the root name of the library, in case it is
3175 dnl not installed as the default curses library. That is how the
3176 dnl wide-character version of ncurses is installed.
3177 AC_DEFUN([CF_NCURSES_LIBS],
3178 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3180 cf_nculib_root=ifelse($1,,ncurses,$1)
3181 # This works, except for the special case where we find gpm, but
3182 # ncurses is in a nonstandard location via $LIBS, and we really want
3185 cf_ncurses_SAVE="$LIBS"
3186 AC_CHECK_LIB(gpm,Gpm_Open,
3187 [AC_CHECK_LIB(gpm,initscr,
3188 [LIBS="$cf_ncurses_SAVE"],
3189 [cf_ncurses_LIBS="-lgpm"])])
3193 # This is only necessary if you are linking against an obsolete
3194 # version of ncurses (but it should do no harm, since it is static).
3195 if test "$cf_nculib_root" = ncurses ; then
3196 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3201 CF_ADD_LIBS($cf_ncurses_LIBS)
3203 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3205 CF_ADD_LIBS(-l$cf_nculib_root)
3207 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3208 [#include <${cf_cv_ncurses_header:-curses.h}>],
3213 if test -n "$cf_ncurses_LIBS" ; then
3214 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3215 cf_ncurses_SAVE="$LIBS"
3216 for p in $cf_ncurses_LIBS ; do
3217 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3218 if test "$q" != "$LIBS" ; then
3222 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3223 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3224 [AC_MSG_RESULT(yes)],
3226 LIBS="$cf_ncurses_SAVE"])
3229 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3230 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3232 dnl ---------------------------------------------------------------------------
3233 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
3234 dnl ------------------
3235 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3236 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3237 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3238 AC_DEFUN([CF_NCURSES_VERSION],
3240 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3241 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3242 cf_cv_ncurses_version=no
3244 rm -f "$cf_tempfile"
3246 #include <${cf_cv_ncurses_header:-curses.h}>
3250 FILE *fp = fopen("$cf_tempfile", "w");
3251 #ifdef NCURSES_VERSION
3252 # ifdef NCURSES_VERSION_PATCH
3253 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3255 fprintf(fp, "%s\\n", NCURSES_VERSION);
3259 fprintf(fp, "old\\n");
3264 ${cf_cv_main_return:-return}(0);
3266 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3268 # This will not work if the preprocessor splits the line after the
3269 # Autoconf token. The 'unproto' program does that.
3270 cat > "conftest.$ac_ext" <<EOF
3271 #include <${cf_cv_ncurses_header:-curses.h}>
3273 #ifdef NCURSES_VERSION
3274 Autoconf NCURSES_VERSION
3282 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3284 if test -f conftest.out ; then
3285 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3286 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3290 rm -f "$cf_tempfile"
3292 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3294 dnl ---------------------------------------------------------------------------
3295 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3297 dnl Compute the object-directory name from the given model name
3298 AC_DEFUN([CF_OBJ_SUBDIR],
3301 (libtool) $2='obj_lo' ;;
3302 (normal) $2='objects' ;;
3303 (debug) $2='obj_g' ;;
3304 (profile) $2='obj_p' ;;
3306 case "$cf_cv_system_name" in
3314 dnl ---------------------------------------------------------------------------
3315 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3317 dnl Provide a value for the $PATH and similar separator (or amend the value
3318 dnl as provided in autoconf 2.5x).
3319 AC_DEFUN([CF_PATHSEP],
3321 AC_MSG_CHECKING(for PATH separator)
3322 case "$cf_cv_system_name" in
3323 (os2*) PATH_SEPARATOR=';' ;;
3324 (*) ${PATH_SEPARATOR:=':'} ;;
3326 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3327 AC_SUBST(PATH_SEPARATOR)
3328 AC_MSG_RESULT($PATH_SEPARATOR)
3330 dnl ---------------------------------------------------------------------------
3331 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3333 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3334 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3335 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3336 dnl delayed evaluation of those symbols.
3337 AC_DEFUN([CF_PATH_SYNTAX],[
3338 if test "x$prefix" != xNONE; then
3339 cf_path_syntax="$prefix"
3341 cf_path_syntax="$ac_default_prefix"
3345 (.\[$]\(*\)*|.\'*\'*)
3349 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3351 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3355 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3360 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3363 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3367 dnl ---------------------------------------------------------------------------
3368 dnl CF_PKG_CONFIG version: 12 updated: 2021/10/10 20:18:09
3370 dnl Check for the package-config program, unless disabled by command-line.
3372 dnl Sets $PKG_CONFIG to the pathname of the pkg-config program.
3373 AC_DEFUN([CF_PKG_CONFIG],
3375 AC_MSG_CHECKING(if you want to use pkg-config)
3376 AC_ARG_WITH(pkg-config,
3377 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3378 [cf_pkg_config=$withval],
3379 [cf_pkg_config=yes])
3380 AC_MSG_RESULT($cf_pkg_config)
3382 case "$cf_pkg_config" in
3387 CF_ACVERSION_CHECK(2.52,
3388 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3389 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3396 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3397 if test "$PKG_CONFIG" != none ; then
3398 CF_PATH_SYNTAX(PKG_CONFIG)
3399 elif test "x$cf_pkg_config" != xno ; then
3400 AC_MSG_WARN(pkg-config is not installed)
3403 AC_SUBST(PKG_CONFIG)
3405 dnl ---------------------------------------------------------------------------
3406 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3407 dnl -----------------
3408 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3410 dnl POSIX.1-1990 _POSIX_SOURCE
3411 dnl POSIX.1-1990 and _POSIX_SOURCE and
3412 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3414 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3415 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3416 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3419 dnl $1 is the nominal value for _POSIX_C_SOURCE
3420 AC_DEFUN([CF_POSIX_C_SOURCE],
3421 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3423 if test "$cf_cv_posix_visible" = no; then
3425 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3427 cf_save_CFLAGS="$CFLAGS"
3428 cf_save_CPPFLAGS="$CPPFLAGS"
3430 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3431 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3433 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3434 CF_MSG_LOG(if the symbol is already defined go no further)
3435 AC_TRY_COMPILE([#include <sys/types.h>],[
3436 #ifndef _POSIX_C_SOURCE
3439 [cf_cv_posix_c_source=no],
3440 [cf_want_posix_source=no
3441 case .$cf_POSIX_C_SOURCE in
3443 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3446 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3447 cf_want_posix_source=yes
3450 cf_want_posix_source=yes
3453 if test "$cf_want_posix_source" = yes ; then
3454 AC_TRY_COMPILE([#include <sys/types.h>],[
3455 #ifdef _POSIX_SOURCE
3458 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3460 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3461 CFLAGS="$cf_trim_CFLAGS"
3462 CPPFLAGS="$cf_trim_CPPFLAGS"
3463 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3464 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3465 AC_TRY_COMPILE([#include <sys/types.h>],[
3466 #ifndef _POSIX_C_SOURCE
3469 [cf_cv_posix_c_source=no])
3470 CFLAGS="$cf_save_CFLAGS"
3471 CPPFLAGS="$cf_save_CPPFLAGS"
3475 if test "$cf_cv_posix_c_source" != no ; then
3476 CFLAGS="$cf_trim_CFLAGS"
3477 CPPFLAGS="$cf_trim_CPPFLAGS"
3478 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3481 fi # cf_cv_posix_visible
3484 dnl ---------------------------------------------------------------------------
3485 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3486 dnl ----------------
3487 dnl POSIX documents test-macros which an application may set before any system
3488 dnl headers are included to make features available.
3490 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3491 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3492 dnl recent features visible in the system header files unless the application
3493 dnl overrides the corresponding test-macros. Doing that introduces portability
3496 dnl This macro makes a special check for the symbols used for this, to avoid a
3497 dnl conflicting definition.
3498 AC_DEFUN([CF_POSIX_VISIBLE],
3500 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3501 AC_TRY_COMPILE([#include <stdio.h>],[
3502 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3503 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3504 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3505 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3506 #error conflicting symbols found
3508 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3511 dnl ---------------------------------------------------------------------------
3512 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3514 dnl Check for archiver "ar".
3515 AC_DEFUN([CF_PROG_AR],[
3516 AC_CHECK_TOOL(AR, ar, ar)
3518 dnl ---------------------------------------------------------------------------
3519 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3521 dnl Check for awk, ensure that the check found something.
3522 AC_DEFUN([CF_PROG_AWK],
3525 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3527 dnl ---------------------------------------------------------------------------
3528 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3530 dnl standard check for CC, plus followup sanity checks
3531 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3532 AC_DEFUN([CF_PROG_CC],[
3533 CF_ACVERSION_CHECK(2.53,
3534 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3535 AC_REQUIRE([AC_PROG_CC])],
3537 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3539 CF_ACVERSION_CHECK(2.52,
3544 dnl ---------------------------------------------------------------------------
3545 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3547 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3548 dnl the output file can be renamed, and allows for a shell variable that can
3549 dnl be used later. The parameter is either CC or CXX. The result is the
3551 dnl $cf_cv_prog_CC_c_o
3552 dnl $cf_cv_prog_CXX_c_o
3555 dnl $2 = compiler options, if any
3556 AC_DEFUN([CF_PROG_CC_C_O],
3557 [AC_REQUIRE([AC_PROG_CC])dnl
3558 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3559 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3561 cat > conftest.$ac_ext <<CF_EOF
3564 ${cf_cv_main_return:-return}(0);
3567 # We do the test twice because some compilers refuse to overwrite an
3568 # existing .o file with -o, though they will create one.
3569 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3570 if AC_TRY_EVAL(ac_try) &&
3571 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3573 eval cf_cv_prog_$1_c_o=yes
3575 eval cf_cv_prog_$1_c_o=no
3579 if test "$cf_cv_prog_$1_c_o" = yes; then
3580 AC_MSG_RESULT([yes])
3585 dnl ---------------------------------------------------------------------------
3586 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3588 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3589 dnl This macro adds a check to ensure the script found something.
3590 AC_DEFUN([CF_PROG_EGREP],
3591 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3592 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3593 then ac_cv_prog_egrep='grep -E'
3594 else ac_cv_prog_egrep='egrep'
3596 EGREP=$ac_cv_prog_egrep
3598 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3600 dnl ---------------------------------------------------------------------------
3601 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3603 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3604 AC_DEFUN([CF_PROG_EXT],
3606 AC_REQUIRE([CF_CHECK_CACHE])
3607 case "$cf_cv_system_name" in
3609 CFLAGS="$CFLAGS -Zmt"
3610 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3611 CXXFLAGS="$CXXFLAGS -Zmt"
3612 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3613 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3623 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])