1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey *
3 dnl Copyright 1998-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 1995-on
32 dnl $Id: aclocal.m4,v 1.975 2021/09/04 10:36:30 tom Exp $
33 dnl Macros used in NCURSES 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 AM_LANGINFO_CODESET version: 6 updated: 2021/01/01 16:53:59
46 dnl -------------------
47 dnl Inserted as requested by gettext 0.10.40
48 dnl File from /usr/share/aclocal
50 dnl ====================
53 dnl From Bruno Haible.
54 AC_DEFUN([AM_LANGINFO_CODESET],
56 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
57 [AC_TRY_LINK([#include <langinfo.h>],
58 [char* cs = nl_langinfo(CODESET); (void)cs],
59 am_cv_langinfo_codeset=yes,
60 am_cv_langinfo_codeset=no)
62 if test "$am_cv_langinfo_codeset" = yes; then
63 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
64 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
67 dnl ---------------------------------------------------------------------------
68 dnl CF_ABI_DEFAULTS version: 2 updated: 2015/06/06 13:49:58
70 dnl Provide configure-script defaults for different ncurses ABIs.
71 AC_DEFUN([CF_ABI_DEFAULTS],[
72 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
73 case x$cf_cv_abi_version in
79 cf_dft_ext_spfuncs=yes
80 cf_dft_filter_syms=yes
81 cf_dft_chtype=uint32_t
82 cf_dft_mmask_t=uint32_t
84 cf_dft_tparm_arg=intptr_t
102 dnl ---------------------------------------------------------------------------
103 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
104 dnl ------------------
105 dnl Conditionally generate script according to whether we're using a given autoconf.
107 dnl $1 = version to compare against
108 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
109 dnl $3 = code to use if AC_ACVERSION is older than $1.
110 define([CF_ACVERSION_CHECK],
112 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
113 ifdef([m4_version_compare],
114 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
115 [CF_ACVERSION_COMPARE(
116 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
117 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
118 dnl ---------------------------------------------------------------------------
119 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
120 dnl --------------------
121 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
122 dnl MAJOR2, MINOR2, TERNARY2,
123 dnl PRINTABLE2, not FOUND, FOUND)
124 define([CF_ACVERSION_COMPARE],
125 [ifelse(builtin([eval], [$2 < $5]), 1,
126 [ifelse([$8], , ,[$8])],
127 [ifelse([$9], , ,[$9])])])dnl
128 dnl ---------------------------------------------------------------------------
129 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
130 dnl -------------------
131 dnl Construct the list of include-options for the C programs in the Ada95
133 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
135 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
136 if test "$srcdir" != "."; then
137 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
139 if test "$GCC" != yes; then
140 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
141 elif test "$includedir" != "/usr/include"; then
142 if test "$includedir" = '${prefix}/include' ; then
143 if test x$prefix != x/usr ; then
144 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
147 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
152 dnl ---------------------------------------------------------------------------
153 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
155 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
156 AC_DEFUN([CF_ADD_ADAFLAGS],[
157 ADAFLAGS="$ADAFLAGS $1"
160 dnl ---------------------------------------------------------------------------
161 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
163 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
164 dnl $1 = flags to add
165 dnl $2 = if given makes this macro verbose.
167 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
168 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
169 dnl confused by the quotes (which require backslashes to keep them usable).
170 AC_DEFUN([CF_ADD_CFLAGS],
175 cf_new_extra_cppflags=
177 for cf_add_cflags in $1
179 case "$cf_fix_cppflags" in
181 case "$cf_add_cflags" in
182 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
183 case "$cf_add_cflags" in
185 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
187 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
188 && test -z "${cf_tst_cflags}" \
189 && cf_fix_cppflags=yes
191 if test "$cf_fix_cppflags" = yes ; then
192 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
194 elif test "${cf_tst_cflags}" = "\"'" ; then
195 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
204 case "$cf_add_cflags" in
206 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
207 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
210 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
215 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
220 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
222 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
224 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
225 && test -z "${cf_tst_cflags}" \
226 && cf_fix_cppflags=no
231 if test -n "$cf_new_cflags" ; then
232 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
233 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
236 if test -n "$cf_new_cppflags" ; then
237 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
238 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
241 if test -n "$cf_new_extra_cppflags" ; then
242 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
243 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
246 AC_SUBST(EXTRA_CPPFLAGS)
249 dnl ---------------------------------------------------------------------------
250 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
252 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
253 dnl The second parameter if given makes this macro verbose.
255 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
256 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
257 dnl confused by the quotes (which require backslashes to keep them usable).
258 AC_DEFUN([CF_ADD_CXXFLAGS],
260 cf_save_CXXFLAGS="$CFLAGS"
262 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
264 CFLAGS="$cf_save_CXXFLAGS"
266 dnl ---------------------------------------------------------------------------
267 dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04
269 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it is
270 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
271 dnl but old versions (and some misinstalled ones) need that. To make things
272 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
273 dnl the include-path).
274 AC_DEFUN([CF_ADD_INCDIR],
276 if test -n "$1" ; then
277 for cf_add_incdir in $1
279 while test "$cf_add_incdir" != /usr/include
281 if test -d "$cf_add_incdir"
284 if test -n "$CFLAGS$CPPFLAGS" ; then
285 # a loop is needed to ensure we can add subdirs of existing dirs
286 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
287 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
288 cf_have_incdir=yes; break
293 if test "$cf_have_incdir" = no ; then
294 if test "$cf_add_incdir" = /usr/local/include ; then
297 cf_save_CPPFLAGS=$CPPFLAGS
298 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
299 AC_TRY_COMPILE([#include <stdio.h>],
302 [cf_have_incdir=yes])
303 CPPFLAGS=$cf_save_CPPFLAGS
308 if test "$cf_have_incdir" = no ; then
309 CF_VERBOSE(adding $cf_add_incdir to include-path)
310 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
312 cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
313 test "$cf_top_incdir" = "$cf_add_incdir" && break
314 cf_add_incdir="$cf_top_incdir"
325 dnl ---------------------------------------------------------------------------
326 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
328 dnl Add a library, used to enforce consistency.
330 dnl $1 = library to add, without the "-l"
331 dnl $2 = variable to update (default $LIBS)
332 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
333 dnl ---------------------------------------------------------------------------
334 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
336 dnl Adds to the library-path
338 dnl Some machines have trouble with multiple -L options.
340 dnl $1 is the (list of) directory(s) to add
341 dnl $2 is the optional name of the variable to update (default LDFLAGS)
343 AC_DEFUN([CF_ADD_LIBDIR],
345 if test -n "$1" ; then
346 for cf_add_libdir in $1
348 if test "$cf_add_libdir" = /usr/lib ; then
350 elif test -d "$cf_add_libdir"
353 if test -n "$LDFLAGS$LIBS" ; then
354 # a loop is needed to ensure we can add subdirs of existing dirs
355 for cf_test_libdir in $LDFLAGS $LIBS ; do
356 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
357 cf_have_libdir=yes; break
361 if test "$cf_have_libdir" = no ; then
362 CF_VERBOSE(adding $cf_add_libdir to library-path)
363 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
369 dnl ---------------------------------------------------------------------------
370 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
372 dnl Add one or more libraries, used to enforce consistency. Libraries are
373 dnl prepended to an existing list, since their dependencies are assumed to
374 dnl already exist in the list.
376 dnl $1 = libraries to add, with the "-l", etc.
377 dnl $2 = variable to update (default $LIBS)
378 AC_DEFUN([CF_ADD_LIBS],[
379 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
382 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
384 for cf_add_1lib in $cf_add_0lib; do
385 for cf_add_2lib in $cf_add_libs; do
386 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
391 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
393 ifelse($2,,LIBS,[$2])="$cf_add_libs"
395 dnl ---------------------------------------------------------------------------
396 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
397 dnl ------------------
398 dnl Append to a search-list for a nonstandard header/lib-file
399 dnl $1 = the variable to return as result
400 dnl $2 = the package name
401 dnl $3 = the subdirectory, e.g., bin, include or lib
402 dnl $4 = the directory under which we will test for subdirectories
403 dnl $5 = a directory that we do not want $4 to match
404 AC_DEFUN([CF_ADD_SUBDIR_PATH],
406 test "x$4" != "x$5" && \
408 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
409 test -n "$verbose" && echo " ... testing for $3-directories under $4"
410 test -d "$4/$3" && $1="[$]$1 $4/$3"
411 test -d "$4/$3/$2" && $1="[$]$1 $4/$3/$2"
412 test -d "$4/$3/$2/$3" && $1="[$]$1 $4/$3/$2/$3"
413 test -d "$4/$2/$3" && $1="[$]$1 $4/$2/$3"
414 test -d "$4/$2/$3/$2" && $1="[$]$1 $4/$2/$3/$2"
417 dnl ---------------------------------------------------------------------------
418 dnl CF_APPEND_CFLAGS version: 1 updated: 2021/08/28 15:20:37
420 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
421 dnl $1 = flags to add
422 dnl $2 = if given makes this macro verbose.
423 define([CF_APPEND_CFLAGS],
425 for cf_add_cflags in $1
427 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
428 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
430 CF_ADD_CFLAGS([$1],[$2])
432 dnl ---------------------------------------------------------------------------
433 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
435 dnl use this macro for appending text without introducing an extra blank at
437 define([CF_APPEND_TEXT],
439 test -n "[$]$1" && $1="[$]$1 "
442 dnl ---------------------------------------------------------------------------
443 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
445 dnl Allow user to disable a normally-on option.
446 AC_DEFUN([CF_ARG_DISABLE],
447 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
448 dnl ---------------------------------------------------------------------------
449 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
451 dnl Allow user to enable a normally-off option.
452 AC_DEFUN([CF_ARG_ENABLE],
453 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
454 dnl ---------------------------------------------------------------------------
455 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
457 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
463 dnl $3 = action to perform if option is not default
464 dnl $4 = action if perform if option is default
465 dnl $5 = default option value (either 'yes' or 'no')
466 AC_DEFUN([CF_ARG_OPTION],
467 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
468 if test "$enableval" != "$5" ; then
470 ,[ $3]) ifelse([$4],,,[
473 fi],[enableval=$5 ifelse([$4],,,[
477 dnl ---------------------------------------------------------------------------
478 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
480 dnl Check for suitable "ar" (archiver) options for updating an archive.
482 dnl In particular, handle some obsolete cases where the "-" might be omitted,
483 dnl as well as a workaround for breakage of make's archive rules by the GNU
484 dnl binutils "ar" program.
485 AC_DEFUN([CF_AR_FLAGS],[
486 AC_REQUIRE([CF_PROG_AR])
488 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
489 case "$cf_cv_system_name" in
492 cat >mk_static_lib.sh <<-EOF
497 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
499 chmod +x mk_static_lib.sh
500 AR=`pwd`/mk_static_lib.sh
503 cf_cv_ar_flags=unknown
504 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
507 # check if $ARFLAGS already contains this choice
508 if test "x$ARFLAGS" != "x" ; then
509 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
510 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
516 rm -f "conftest.$ac_cv_objext"
519 cat >"conftest.$ac_ext" <<EOF
520 #line __oline__ "configure"
521 int testdata[[3]] = { 123, 456, 789 };
523 if AC_TRY_EVAL(ac_compile) ; then
524 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
525 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
526 if test -f conftest.a ; then
527 cf_cv_ar_flags="$cf_ar_flags"
531 CF_VERBOSE(cannot compile test-program)
535 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
540 if test -n "$ARFLAGS" ; then
541 if test -n "$cf_cv_ar_flags" ; then
542 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
545 ARFLAGS=$cf_cv_ar_flags
550 dnl ---------------------------------------------------------------------------
551 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
552 dnl -----------------
553 dnl Check if awk can handle big strings using printf. Some older versions of
554 dnl awk choke on large strings passed via "%s".
556 dnl $1 = desired string size
557 dnl $2 = variable to set with result
558 AC_DEFUN([CF_AWK_BIG_PRINTF],
565 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
566 | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
574 dnl ---------------------------------------------------------------------------
575 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
577 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
578 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
579 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
581 dnl Treat the configuration-variable specially here, since we're directly
582 dnl substituting its value (i.e., 1/0).
584 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
585 AC_DEFUN([CF_BOOL_DECL],
587 AC_MSG_CHECKING(if we should include stdbool.h)
589 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
590 AC_TRY_COMPILE([],[bool foo = false],
591 [cf_cv_header_stdbool_h=0],
596 ],[bool foo = false],
597 [cf_cv_header_stdbool_h=1],
598 [cf_cv_header_stdbool_h=0])])])
600 if test "$cf_cv_header_stdbool_h" = 1
601 then AC_MSG_RESULT(yes)
602 else AC_MSG_RESULT(no)
605 AC_MSG_CHECKING([for builtin bool type])
607 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
610 #include <sys/types.h>
612 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
613 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
616 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
617 then AC_MSG_RESULT(yes)
618 else AC_MSG_RESULT(no)
621 dnl ---------------------------------------------------------------------------
622 dnl CF_BOOL_SIZE version: 18 updated: 2021/09/04 06:35:04
624 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
625 dnl Don't bother looking for bool.h, since it has been deprecated.
627 dnl If the current compiler is C rather than C++, we get the bool definition
628 dnl from <stdbool.h>.
629 AC_DEFUN([CF_BOOL_SIZE],
631 AC_CHECK_SIZEOF(bool,,[
635 #if defined(__cplusplus)
637 #ifdef HAVE_GXX_BUILTIN_H
638 #include <g++/builtin.h>
639 #elif HAVE_GPP_BUILTIN_H
640 #include <gpp/builtin.h>
647 #if $cf_cv_header_stdbool_h
654 AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[
660 #if defined(__cplusplus)
662 #ifdef HAVE_GXX_BUILTIN_H
663 #include <g++/builtin.h>
664 #elif HAVE_GPP_BUILTIN_H
665 #include <gpp/builtin.h>
672 #if $cf_cv_header_stdbool_h
680 FILE *fp = fopen("cf_test.out", "w");
684 fputs("unsigned ", fp);
685 if (sizeof(x) == sizeof(int)) fputs("int", fp);
686 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
687 else if (sizeof(x) == sizeof(short))fputs("short",fp);
688 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
691 ${cf_cv_main_return:-return}(0);
694 [cf_cv_type_of_bool=`cat cf_test.out`
695 if test -z "$cf_cv_type_of_bool"; then
696 cf_cv_type_of_bool=unknown
698 [cf_cv_type_of_bool=unknown],
700 case x$ac_cv_sizeof_bool in
701 (x1) cf_cv_type_of_bool="unsigned char";;
702 (x2) cf_cv_type_of_bool="unsigned short";;
703 (x4) cf_cv_type_of_bool="unsigned int";;
704 (x8) cf_cv_type_of_bool="unsigned long";;
705 (*) cf_cv_type_of_bool=unknown;;
711 if test "$cf_cv_type_of_bool" = unknown ; then
712 case .$NCURSES_BOOL in
713 (.auto|.) NCURSES_BOOL=unsigned;;
715 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
716 cf_cv_type_of_bool=$NCURSES_BOOL
719 dnl ---------------------------------------------------------------------------
720 dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
722 dnl If we're cross-compiling, allow the user to override the tools and their
723 dnl options. The configure script is oriented toward identifying the host
724 dnl compiler, etc., but we need a build compiler to generate parts of the
727 dnl $1 = default for $CPPFLAGS
728 dnl $2 = default for $LIBS
729 AC_DEFUN([CF_BUILD_CC],[
730 CF_ACVERSION_CHECK(2.52,,
731 [AC_REQUIRE([CF_PROG_EXT])])
732 if test "$cross_compiling" = yes ; then
734 # defaults that we might want to override
735 : ${BUILD_CFLAGS:=''}
736 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
737 : ${BUILD_LDFLAGS:=''}
738 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
739 : ${BUILD_EXEEXT:='$x'}
740 : ${BUILD_OBJEXT:='o'}
742 AC_ARG_WITH(build-cc,
743 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
744 [BUILD_CC="$withval"],
745 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
746 AC_MSG_CHECKING(for native build C compiler)
747 AC_MSG_RESULT($BUILD_CC)
749 AC_MSG_CHECKING(for native build C preprocessor)
750 AC_ARG_WITH(build-cpp,
751 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
752 [BUILD_CPP="$withval"],
753 [BUILD_CPP='${BUILD_CC} -E'])
754 AC_MSG_RESULT($BUILD_CPP)
756 AC_MSG_CHECKING(for native build C flags)
757 AC_ARG_WITH(build-cflags,
758 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
759 [BUILD_CFLAGS="$withval"])
760 AC_MSG_RESULT($BUILD_CFLAGS)
762 AC_MSG_CHECKING(for native build C preprocessor-flags)
763 AC_ARG_WITH(build-cppflags,
764 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
765 [BUILD_CPPFLAGS="$withval"])
766 AC_MSG_RESULT($BUILD_CPPFLAGS)
768 AC_MSG_CHECKING(for native build linker-flags)
769 AC_ARG_WITH(build-ldflags,
770 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
771 [BUILD_LDFLAGS="$withval"])
772 AC_MSG_RESULT($BUILD_LDFLAGS)
774 AC_MSG_CHECKING(for native build linker-libraries)
775 AC_ARG_WITH(build-libs,
776 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
777 [BUILD_LIBS="$withval"])
778 AC_MSG_RESULT($BUILD_LIBS)
780 # this assumes we're on Unix.
784 : ${BUILD_CC:='${CC}'}
786 if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
787 AC_MSG_ERROR([Cross-build requires two compilers.
788 Use --with-build-cc to specify the native compiler.])
792 : ${BUILD_CC:='${CC}'}
793 : ${BUILD_CPP:='${CPP}'}
794 : ${BUILD_CFLAGS:='${CFLAGS}'}
795 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
796 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
797 : ${BUILD_LIBS:='${LIBS}'}
798 : ${BUILD_EXEEXT:='$x'}
799 : ${BUILD_OBJEXT:='o'}
804 AC_SUBST(BUILD_CFLAGS)
805 AC_SUBST(BUILD_CPPFLAGS)
806 AC_SUBST(BUILD_LDFLAGS)
808 AC_SUBST(BUILD_EXEEXT)
809 AC_SUBST(BUILD_OBJEXT)
811 dnl ---------------------------------------------------------------------------
812 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
814 AC_DEFUN([CF_C11_NORETURN],
816 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
817 CF_ARG_ENABLE(stdnoreturn,
818 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
819 [enable_stdnoreturn=yes],
820 [enable_stdnoreturn=no])
821 AC_MSG_RESULT($enable_stdnoreturn)
823 if test $enable_stdnoreturn = yes; then
824 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
828 #include <stdnoreturn.h>
829 static _Noreturn void giveup(void) { exit(0); }
831 [if (feof(stdin)) giveup()],
832 cf_cv_c11_noreturn=yes,
833 cf_cv_c11_noreturn=no)
836 cf_cv_c11_noreturn=no,
839 if test "$cf_cv_c11_noreturn" = yes; then
840 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
841 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
847 AC_SUBST(HAVE_STDNORETURN_H)
848 AC_SUBST(STDC_NORETURN)
850 dnl ---------------------------------------------------------------------------
851 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
853 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
854 dnl into CC. This will not help with broken scripts that wrap the compiler
855 dnl with options, but eliminates a more common category of user confusion.
857 dnl In particular, it addresses the problem of being able to run the C
858 dnl preprocessor in a consistent manner.
860 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
861 dnl the nuisance of having inconsistent settings for compiler and preprocessor
862 dnl outweighs that limitation.
863 AC_DEFUN([CF_CC_ENV_FLAGS],
865 # This should have been defined by AC_PROG_CC
868 AC_MSG_CHECKING(\$CFLAGS variable)
871 AC_MSG_RESULT(broken)
872 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
875 for cf_arg in $cf_flags
877 CF_ADD_CFLAGS($cf_arg)
885 AC_MSG_CHECKING(\$CC variable)
888 AC_MSG_RESULT(broken)
889 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
891 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
892 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
894 for cf_arg in $cf_flags
898 CF_ADD_CFLAGS($cf_arg)
905 CF_VERBOSE(resulting CC: '$CC')
906 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
907 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
914 dnl ---------------------------------------------------------------------------
915 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
917 dnl Determine the default configuration into which we'll install ncurses. This
918 dnl can be overridden by the user's command-line options. There's two items to
920 dnl 1. the prefix (e.g., /usr)
921 dnl 2. the header files (e.g., /usr/include/ncurses)
922 dnl We'll look for a previous installation of ncurses and use the same defaults.
924 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
925 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
926 dnl programs from a vendor's.
927 AC_DEFUN([CF_CFG_DEFAULTS],
928 [AC_REQUIRE([AC_PROG_FGREP])dnl
930 AC_MSG_CHECKING(for prefix)
931 if test "x$prefix" = "xNONE" ; then
932 case "$cf_cv_system_name" in
933 # non-vendor systems don't have a conflict
934 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
937 (*) prefix=$ac_default_prefix
941 AC_MSG_RESULT($prefix)
943 if test "x$prefix" = "xNONE" ; then
944 AC_MSG_CHECKING(for default include-directory)
945 test -n "$verbose" && echo 1>&AC_FD_MSG
948 "$includedir/ncurses" \
950 "$prefix/include/ncurses" \
952 /usr/local/include/ncurses \
956 cf_dir=`eval echo "$cf_symbol"`
957 if test -f "$cf_dir/curses.h" ; then
958 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
959 includedir="$cf_symbol"
960 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
964 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
966 AC_MSG_RESULT($includedir)
969 dnl ---------------------------------------------------------------------------
970 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
972 dnl Check if the terminal-capability database functions are available. If not,
973 dnl ncurses has a much-reduced version.
974 AC_DEFUN([CF_CGETENT],[
975 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
977 #include <stdlib.h>],[
980 char *db_array = temp;
981 cgetent(&buf, &db_array, "vt100");
982 cgetcap(buf, "tc", '=');
983 cgetmatch(buf, "tc");
989 if test "$cf_cv_cgetent" = yes
991 AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
992 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
994 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
995 #include <stdlib.h>],[
998 #ifndef _NETBSD_SOURCE /* given, since April 2004 in stdlib.h */
999 const char *db_array = temp;
1000 cgetent(&buf, &db_array, "vt100");
1002 cgetcap(buf, "tc", '=');
1003 cgetmatch(buf, "tc");
1005 [cf_cv_cgetent_const=yes],
1006 [cf_cv_cgetent_const=no])
1008 if test "$cf_cv_cgetent_const" = yes
1010 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
1014 dnl ---------------------------------------------------------------------------
1015 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
1017 dnl Check if we're accidentally using a cache from a different machine.
1018 dnl Derive the system name, as a check for reusing the autoconf cache.
1020 dnl If we've packaged config.guess and config.sub, run that (since it does a
1021 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
1022 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
1023 dnl which is useful in cross-compiles.
1025 dnl Note: we would use $ac_config_sub, but that is one of the places where
1026 dnl autoconf 2.5x broke compatibility with autoconf 2.13
1027 AC_DEFUN([CF_CHECK_CACHE],
1029 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
1030 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
1031 system_name="$host_os"
1033 system_name="`(uname -s -r) 2>/dev/null`"
1034 if test -z "$system_name" ; then
1035 system_name="`(hostname) 2>/dev/null`"
1038 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
1039 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
1041 test -z "$system_name" && system_name="$cf_cv_system_name"
1042 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
1044 if test ".$system_name" != ".$cf_cv_system_name" ; then
1045 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
1046 AC_MSG_ERROR("Please remove config.cache and try again.")
1049 dnl ---------------------------------------------------------------------------
1050 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
1051 dnl ----------------
1052 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
1053 dnl variable. Define a DECL_xxx symbol if we must declare it ourselves.
1055 dnl $1 = the name to check
1056 dnl $2 = the assumed type
1057 AC_DEFUN([CF_CHECK_ENVIRON],
1059 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1061 #ifdef HAVE_STDLIB_H
1064 #include <unistd.h> ],
1065 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
1070 if test "$cf_cv_dcl_$1" = no ; then
1071 CF_UPPER(cf_result,decl_$1)
1072 AC_DEFINE_UNQUOTED($cf_result)
1075 # It's possible (for near-UNIX clones) that the data doesn't exist
1076 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1078 dnl ---------------------------------------------------------------------------
1079 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
1081 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
1082 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
1085 dnl $1 = the name to check
1086 dnl $2 = the assumed type
1087 AC_DEFUN([CF_CHECK_ERRNO],
1089 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1091 #ifdef HAVE_STDLIB_H
1095 #include <sys/types.h>
1096 #include <errno.h> ],
1097 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1102 if test "$cf_cv_dcl_$1" = no ; then
1103 CF_UPPER(cf_result,decl_$1)
1104 AC_DEFINE_UNQUOTED($cf_result)
1107 # It's possible (for near-UNIX clones) that the data doesn't exist
1108 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1110 dnl ---------------------------------------------------------------------------
1111 dnl CF_CHECK_EXTERN_DATA version: 5 updated: 2021/09/04 06:35:04
1112 dnl --------------------
1113 dnl Check for existence of external data in the current set of libraries. If
1114 dnl we can modify it, it is real enough.
1115 dnl $1 = the name to check
1117 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1119 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1125 [cf_cv_have_$1=yes],
1129 if test "$cf_cv_have_$1" = yes ; then
1130 CF_UPPER(cf_result,have_$1)
1131 AC_DEFINE_UNQUOTED($cf_result)
1135 dnl ---------------------------------------------------------------------------
1136 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1137 dnl --------------------
1138 dnl Check whether the compiler understands -fvisibility=hidden
1141 dnl $2 = compiler-flags variable name
1142 dnl $3 = cache variable to set
1143 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1144 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1145 cf_save_cflags="[$]$2"
1146 $2="[$]$2 -fvisibility=hidden"
1148 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1150 if (somefunc()) return 1;
1157 dnl ---------------------------------------------------------------------------
1158 dnl CF_CHECK_GETENV version: 2 updated: 2021/01/02 17:09:14
1160 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1161 dnl discard the previous pointer when returning a new one.
1162 AC_DEFUN([CF_CHECK_GETENV],
1164 AC_REQUIRE([CF_CHECK_ENVIRON])
1165 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1166 AC_CHECK_FUNCS( putenv setenv strdup )
1167 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1173 #include <sys/types.h>
1175 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1176 extern char **environ; /* POSIX, but some systems are not... */
1179 #if defined(HAVE_STRDUP)
1180 #define str_alloc(s) strdup(s)
1182 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1185 static void set_value(const char *name, const char *value)
1187 #if defined(HAVE_SETENV)
1188 setenv(name, value, 1);
1189 #elif defined(HAVE_PUTENV)
1191 sprintf(buffer, "%s=%s", name, value);
1192 putenv(str_alloc(buffer));
1194 #error neither putenv/setenv found
1200 size_t numenv, limit, j;
1205 for (numenv = 0; environ[numenv]; ++numenv) ;
1206 limit = numenv + 10;
1207 mynames = (char **) calloc(limit + 1, sizeof(char *));
1208 myvalues = (char **) calloc(limit + 1, sizeof(char *));
1209 mypointer = (char **) calloc(limit + 1, sizeof(char *));
1210 #if defined(HAVE_ENVIRON)
1211 for (j = 0; environ[j]; ++j) {
1212 mynames[j] = str_alloc(environ[j]);
1213 equals = strchr(mynames[j], '=');
1216 myvalues[j] = str_alloc(equals);
1218 myvalues[j] = str_alloc("");
1222 for (j = numenv; j < limit; ++j) {
1230 sprintf(name, "TERM%lu", (unsigned long) k);
1231 for (jk = 0; jk < j; ++jk) {
1232 if (!strcmp(name, mynames[jk])) {
1239 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1240 set_value(name, value);
1241 mynames[j] = str_alloc(name);
1242 myvalues[j] = str_alloc(value);
1244 for (pass = 0; pass < 3; ++pass) {
1245 for (j = 0; j < limit; ++j) {
1246 char *value = getenv(mynames[j]);
1249 fprintf(stderr, "getenv returned null for %s\\n", mynames[j]);
1250 ${cf_cv_main_return:-return}(1);
1251 } else if (value != mypointer[j]) {
1252 fprintf(stderr, "getenv returned different pointer for %s\\n", mynames[j]);
1253 ${cf_cv_main_return:-return}(1);
1254 } else if (strcmp(value, myvalues[j])) {
1255 fprintf(stderr, "getenv returned different value for %s\\n", mynames[j]);
1256 ${cf_cv_main_return:-return}(1);
1260 mypointer[j] = value;
1261 for (k = 0; k < j; ++k) {
1262 if (mypointer[j] == mypointer[k]) {
1263 fprintf(stderr, "getenv returned same pointer for %s and %s\\n", mynames[j], mynames[k]);
1264 ${cf_cv_main_return:-return}(1);
1270 ${cf_cv_main_return:-return}(0);
1273 [cf_cv_consistent_getenv=yes],
1274 [cf_cv_consistent_getenv=no],
1275 [cf_cv_consistent_getenv=unknown])
1278 if test "x$cf_cv_consistent_getenv" = xno
1280 AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1283 dnl ---------------------------------------------------------------------------
1284 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
1285 dnl ---------------------
1286 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1288 AC_REQUIRE([CF_GNAT_VERSION])
1289 case "$cf_cv_gnat_version" in
1290 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1291 cf_cv_prog_gnat_correct=yes
1294 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1295 cf_cv_prog_gnat_correct=no
1299 dnl ---------------------------------------------------------------------------
1300 dnl CF_CHECK_GPM_WGETCH version: 6 updated: 2021/01/04 18:48:01
1301 dnl -------------------
1302 dnl Check if GPM is already linked with curses. If so - and if the linkage
1303 dnl is not "weak" - warn about this because it can create problems linking
1304 dnl applications with ncurses.
1305 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1306 AC_REQUIRE([AC_PROG_EGREP])dnl
1308 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1310 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1311 cf_cv_check_gpm_wgetch=unknown
1312 if test "$cross_compiling" != yes ; then
1314 cat >conftest.$ac_ext <<CF_EOF
1319 ${cf_cv_main_return:-return}(0);
1323 cf_save_LIBS="$LIBS"
1324 # This only works if we can look at the symbol table. If a shared
1325 # library is stripped for install, we cannot use that. So we're forced
1326 # to rely on the static library, noting that some packagers may not
1328 LIBS="-static -lgpm -dynamic $LIBS"
1329 if AC_TRY_EVAL(ac_compile) ; then
1330 if AC_TRY_EVAL(ac_link) ; then
1331 cf_cv_check_gpm_wgetch="`nm \"conftest$ac_exeext\" | ${EGREP-egrep} '\<wgetch\>' | ${EGREP-egrep} '\<[[vVwW]]\>'`"
1332 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1333 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1337 LIBS="$cf_save_LIBS"
1341 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1342 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1345 dnl ---------------------------------------------------------------------------
1346 dnl CF_CHECK_LIBTOOL_VERSION version: 2 updated: 2021/05/01 16:24:34
1347 dnl ------------------------
1348 dnl Show the version of libtool
1350 dnl Save the version in a cache variable - this is not entirely a good thing,
1351 dnl but the version string from libtool is very ugly, and for bug reports it
1352 dnl might be useful to have the original string.
1354 dnl There is an imitation in OpenBSD, which has no apparent use other than to
1355 dnl deny that it is GNU libtool. Just ignore it.
1356 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1357 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1359 AC_MSG_CHECKING(version of $LIBTOOL)
1361 AC_MSG_RESULT($cf_cv_libtool_version)
1362 if test -n "$cf_cv_libtool_version"
1364 cf_check_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' -e 's,[[()]],...,g' -e 's,[[ ]],-,g' -e '2,$d'`
1365 case "x$cf_check_libtool_version" in
1366 (*...GNU-libtool...*)
1369 AC_MSG_ERROR(This is not GNU libtool)
1373 AC_MSG_ERROR(No version found for $LIBTOOL)
1376 AC_MSG_ERROR(GNU libtool has not been found)
1379 dnl ---------------------------------------------------------------------------
1380 dnl CF_CHECK_WCHAR_H version: 3 updated: 2021/01/01 13:31:04
1381 dnl ----------------
1382 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1383 AC_DEFUN([CF_CHECK_WCHAR_H],[
1388 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1395 #ifdef HAVE_WCTYPE_H
1400 int bar = iswpunct(foo)],
1401 [cf_cv_wchar_h_okay=yes],
1402 [cf_cv_wchar_h_okay=no])])
1404 if test "$cf_cv_wchar_h_okay" = no
1406 CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1409 dnl ---------------------------------------------------------------------------
1410 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 2 updated: 2021/01/02 17:09:14
1411 dnl -------------------------
1412 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1413 dnl should support line-drawing. Even with Unicode. There is a problem.
1415 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1416 dnl all of those were combined into a page of useful graphics characters.
1418 dnl So far, so good.
1420 dnl However, while they are useful, there are other considerations. CJK
1421 dnl is (because of poor device resolution) often rendered as double-width
1422 dnl characters. So... for these generally-useful characters, what should
1423 dnl be the width (to make them consistent with adjacent characters)?
1425 dnl The obvious choice would have been to make this locale-dependent, and use
1426 dnl wcwidth() to tell applications what the actual width is. That was too
1427 dnl obvious. Instead, we have a slew of "ambiguous-width" characters.
1429 dnl http://www.unicode.org/reports/tr11/tr11-29.html
1430 dnl http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1432 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1433 dnl more than 22,000 characters, with 1281 of those as ambiguous-width. For
1434 dnl instance, it lists half (44/96) of the Latin-1 characters as
1435 dnl ambiguous-width. Also, all of the box-characters at 0x2500 are ambiguous.
1437 dnl What this means for the implementor is that on some systems wcwidth() can
1438 dnl give bad advice. On Solaris, some of the ambiguous widths are returned as
1439 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1440 dnl characters). These do not necessarily match the behavior of the terminal
1441 dnl emulator. xterm, for instance, does an optional startup check to find if
1442 dnl this problem (or similar) exists with the system's locale tables, rejecting
1443 dnl them if they are too unreliable.
1444 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1445 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1446 cat >conftest.in <<CF_EOF
1448 0x250c upper left corner
1449 0x2514 lower left corner
1450 0x2510 upper right corner
1451 0x2518 lower right corner
1452 0x251c tee pointing left
1453 0x2524 tee pointing right
1454 0x2534 tee pointing up
1455 0x252c tee pointing down
1456 0x2500 horizontal line
1457 0x2502 vertical line
1458 0x253c large plus or crossover
1462 0x2592 checker board (stipple)
1463 0x00b0 degree symbol
1466 - Teletype 5410v1 symbols
1467 0x2190 arrow pointing left
1468 0x2192 arrow pointing right
1469 0x2193 arrow pointing down
1470 0x2191 arrow pointing up
1471 0x2592 board of squares
1472 0x2603 lantern symbol
1473 0x25ae solid square block
1474 - these defaults were invented for ncurses
1477 0x2264 less-than-or-equal-to
1478 0x2265 greater-than-or-equal-to
1481 0x00a3 pound-sterling symbol
1482 - thick-line-drawing
1483 0x250f upper left corner
1484 0x2517 lower left corner
1485 0x2513 upper right corner
1486 0x251b lower right corner
1487 0x2523 tee pointing left
1488 0x252b tee pointing right
1489 0x253b tee pointing up
1490 0x2533 tee pointing down
1491 0x2501 horizontal line
1492 0x2503 vertical line
1493 0x254b large plus or crossover
1494 - double-line-drawing
1495 0x2554 upper left corner
1496 0x255a lower left corner
1497 0x2557 upper right corner
1498 0x255d lower right corner
1499 0x2563 tee pointing left
1500 0x2560 tee pointing right
1501 0x2569 tee pointing up
1502 0x2566 tee pointing down
1503 0x2550 horizontal line
1504 0x2551 vertical line
1505 0x256c large plus or crossover
1519 char buffer[MY_LEN + 1];
1520 char notes[MY_LEN + 1];
1524 if (setlocale(LC_ALL, "en_US.UTF8") ||
1525 setlocale(LC_ALL, "en_US.UTF-8") ||
1526 setlocale(LC_ALL, "en_US.utf8") ||
1527 setlocale(LC_ALL, "en_US.utf-8")) {
1528 if ((fp = fopen("conftest.in", "r")) != 0) {
1529 while (fgets(buffer, MY_LEN, fp) != 0) {
1530 if (*buffer == '-') {
1531 fprintf(stderr, "\\t%s", buffer);
1532 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1534 if (wcwidth(value) == 1)
1536 fprintf(stderr, "%d\\t%s", wcwidth(value), buffer);
1538 fprintf(stderr, "?\\t%s", buffer);
1543 fprintf(stderr, "%d/%d passed wcwidth/graphics check\\n", passed, totals);
1544 return (totals == passed) ? 0 : 1;
1547 [cf_cv_wcwidth_graphics=yes],
1548 [cf_cv_wcwidth_graphics=no],
1549 [cf_cv_wcwidth_graphics=unknown])
1552 dnl ---------------------------------------------------------------------------
1553 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
1554 dnl -----------------
1555 dnl Check if the given compiler is really clang. clang's C driver defines
1556 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1557 dnl not ignore some gcc options.
1559 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1560 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1561 dnl the wrappers for gcc and g++ warnings.
1563 dnl $1 = GCC (default) or GXX
1564 dnl $2 = CLANG_COMPILER (default)
1565 dnl $3 = CFLAGS (default) or CXXFLAGS
1566 AC_DEFUN([CF_CLANG_COMPILER],[
1567 ifelse([$2],,CLANG_COMPILER,[$2])=no
1569 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1570 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1571 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1577 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1579 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1580 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1585 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
1587 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
1588 AC_MSG_WARN(replacing broken compiler alias $CC)
1589 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
1594 AC_MSG_CHECKING(version of $CC)
1595 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.]].*//'`"
1596 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
1597 AC_MSG_RESULT($CLANG_VERSION)
1599 for cf_clang_opt in \
1600 -Qunused-arguments \
1601 -Wno-error=implicit-function-declaration
1603 AC_MSG_CHECKING(if option $cf_clang_opt works)
1604 cf_save_CFLAGS="$CFLAGS"
1605 CFLAGS="$CFLAGS $cf_clang_opt"
1607 #include <stdio.h>],[
1608 printf("hello!\\n");],[
1609 cf_clang_optok=yes],[
1611 AC_MSG_RESULT($cf_clang_optok)
1612 CFLAGS="$cf_save_CFLAGS"
1613 if test "$cf_clang_optok" = yes; then
1614 CF_VERBOSE(adding option $cf_clang_opt)
1615 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
1620 dnl ---------------------------------------------------------------------------
1621 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
1622 dnl -----------------
1623 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1624 dnl character-strings.
1626 dnl It is ambiguous because the specification accommodated the pre-ANSI
1627 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1628 dnl compiler other than by costly add-ons. Because of this, the specification
1629 dnl did not take into account the use of const for telling the compiler that
1630 dnl string literals would be in readonly memory.
1632 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1633 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1634 dnl That does not solve the problem of using the block of Xt's strings which
1635 dnl are compiled into the library (and is less efficient than one might want).
1637 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1638 dnl when compiling the library and compiling using the library, to tell the
1639 dnl compiler that String is const.
1640 AC_DEFUN([CF_CONST_X_STRING],
1642 AC_REQUIRE([AC_PATH_XTRA])
1644 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1649 #include <X11/Intrinsic.h>
1651 [String foo = malloc(1); free((void*)foo)],[
1653 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1656 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1657 #undef XTSTRINGDEFINES /* X11R5 and later */
1659 #include <X11/Intrinsic.h>
1660 ],[String foo = malloc(1); *foo = 0],[
1661 cf_cv_const_x_string=no
1663 cf_cv_const_x_string=yes
1667 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1669 case "$cf_cv_const_x_string" in
1671 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1674 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1680 dnl ---------------------------------------------------------------------------
1681 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1682 dnl -----------------
1683 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
1684 dnl is a late feature for the standard and is not in some recent compilers
1686 AC_DEFUN([CF_CPP_PARAM_INIT],
1688 if test -n "$CXX"; then
1689 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1701 TEST::TEST(int x = 1) // some compilers do not like second initializer
1707 [cf_cv_cpp_param_init=yes],
1708 [cf_cv_cpp_param_init=no],
1709 [cf_cv_cpp_param_init=unknown])
1713 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1715 dnl ---------------------------------------------------------------------------
1716 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1717 dnl ------------------
1718 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
1719 dnl not be supported in g++ before 3.0
1720 AC_DEFUN([CF_CPP_STATIC_CAST],
1722 if test -n "$CXX"; then
1724 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1732 NCursesPanel(int nlines,
1742 template<class T> class NCursesUserPanel : public NCursesPanel
1745 NCursesUserPanel (int nlines,
1749 const T* p_UserData = static_cast<T*>(0))
1750 : NCursesPanel (nlines, ncols, begin_y, begin_x)
1753 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1757 virtual ~NCursesUserPanel() {};
1760 const char* p_UserData = static_cast<char*>(0)],
1761 [cf_cv_cpp_static_cast=yes],
1762 [cf_cv_cpp_static_cast=no])
1769 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1771 dnl ---------------------------------------------------------------------------
1772 dnl CF_CXX_AR_FLAGS version: 3 updated: 2021/01/01 13:31:04
1774 dnl Setup special archiver flags for given compilers.
1775 AC_DEFUN([CF_CXX_AR_FLAGS],[
1777 CXX_ARFLAGS='$(ARFLAGS)'
1778 case "$cf_cv_system_name" in
1780 if test "$GXX" != yes ; then
1782 CXX_ARFLAGS='-ar -o'
1786 CXXLDFLAGS="-u main"
1789 if test "$GXX" != yes ; then
1791 CXX_ARFLAGS='-xar -o'
1795 AC_SUBST(CXXLDFLAGS)
1797 AC_SUBST(CXX_ARFLAGS)
1799 dnl ---------------------------------------------------------------------------
1800 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1801 dnl -------------------------
1802 dnl For c++, check if iostream uses "std::" namespace.
1803 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1804 AC_CHECK_HEADERS(iostream)
1805 if test x"$ac_cv_header_iostream" = xyes ; then
1806 AC_MSG_CHECKING(if iostream uses std-namespace)
1811 cerr << "testing" << endl;
1812 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1813 AC_MSG_RESULT($cf_iostream_namespace)
1814 if test "$cf_iostream_namespace" = yes ; then
1815 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1819 dnl ---------------------------------------------------------------------------
1820 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1822 dnl Check if the C compiler supports "inline".
1823 dnl $1 is the name of a shell variable to set if inline is supported
1824 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1825 AC_DEFUN([CF_C_INLINE],[
1826 AC_REQUIRE([CF_GCC_VERSION])
1829 if test "$ac_cv_c_inline" != no ; then
1831 if test "$INTEL_COMPILER" = yes
1834 elif test "$CLANG_COMPILER" = yes
1837 elif test "$GCC" = yes
1839 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1840 cf_save_CFLAGS=$CFLAGS
1841 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1842 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1843 [${cf_cv_main_return:-return} foo()],
1844 [cf_cv_gcc_inline=yes],
1845 [cf_cv_gcc_inline=no])
1846 CFLAGS=$cf_save_CFLAGS
1848 if test "$cf_cv_gcc_inline" = yes ; then
1849 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1855 dnl ---------------------------------------------------------------------------
1856 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1858 dnl "dirname" is not portable, so we fake it with a shell script.
1859 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1860 dnl ---------------------------------------------------------------------------
1861 dnl CF_DIRS_TO_MAKE version: 4 updated: 2021/01/01 13:31:04
1863 AC_DEFUN([CF_DIRS_TO_MAKE],
1866 for cf_item in $cf_list_models
1868 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1869 for cf_item2 in $DIRS_TO_MAKE
1871 test "$cf_item2" = "$cf_subdir" && break
1873 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1875 for cf_dir in $DIRS_TO_MAKE
1877 test ! -d "$cf_dir" && mkdir "$cf_dir"
1879 AC_SUBST(DIRS_TO_MAKE)
1881 dnl ---------------------------------------------------------------------------
1882 dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04
1884 dnl You can always use "make -n" to see the actual options, but it is hard to
1885 dnl pick out/analyze warning messages when the compile-line is long.
1888 dnl ECHO_LT - symbol to control if libtool is verbose
1889 dnl ECHO_LD - symbol to prefix "cc -o" lines
1890 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1891 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1892 dnl ECHO_CC - symbol to put before any "cc" line
1894 AC_DEFUN([CF_DISABLE_ECHO],[
1895 AC_MSG_CHECKING(if you want to see long compiling messages)
1896 CF_ARG_DISABLE(echo,
1897 [ --disable-echo do not display "compiling" commands],
1900 ECHO_LD='@echo linking [$]@;'
1901 RULE_CC='@echo compiling [$]<'
1902 SHOW_CC='@echo compiling [$]@'
1911 AC_MSG_RESULT($enableval)
1918 dnl ---------------------------------------------------------------------------
1919 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1920 dnl ------------------------
1921 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1922 AC_MSG_CHECKING(if we want to use GNAT projects)
1923 CF_ARG_DISABLE(gnat-projects,
1924 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1925 [enable_gnat_projects=no],
1926 [enable_gnat_projects=yes])
1927 AC_MSG_RESULT($enable_gnat_projects)
1929 dnl ---------------------------------------------------------------------------
1930 dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50
1931 dnl ----------------
1932 dnl Combine no-leak checks with the libraries or tools that are used for the
1934 AC_DEFUN([CF_DISABLE_LEAKS],[
1936 AC_REQUIRE([CF_WITH_DMALLOC])
1937 AC_REQUIRE([CF_WITH_DBMALLOC])
1938 AC_REQUIRE([CF_WITH_VALGRIND])
1940 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1941 AC_ARG_ENABLE(leaks,
1942 [ --disable-leaks test: free permanent memory, analyze leaks],
1943 [enable_leaks=$enableval],
1945 dnl with_no_leaks is more readable...
1946 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
1947 AC_MSG_RESULT($with_no_leaks)
1949 if test "$enable_leaks" = no ; then
1950 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1951 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1954 dnl ---------------------------------------------------------------------------
1955 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1956 dnl --------------------------
1957 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1958 dnl the older "-version-info" feature. The newer feature allows us to use
1959 dnl version numbering on shared libraries which make them compatible with
1960 dnl various systems.
1961 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1963 AC_MSG_CHECKING(if libtool -version-number should be used)
1964 CF_ARG_DISABLE(libtool-version,
1965 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1966 [cf_libtool_version=no],
1967 [cf_libtool_version=yes])
1968 AC_MSG_RESULT($cf_libtool_version)
1970 if test "$cf_libtool_version" = yes ; then
1971 LIBTOOL_VERSION="-version-number"
1973 LIBTOOL_VERSION="-version-info"
1976 AC_MSG_WARN(VERSION was not set)
1979 ABI_VERSION="$VERSION"
1980 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1983 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1984 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1987 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1992 AC_SUBST(ABI_VERSION)
1993 AC_SUBST(LIBTOOL_VERSION)
1995 dnl ---------------------------------------------------------------------------
1996 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
1997 dnl ---------------------
1998 dnl The rpath-hack makes it simpler to build programs, particularly with the
1999 dnl *BSD ports which may have essential libraries in unusual places. But it
2000 dnl can interfere with building an executable for the base system. Use this
2001 dnl option in that case.
2002 AC_DEFUN([CF_DISABLE_RPATH_HACK],
2004 AC_MSG_CHECKING(if rpath-hack should be disabled)
2005 CF_ARG_DISABLE(rpath-hack,
2006 [ --disable-rpath-hack don't add rpath options for additional libraries],
2007 [enable_rpath_hack=no],
2008 [enable_rpath_hack=yes])
2009 dnl TODO - drop cf_disable_rpath_hack
2010 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
2011 AC_MSG_RESULT($cf_disable_rpath_hack)
2013 if test "$enable_rpath_hack" = yes ; then
2017 dnl ---------------------------------------------------------------------------
2018 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
2019 dnl -----------------------
2020 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
2021 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
2022 dnl an unconditional feature.
2023 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
2025 AC_MSG_CHECKING(if you want broken-linker support code)
2026 AC_ARG_ENABLE(broken_linker,
2027 [ --enable-broken_linker compile with broken-linker support code],
2028 [with_broken_linker=$enableval],
2029 [with_broken_linker=no])
2030 AC_MSG_RESULT($with_broken_linker)
2032 : "${BROKEN_LINKER:=0}"
2033 if test "x$with_broken_linker" = xyes ; then
2034 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
2037 AC_SUBST(BROKEN_LINKER)
2039 dnl ---------------------------------------------------------------------------
2040 dnl CF_ENABLE_PC_FILES version: 13 updated: 2015/11/01 05:27:39
2041 dnl ------------------
2042 dnl This is the "--enable-pc-files" option, which is available if there is a
2043 dnl pkg-config configuration on the local machine.
2044 AC_DEFUN([CF_ENABLE_PC_FILES],[
2045 AC_REQUIRE([CF_PKG_CONFIG])
2046 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
2048 if test "x$PKG_CONFIG" != xnone
2050 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
2052 AC_MSG_CHECKING(if we should install .pc files)
2055 AC_ARG_ENABLE(pc-files,
2056 [ --enable-pc-files generate and install .pc files for pkg-config],
2057 [enable_pc_files=$enableval],
2058 [enable_pc_files=no])
2059 AC_MSG_RESULT($enable_pc_files)
2061 if test "x$enable_pc_files" != xno
2064 case "x$PKG_CONFIG_LIBDIR" in
2066 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
2069 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
2075 AC_SUBST(MAKE_PC_FILES)
2077 dnl ---------------------------------------------------------------------------
2078 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
2080 dnl Check if the rpath option should be used, setting cache variable
2081 dnl cf_cv_enable_rpath if so.
2082 AC_DEFUN([CF_ENABLE_RPATH],
2084 AC_MSG_CHECKING(if rpath option should be used)
2085 AC_ARG_ENABLE(rpath,
2086 [ --enable-rpath use rpath option when generating shared libraries],
2087 [cf_cv_enable_rpath=$enableval],
2088 [cf_cv_enable_rpath=no])
2089 AC_MSG_RESULT($cf_cv_enable_rpath)
2091 dnl ---------------------------------------------------------------------------
2092 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
2093 dnl ----------------------
2094 dnl On a few platforms, the compiler and/or loader nags with untruthful
2095 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
2096 dnl and implying that most uses of the recommended alternatives are correct.
2098 dnl Factually speaking, no one has actually counted the number of uses of these
2099 dnl functions versus the total of incorrect uses. Samples of a few thousand
2100 dnl instances are meaningless compared to the hundreds of millions of lines of
2101 dnl existing C code.
2103 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
2104 dnl platforms, in implementations of varying quality. Likewise, snprintf is
2105 dnl standard - but evolved through phases, and older implementations are likely
2106 dnl to yield surprising results, as documented in manpages on various systems.
2107 AC_DEFUN([CF_ENABLE_STRING_HACKS],
2109 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
2110 AC_ARG_ENABLE(string-hacks,
2111 [ --enable-string-hacks work around bogus compiler/loader warnings],
2112 [enable_string_hacks=$enableval],
2113 [enable_string_hacks=no])
2114 AC_MSG_RESULT($enable_string_hacks)
2116 if test "x$enable_string_hacks" = "xyes"; then
2117 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
2118 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
2119 AC_CHECK_FUNC(strlcat,[
2120 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2122 AC_CHECK_LIB(bsd,strlcat,[
2124 AC_CHECK_HEADERS(bsd/string.h)
2125 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2128 AC_CHECK_FUNCS( strlcpy snprintf )
2131 dnl ---------------------------------------------------------------------------
2132 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
2133 dnl ------------------
2134 dnl Configure-option to enable gcc warnings
2136 dnl $1 = extra options to add, if supported
2137 dnl $2 = option for checking attributes. By default, this is done when
2138 dnl warnings are enabled. For other values:
2139 dnl yes: always do this, e.g., to use in generated library-headers
2140 dnl no: never do this
2141 AC_DEFUN([CF_ENABLE_WARNINGS],[
2142 if test "$GCC" = yes || test "$GXX" = yes
2144 CF_FIX_WARNINGS(CFLAGS)
2145 CF_FIX_WARNINGS(CPPFLAGS)
2146 CF_FIX_WARNINGS(LDFLAGS)
2147 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2148 CF_ARG_ENABLE(warnings,
2149 [ --enable-warnings test: turn on gcc compiler warnings],
2150 [enable_warnings=yes],
2151 [enable_warnings=no])
2152 AC_MSG_RESULT($enable_warnings)
2153 if test "$enable_warnings" = "yes"
2155 ifelse($2,,[CF_GCC_ATTRIBUTES])
2158 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2161 dnl ---------------------------------------------------------------------------
2162 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2164 dnl Check if 'errno' is declared in <errno.h>
2165 AC_DEFUN([CF_ERRNO],
2167 CF_CHECK_ERRNO(errno)
2169 dnl ---------------------------------------------------------------------------
2170 dnl CF_ETIP_DEFINES version: 6 updated: 2021/01/02 17:09:14
2172 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2173 dnl math.h and builtin.h, only for ncurses
2174 AC_DEFUN([CF_ETIP_DEFINES],
2176 AC_MSG_CHECKING(for special defines needed for etip.h)
2177 cf_save_CXXFLAGS="$CXXFLAGS"
2180 # etip.h includes ncurses.h which includes ncurses_dll.h
2181 # But ncurses_dll.h is generated - fix here.
2182 test -d include || mkdir include
2183 test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' "${srcdir}/include/ncurses_dll.h.in" >include/ncurses_dll.h
2185 for cf_math in "" MATH_H
2187 for cf_excp in "" MATH_EXCEPTION
2189 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2190 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2191 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2193 #include <etip.h.in>
2195 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2196 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2197 cf_result="$cf_math $cf_excp"
2202 AC_MSG_RESULT($cf_result)
2203 CXXFLAGS="$cf_save_CXXFLAGS"
2205 dnl ---------------------------------------------------------------------------
2206 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
2208 dnl Find a library (specifically the linkage used in the code fragment),
2209 dnl searching for it if it is not already in the library path.
2210 dnl See also CF_ADD_SEARCHPATH.
2212 dnl Parameters (4-on are optional):
2213 dnl $1 = headers for library entrypoint
2214 dnl $2 = code fragment for library entrypoint
2215 dnl $3 = the library name without the "-l" option or ".so" suffix.
2216 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
2217 dnl $5 = action to perform if not successful
2218 dnl $6 = module name, if not the same as the library name
2219 dnl $7 = extra libraries
2221 dnl Sets these variables:
2222 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2223 dnl $cf_cv_header_path_$3 - include-directory if needed
2224 dnl $cf_cv_library_path_$3 - library-directory if needed
2225 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2226 AC_DEFUN([CF_FIND_LINKAGE],[
2228 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2229 # will be set on completion of the AC_TRY_LINK below.
2230 cf_cv_header_path_$3=
2231 cf_cv_library_path_$3=
2233 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2235 cf_save_LIBS="$LIBS"
2237 AC_TRY_LINK([$1],[$2],[
2238 cf_cv_find_linkage_$3=yes
2239 cf_cv_header_path_$3=/usr/include
2240 cf_cv_library_path_$3=/usr/lib
2243 LIBS="-l$3 $7 $cf_save_LIBS"
2245 AC_TRY_LINK([$1],[$2],[
2246 cf_cv_find_linkage_$3=yes
2247 cf_cv_header_path_$3=/usr/include
2248 cf_cv_library_path_$3=/usr/lib
2249 cf_cv_library_file_$3="-l$3"
2251 cf_cv_find_linkage_$3=no
2252 LIBS="$cf_save_LIBS"
2254 CF_VERBOSE(find linkage for $3 library)
2255 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2257 cf_save_CPPFLAGS="$CPPFLAGS"
2258 cf_test_CPPFLAGS="$CPPFLAGS"
2260 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2261 for cf_cv_header_path_$3 in $cf_search
2263 if test -d "$cf_cv_header_path_$3" ; then
2264 CF_VERBOSE(... testing $cf_cv_header_path_$3)
2265 CPPFLAGS="$cf_save_CPPFLAGS"
2266 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2267 AC_TRY_COMPILE([$1],[$2],[
2268 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2269 cf_cv_find_linkage_$3=maybe
2270 cf_test_CPPFLAGS="$CPPFLAGS"
2272 CPPFLAGS="$cf_save_CPPFLAGS"
2277 if test "$cf_cv_find_linkage_$3" = maybe ; then
2279 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2281 cf_save_LIBS="$LIBS"
2282 cf_save_LDFLAGS="$LDFLAGS"
2285 CPPFLAGS="$cf_test_CPPFLAGS"
2286 LIBS="-l$3 $7 $cf_save_LIBS"
2287 AC_TRY_LINK([$1],[$2],[
2288 CF_VERBOSE(... found $3 library in system)
2289 cf_cv_find_linkage_$3=yes])
2290 CPPFLAGS="$cf_save_CPPFLAGS"
2291 LIBS="$cf_save_LIBS"
2294 if test "$cf_cv_find_linkage_$3" != yes ; then
2295 CF_LIBRARY_PATH(cf_search,$3)
2296 for cf_cv_library_path_$3 in $cf_search
2298 if test -d "$cf_cv_library_path_$3" ; then
2299 CF_VERBOSE(... testing $cf_cv_library_path_$3)
2300 CPPFLAGS="$cf_test_CPPFLAGS"
2301 LIBS="-l$3 $7 $cf_save_LIBS"
2302 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2303 AC_TRY_LINK([$1],[$2],[
2304 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2305 cf_cv_find_linkage_$3=yes
2306 cf_cv_library_file_$3="-l$3"
2308 CPPFLAGS="$cf_save_CPPFLAGS"
2309 LIBS="$cf_save_LIBS"
2310 LDFLAGS="$cf_save_LDFLAGS"
2314 CPPFLAGS="$cf_save_CPPFLAGS"
2315 LDFLAGS="$cf_save_LDFLAGS"
2319 cf_cv_find_linkage_$3=no
2324 LIBS="$cf_save_LIBS"
2326 if test "$cf_cv_find_linkage_$3" = yes ; then
2328 CF_ADD_INCDIR($cf_cv_header_path_$3)
2329 CF_ADD_LIBDIR($cf_cv_library_path_$3)
2333 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2336 dnl ---------------------------------------------------------------------------
2337 dnl CF_FIND_SUB_INCDIR version: 3 updated: 2021/01/01 13:31:04
2338 dnl ------------------
2339 dnl Find an include-directory with the given leaf-name. This is useful for
2340 dnl example with FreeBSD ports, which use this convention to distinguish
2341 dnl different versions of the same port.
2342 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2343 CF_SUBDIR_PATH(cf_search,$1,include)
2344 for cf_item in $cf_search
2348 CF_ADD_INCDIR($cf_item)
2353 dnl ---------------------------------------------------------------------------
2354 dnl CF_FIND_SUB_LIBDIR version: 3 updated: 2021/01/01 13:31:04
2355 dnl ------------------
2356 dnl Find a library-directory with the given leaf-name. This is useful for
2357 dnl example with FreeBSD ports, which use this convention to distinguish
2358 dnl different versions of the same port.
2359 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2360 CF_SUBDIR_PATH(cf_search,$1,lib)
2361 for cf_item in $cf_search
2365 CF_ADD_LIBDIR($cf_item)
2370 dnl ---------------------------------------------------------------------------
2371 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2372 dnl -----------------
2373 dnl make ADAFLAGS consistent with CFLAGS
2374 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2375 AC_MSG_CHECKING(optimization options for ADAFLAGS)
2383 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
2384 CF_ADD_ADAFLAGS($cf_O_flag)
2387 AC_MSG_RESULT($ADAFLAGS)
2389 dnl ---------------------------------------------------------------------------
2390 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
2392 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
2393 dnl "-Werror" flags can interfere with configure-checks. Those go into
2396 dnl $1 = variable name to repair
2397 define([CF_FIX_WARNINGS],[
2398 if test "$GCC" = yes || test "$GXX" = yes
2402 CF_VERBOSE(repairing $1: [$]$1)
2404 for cf_temp_scan in [$]$1
2406 case "x$cf_temp_scan" in
2408 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
2411 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
2416 CF_VERBOSE(... fixed [$]$1)
2417 CF_VERBOSE(... extra $EXTRA_CFLAGS)
2421 AC_SUBST(EXTRA_CFLAGS)
2423 dnl ---------------------------------------------------------------------------
2424 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2426 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2427 dnl parameter. POSIX ignores the "b", which c89 specified. Some very old
2428 dnl systems do not accept it.
2429 AC_DEFUN([CF_FOPEN_BIN_R],[
2430 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2434 FILE *fp = fopen("conftest.tmp", "wb");
2438 for (p = 0; p < 256; ++p) {
2442 fp = fopen("conftest.tmp", "rb");
2444 for (p = 0; p < 256; ++p) {
2457 ${cf_cv_main_return:-return} (rc);
2460 [cf_cv_fopen_bin_r=yes],
2461 [cf_cv_fopen_bin_r=no],
2462 [cf_cv_fopen_bin_r=unknown])
2464 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2466 dnl ---------------------------------------------------------------------------
2467 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2469 dnl Forget that we saw the given tool.
2470 AC_DEFUN([CF_FORGET_TOOL],[
2471 unset ac_cv_prog_ac_ct_$1
2475 dnl ---------------------------------------------------------------------------
2476 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2478 dnl Test for dlsym() and related functions, as well as libdl.
2483 AC_DEFUN([CF_FUNC_DLSYM],[
2485 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2488 AC_CHECK_LIB(dl,dlsym,[
2490 cf_have_libdl=yes])])
2492 if test "$cf_have_dlsym" = yes ; then
2493 test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2495 AC_MSG_CHECKING(whether able to link to dl*() functions)
2496 AC_TRY_LINK([#include <dlfcn.h>],[
2498 if ((obj = dlopen("filename", 0)) != 0) {
2499 if (dlsym(obj, "symbolname") == 0) {
2503 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2504 AC_MSG_ERROR(Cannot link test program for libdl)])
2507 AC_MSG_ERROR(Cannot find dlsym function)
2510 dnl ---------------------------------------------------------------------------
2511 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2513 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
2514 dnl is found, add our own version of memmove to the list of objects.
2515 AC_DEFUN([CF_FUNC_MEMMOVE],
2517 AC_CHECK_FUNC(memmove,,[
2518 AC_CHECK_FUNC(bcopy,[
2519 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2522 static char data[] = "abcdefghijklmnopqrstuwwxyz";
2524 bcopy(data, temp, sizeof(data));
2525 bcopy(temp+10, temp, 15);
2526 bcopy(temp+5, temp+15, 10);
2527 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2530 [cf_cv_good_bcopy=yes],
2531 [cf_cv_good_bcopy=no],
2532 [cf_cv_good_bcopy=unknown])
2534 ],[cf_cv_good_bcopy=no])
2535 if test "$cf_cv_good_bcopy" = yes ; then
2536 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2538 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2541 dnl ---------------------------------------------------------------------------
2542 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2543 dnl -----------------
2544 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
2545 dnl AIX 4.x, provide a non-working version.
2546 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2547 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2553 #ifdef HAVE_SYS_TIME_H
2554 #include <sys/time.h>
2558 struct timespec ts1, ts2;
2561 ts1.tv_nsec = 750000000;
2565 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2566 ${cf_cv_main_return:-return}(code != 0);
2569 [cf_cv_func_nanosleep=yes],
2570 [cf_cv_func_nanosleep=no],
2571 [cf_cv_func_nanosleep=unknown])])
2573 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2575 dnl ---------------------------------------------------------------------------
2576 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
2578 dnl Check for openpty() function, along with <pty.h> header. It may need the
2579 dnl "util" library as well.
2580 AC_DEFUN([CF_FUNC_OPENPTY],
2582 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2583 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2584 cf_save_LIBS="$LIBS"
2585 test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
2586 for cf_header in pty.h libutil.h util.h
2589 #include <$cf_header>
2591 int x = openpty((int *)0, (int *)0, (char *)0,
2592 (struct termios *)0, (struct winsize *)0);
2594 cf_cv_func_openpty=$cf_header
2597 cf_cv_func_openpty=no
2600 LIBS="$cf_save_LIBS"
2603 dnl ---------------------------------------------------------------------------
2604 dnl CF_FUNC_POLL version: 10 updated: 2021/01/04 19:13:57
2606 dnl See if the poll function really works. Some platforms have poll(), but
2607 dnl it does not work for terminals or files.
2608 AC_DEFUN([CF_FUNC_POLL],[
2609 tty >/dev/null 2>&1 || { AC_CHECK_FUNCS(posix_openpt) }
2610 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2619 #include <sys/poll.h>
2622 struct pollfd myfds;
2625 /* check for Darwin bug with respect to "devices" */
2626 myfds.fd = open("/dev/null", 1); /* O_WRONLY */
2629 myfds.events = POLLIN;
2632 ret = poll(&myfds, 1, 100);
2634 if (ret < 0 || (myfds.revents & POLLNVAL)) {
2639 fd = open("/dev/tty", 2); /* O_RDWR */
2641 #ifdef HAVE_POSIX_OPENPT
2643 fd = posix_openpt(O_RDWR);
2648 /* also check with standard input */
2650 myfds.events = POLLIN;
2652 ret = poll(&myfds, 1, 100);
2657 ${cf_cv_main_return:-return}(ret < 0);
2659 [cf_cv_working_poll=yes],
2660 [cf_cv_working_poll=no],
2661 [cf_cv_working_poll=unknown])])
2662 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2664 dnl ---------------------------------------------------------------------------
2665 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2667 dnl Some old/broken variations define tcgetattr() only as a macro in
2669 AC_DEFUN([CF_FUNC_TERMIOS],[
2670 AC_REQUIRE([CF_STRUCT_TERMIOS])
2671 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2673 #include <sys/types.h>
2674 #ifdef HAVE_UNISTD_H
2677 #ifdef HAVE_TERMIOS_H
2678 #include <termios.h>
2679 #define TTY struct termios
2681 #ifdef HAVE_TERMIO_H
2683 #define TTY struct termio
2688 tcgetattr(1, &foo);],
2689 [cf_cv_have_tcgetattr=yes],
2690 [cf_cv_have_tcgetattr=no])])
2691 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2693 dnl ---------------------------------------------------------------------------
2694 dnl CF_FUNC_VSSCANF version: 7 updated: 2021/01/01 13:31:04
2696 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2697 dnl versions of C. It is in the GNU C library, and can often be simulated by
2698 dnl other functions.
2699 AC_DEFUN([CF_FUNC_VSSCANF],
2701 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2704 #include <stdio.h>],[
2706 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2709 #include <stdio.h>],[
2713 strbuf._flag = _IOREAD;
2714 strbuf._ptr = strbuf._base = (unsigned char *) str;
2715 strbuf._cnt = strlen(str);
2716 strbuf._file = _NFILE;
2717 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2720 #include <stdio.h>],[
2724 strbuf._flag = _IOREAD;
2725 strbuf._ptr = strbuf._base = (unsigned char *) str;
2726 strbuf._cnt = strlen(str);
2727 strbuf._file = _NFILE;
2728 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2729 cf_cv_func_vsscanf=no])])])])
2731 case "$cf_cv_func_vsscanf" in
2732 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2733 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2734 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2738 dnl ---------------------------------------------------------------------------
2739 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
2740 dnl -----------------
2741 dnl Test for availability of useful gcc __attribute__ directives to quiet
2742 dnl compiler warnings. Though useful, not all are supported -- and contrary
2743 dnl to documentation, unrecognized directives cause older compilers to barf.
2744 AC_DEFUN([CF_GCC_ATTRIBUTES],
2745 [AC_REQUIRE([AC_PROG_FGREP])dnl
2746 AC_REQUIRE([CF_C11_NORETURN])dnl
2748 if test "$GCC" = yes || test "$GXX" = yes
2750 cat > conftest.i <<EOF
2752 #define GCC_PRINTF 0
2757 #ifndef GCC_NORETURN
2758 #define GCC_NORETURN /* nothing */
2761 #define GCC_UNUSED /* nothing */
2764 if test "$GCC" = yes
2766 AC_CHECKING([for $CC __attribute__ directives])
2767 cat > "conftest.$ac_ext" <<EOF
2768 #line __oline__ "${as_me:-configure}"
2769 #include "confdefs.h"
2770 #include "conftest.h"
2771 #include "conftest.i"
2773 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2775 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2778 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
2780 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
2782 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2783 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
2784 extern GCC_NORETURN void foo(void);
2785 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2787 cf_printf_attribute=no
2788 cf_scanf_attribute=no
2789 for cf_attribute in scanf printf unused noreturn
2791 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2792 cf_directive="__attribute__(($cf_attribute))"
2793 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2795 case "$cf_attribute" in
2797 cf_printf_attribute=yes
2798 cat >conftest.h <<EOF
2799 #define GCC_$cf_ATTRIBUTE 1
2803 cf_scanf_attribute=yes
2804 cat >conftest.h <<EOF
2805 #define GCC_$cf_ATTRIBUTE 1
2809 cat >conftest.h <<EOF
2810 #define GCC_$cf_ATTRIBUTE $cf_directive
2815 if AC_TRY_EVAL(ac_compile); then
2816 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2817 cat conftest.h >>confdefs.h
2818 case "$cf_attribute" in
2820 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2823 cf_value='/* nothing */'
2824 if test "$cf_printf_attribute" != no ; then
2825 cf_value='__attribute__((format(printf,fmt,var)))'
2826 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2828 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2831 cf_value='/* nothing */'
2832 if test "$cf_scanf_attribute" != no ; then
2833 cf_value='__attribute__((format(scanf,fmt,var)))'
2834 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2836 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2839 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2845 ${FGREP-fgrep} define conftest.i >>confdefs.h
2850 dnl ---------------------------------------------------------------------------
2851 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2853 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2854 dnl compatible), attempt to determine if icc/clang is actually used.
2855 AC_DEFUN([CF_GCC_VERSION],[
2856 AC_REQUIRE([AC_PROG_CC])
2858 if test "$GCC" = yes ; then
2859 AC_MSG_CHECKING(version of $CC)
2860 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.]].*//'`"
2861 test -z "$GCC_VERSION" && GCC_VERSION=unknown
2862 AC_MSG_RESULT($GCC_VERSION)
2864 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2865 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2867 dnl ---------------------------------------------------------------------------
2868 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
2870 dnl Check if the compiler supports useful warning options. There's a few that
2871 dnl we don't use, simply because they're too noisy:
2873 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2874 dnl -Winline (usually not worthwhile)
2875 dnl -Wredundant-decls (system headers make this too noisy)
2876 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
2877 dnl -Wwrite-strings (too noisy, but should review occasionally). This
2878 dnl is enabled for ncurses using "--enable-const".
2882 dnl $1 is an optional list of gcc warning flags that a particular
2883 dnl application might want to use, e.g., "no-unused" for
2886 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2888 AC_DEFUN([CF_GCC_WARNINGS],
2890 AC_REQUIRE([CF_GCC_VERSION])
2891 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
2892 cat > "conftest.$ac_ext" <<EOF
2893 #line __oline__ "${as_me:-configure}"
2894 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2896 if test "$INTEL_COMPILER" = yes
2898 # The "-wdXXX" options suppress warnings:
2899 # remark #1419: external declaration in primary source file
2900 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2901 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2902 # remark #193: zero used for undefined preprocessing identifier
2903 # remark #593: variable "curs_sb_left_arrow" was set but never used
2904 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2905 # remark #869: parameter "tw" was never referenced
2906 # remark #981: operands are evaluated in unspecified order
2907 # warning #279: controlling expression is constant
2909 AC_CHECKING([for $CC warning options])
2910 cf_save_CFLAGS="$CFLAGS"
2911 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
2923 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2924 if AC_TRY_EVAL(ac_compile); then
2925 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2926 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2929 CFLAGS="$cf_save_CFLAGS"
2930 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
2932 AC_CHECKING([for $CC warning options])
2933 cf_save_CFLAGS="$CFLAGS"
2935 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2936 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2937 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2938 for cf_opt in W Wall \
2939 Wbad-function-cast \
2942 Wdeclaration-after-statement \
2945 Wmissing-declarations \
2946 Wmissing-prototypes \
2950 Wstrict-prototypes \
2951 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
2953 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2954 if AC_TRY_EVAL(ac_compile); then
2955 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2958 case "$GCC_VERSION" in
2960 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2965 case "$GCC_VERSION" in
2967 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2972 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2975 CFLAGS="$cf_save_CFLAGS"
2979 AC_SUBST(EXTRA_CFLAGS)
2981 dnl ---------------------------------------------------------------------------
2982 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
2983 dnl ----------------
2984 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2985 dnl unistd.h or (nonstandard) in getopt.h
2986 AC_DEFUN([CF_GETOPT_HEADER],
2988 AC_HAVE_HEADERS(unistd.h getopt.h)
2989 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2990 cf_cv_getopt_header=none
2991 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2994 #include <$cf_header>],
2995 [int x = optind; char *y = optarg; (void)x; (void)y],
2996 [cf_cv_getopt_header=$cf_header
3000 if test "$cf_cv_getopt_header" != none ; then
3001 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
3003 if test "$cf_cv_getopt_header" = getopt.h ; then
3004 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
3007 dnl ---------------------------------------------------------------------------
3008 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
3009 dnl -----------------
3010 AC_DEFUN([CF_GNATPREP_OPT_T],[
3011 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
3012 cf_cv_gnatprep_opt_t=no
3013 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
3015 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
3016 AC_SUBST(GNATPREP_OPTS)
3018 dnl ---------------------------------------------------------------------------
3019 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
3020 dnl ----------------
3021 AC_DEFUN([CF_GNAT_GENERICS],
3023 AC_REQUIRE([CF_GNAT_VERSION])
3025 AC_MSG_CHECKING(if GNAT supports generics)
3026 case "$cf_cv_gnat_version" in
3027 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
3028 cf_gnat_generics=yes
3034 AC_MSG_RESULT($cf_gnat_generics)
3036 if test "$cf_gnat_generics" = yes
3038 cf_compile_generics=generics
3039 cf_generic_objects="\${GENOBJS}"
3041 cf_compile_generics=
3045 AC_SUBST(cf_compile_generics)
3046 AC_SUBST(cf_generic_objects)
3048 dnl ---------------------------------------------------------------------------
3049 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
3050 dnl ----------------
3051 dnl GNAT projects are configured with ".gpr" project files.
3052 dnl GNAT libraries are a further development, using the project feature.
3053 AC_DEFUN([CF_GNAT_PROJECTS],
3055 AC_REQUIRE([CF_GNAT_VERSION])
3056 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
3058 cf_gnat_libraries=no
3061 if test "$enable_gnat_projects" != no ; then
3062 AC_MSG_CHECKING(if GNAT supports project files)
3063 case "$cf_cv_gnat_version" in
3067 case "$cf_cv_system_name" in
3071 rm -rf ./conftest* ./*~conftest*
3072 if mkdir conftest.src conftest.bin conftest.lib
3075 rm -rf ./conftest* ./*~conftest*
3076 cat >>library.gpr <<CF_EOF
3078 Kind := External ("LIB_KIND");
3079 for Library_Name use "ConfTest";
3080 for Object_Dir use ".";
3081 for Library_ALI_Dir use External("LIBRARY_DIR");
3082 for Library_Version use External ("SONAME");
3083 for Library_Kind use Kind;
3084 for Library_Dir use External("BUILD_DIR");
3085 Source_Dir := External ("SOURCE_DIR");
3086 for Source_Dirs use (Source_Dir);
3089 cat >>confpackage.ads <<CF_EOF
3090 package ConfPackage is
3094 cat >>confpackage.adb <<CF_EOF
3096 package body ConfPackage is
3097 procedure conftest is
3099 Text_IO.Put ("Hello World");
3104 if ( "$cf_ada_make" $ADAFLAGS \
3106 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
3107 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
3108 -XSOURCE_DIR="`pwd`" \
3109 -XSONAME=libConfTest.so.1 \
3110 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
3111 cf_gnat_projects=yes
3115 if test -f conftest.lib/confpackage.ali
3117 cf_gnat_libraries=yes
3119 rm -rf ./conftest* ./*~conftest*
3124 AC_MSG_RESULT($cf_gnat_projects)
3125 fi # enable_gnat_projects
3127 if test "$cf_gnat_projects" = yes
3129 AC_MSG_CHECKING(if GNAT supports libraries)
3130 AC_MSG_RESULT($cf_gnat_libraries)
3133 USE_OLD_MAKERULES=""
3134 USE_GNAT_PROJECTS="#"
3135 USE_GNAT_MAKE_GPR="#"
3136 USE_GNAT_GPRBUILD="#"
3138 if test "$cf_gnat_projects" = yes
3140 USE_OLD_MAKERULES="#"
3141 USE_GNAT_PROJECTS=""
3142 if test "$cf_cv_VERSION_GPRBUILD" != no
3144 USE_GNAT_GPRBUILD=""
3145 elif test "$cf_cv_VERSION_GNATMAKE" != no
3147 USE_GNAT_MAKE_GPR=""
3149 AC_MSG_WARN(use old makefile rules since tools are missing)
3153 if test "$cf_gnat_libraries" = yes
3155 USE_GNAT_LIBRARIES=""
3157 USE_GNAT_LIBRARIES="#"
3160 AC_SUBST(USE_OLD_MAKERULES)
3161 AC_SUBST(USE_GNAT_PROJECTS)
3162 AC_SUBST(USE_GNAT_LIBRARIES)
3163 AC_SUBST(USE_GNAT_MAKE_GPR)
3164 AC_SUBST(USE_GNAT_GPRBUILD)
3166 dnl ---------------------------------------------------------------------------
3167 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
3169 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
3170 dnl is noted that gnat may compile a tasking unit even for configurations which
3171 dnl fail at runtime.
3172 AC_DEFUN([CF_GNAT_SIGINT],[
3173 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3174 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3178 pragma Warnings (Off); -- the next pragma exists since 3.11p
3179 pragma Unreserve_All_Interrupts;
3180 pragma Warnings (On);
3182 protected Process is
3184 function Continue return Boolean;
3185 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3187 Done : Boolean := False;
3191 [package body ConfTest is
3192 protected body Process is
3197 function Continue return Boolean is
3203 [cf_cv_gnat_sigint=yes],
3204 [cf_cv_gnat_sigint=no])])
3206 if test "$cf_cv_gnat_sigint" = yes ; then
3211 AC_SUBST(USE_GNAT_SIGINT)
3213 dnl ---------------------------------------------------------------------------
3214 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
3215 dnl ----------------
3216 dnl Verify that a test program compiles/links with GNAT.
3217 dnl $cf_ada_make is set to the program that compiles/links
3218 dnl $ADAFLAGS may be set to the GNAT flags.
3220 dnl $1 is the text of the spec
3221 dnl $2 is the text of the body
3222 dnl $3 is the shell command to execute if successful
3223 dnl $4 is the shell command to execute if not successful
3224 AC_DEFUN([CF_GNAT_TRY_LINK],
3226 rm -rf ./conftest* ./*~conftest*
3227 cat >>conftest.ads <<CF_EOF
3230 cat >>conftest.adb <<CF_EOF
3233 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3234 ifelse($3,, :,[ $3])
3238 rm -rf ./conftest* ./*~conftest*
3240 dnl ---------------------------------------------------------------------------
3241 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
3243 dnl Verify that a test program compiles and runs with GNAT
3244 dnl $cf_ada_make is set to the program that compiles/links
3245 dnl $ADAFLAGS may be set to the GNAT flags.
3247 dnl $1 is the text of the spec
3248 dnl $2 is the text of the body
3249 dnl $3 is the shell command to execute if successful
3250 dnl $4 is the shell command to execute if not successful
3251 AC_DEFUN([CF_GNAT_TRY_RUN],
3253 rm -rf ./conftest* ./*~conftest*
3254 cat >>conftest.ads <<CF_EOF
3257 cat >>conftest.adb <<CF_EOF
3260 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3261 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3262 ifelse($3,, :,[ $3])
3269 rm -rf ./conftest* ./*~conftest*
3271 dnl ---------------------------------------------------------------------------
3272 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3274 dnl $1 = cache variable to update
3275 dnl $2 = program name
3276 dnl Verify version of GNAT or related tool
3277 AC_DEFUN([CF_GNAT_VERSION],
3279 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3280 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3281 grep '[[0-9]].[[0-9]][[0-9]]*' |\
3282 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3284 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3285 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3287 dnl ---------------------------------------------------------------------------
3288 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3290 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3291 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
3292 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3293 dnl since it is interwoven with GNU extensions.
3295 dnl Well, yes we could work around it...
3298 dnl $1 is the nominal value for _XOPEN_SOURCE
3299 AC_DEFUN([CF_GNU_SOURCE],
3301 cf_gnu_xopen_source=ifelse($1,,500,$1)
3303 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3304 AC_TRY_COMPILE([#include <sys/types.h>],[
3305 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3307 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3310 # error not GNU C library
3312 [cf_cv_gnu_library=yes],
3313 [cf_cv_gnu_library=no])
3316 if test x$cf_cv_gnu_library = xyes; then
3318 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3319 # was changed to help a little. newlib incorporated the change about 4
3321 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3323 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3324 AC_TRY_COMPILE([#include <sys/types.h>],[
3325 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3327 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3330 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3332 [cf_cv_gnu_library_219=yes],
3333 [cf_cv_gnu_library_219=no])
3337 if test "x$cf_cv_gnu_library_219" = xyes; then
3339 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3340 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3343 #include <sys/types.h>
3345 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3348 # error GNU C library is too old
3350 [cf_cv_gnu_dftsrc_219=yes],
3351 [cf_cv_gnu_dftsrc_219=no])
3353 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3355 cf_cv_gnu_dftsrc_219=maybe
3358 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3360 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3361 AC_TRY_COMPILE([#include <sys/types.h>],[
3362 #ifndef _XOPEN_SOURCE
3363 #error expected _XOPEN_SOURCE to be defined
3365 [cf_cv_gnu_source=no],
3366 [cf_save="$CPPFLAGS"
3367 CF_ADD_CFLAGS(-D_GNU_SOURCE)
3368 AC_TRY_COMPILE([#include <sys/types.h>],[
3369 #ifdef _XOPEN_SOURCE
3370 #error expected _XOPEN_SOURCE to be undefined
3372 [cf_cv_gnu_source=no],
3373 [cf_cv_gnu_source=yes])
3378 if test "$cf_cv_gnu_source" = yes
3380 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3381 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3382 AC_TRY_COMPILE([#include <sys/types.h>],[
3383 #ifdef _DEFAULT_SOURCE
3384 #error expected _DEFAULT_SOURCE to be undefined
3386 [cf_cv_default_source=no],
3387 [cf_cv_default_source=yes])
3389 if test "$cf_cv_default_source" = yes
3391 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3398 dnl ---------------------------------------------------------------------------
3399 dnl CF_GPP_LIBRARY version: 13 updated: 2021/01/01 13:31:04
3401 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3402 dnl problem :-). If we have the compiler but no library, we'll be able to
3403 dnl configure, but won't be able to build the c++ demo program.
3404 AC_DEFUN([CF_GPP_LIBRARY],
3406 cf_cxx_library=unknown
3407 case "$cf_cv_system_name" in
3415 if test "$GXX" = yes; then
3416 AC_MSG_CHECKING([for lib$cf_gpp_libname])
3418 CF_ADD_LIB($cf_gpp_libname)
3420 #include <$cf_gpp_libname/builtin.h>
3422 [two_arg_error_handler_t foo2 = lib_error_handler],
3424 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3425 if test "$cf_gpp_libname" = cpp ; then
3426 AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3428 AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3431 #include <builtin.h>
3433 [two_arg_error_handler_t foo2 = lib_error_handler],
3435 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3436 AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3437 [cf_cxx_library=no])])
3439 AC_MSG_RESULT($cf_cxx_library)
3442 dnl ---------------------------------------------------------------------------
3443 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3445 dnl Check for version of g++
3446 AC_DEFUN([CF_GXX_VERSION],[
3447 AC_REQUIRE([AC_PROG_CPP])
3449 if test "$GXX" = yes; then
3450 AC_MSG_CHECKING(version of ${CXX:-g++})
3451 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3452 if test -z "$GXX_VERSION"
3457 AC_MSG_RESULT($GXX_VERSION)
3460 dnl ---------------------------------------------------------------------------
3461 dnl CF_GXX_WARNINGS version: 11 updated: 2021/01/08 16:50:55
3463 dnl Check if the compiler supports useful warning options.
3465 dnl Most of gcc's options apply to g++, except:
3466 dnl -Wbad-function-cast
3467 dnl -Wmissing-declarations
3468 dnl -Wnested-externs
3470 dnl Omit a few (for now):
3474 dnl $1 is an optional list of g++ warning flags that a particular
3475 dnl application might want to use, e.g., "no-unused" for
3478 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
3480 AC_DEFUN([CF_GXX_WARNINGS],
3483 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3484 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3486 AC_REQUIRE([CF_GXX_VERSION])
3491 cat > conftest.$ac_ext <<EOF
3492 #line __oline__ "configure"
3493 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3496 if test "$INTEL_CPLUSPLUS" = yes
3498 # The "-wdXXX" options suppress warnings:
3499 # remark #1419: external declaration in primary source file
3500 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3501 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3502 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3503 # remark #193: zero used for undefined preprocessing identifier
3504 # remark #593: variable "curs_sb_left_arrow" was set but never used
3505 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3506 # remark #869: parameter "tw" was never referenced
3507 # remark #981: operands are evaluated in unspecified order
3508 # warning #269: invalid format string conversion
3510 AC_CHECKING([for $CC warning options])
3511 cf_save_CXXFLAGS="$CXXFLAGS"
3512 EXTRA_CXXFLAGS="-Wall"
3525 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3526 if AC_TRY_EVAL(ac_compile); then
3527 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3528 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3531 CXXFLAGS="$cf_save_CXXFLAGS"
3533 elif test "$GXX" = yes
3535 AC_CHECKING([for $CXX warning options])
3536 cf_save_CXXFLAGS="$CXXFLAGS"
3537 EXTRA_CXXFLAGS="-W -Wall"
3538 cf_gxx_extra_warnings=""
3539 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3540 case "$GXX_VERSION" in
3544 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3551 Wignored-qualifiers \
3553 Woverloaded-virtual \
3561 Wundef $cf_gxx_extra_warnings $1
3563 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3564 if AC_TRY_EVAL(ac_compile); then
3565 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3566 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3568 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3571 CXXFLAGS="$cf_save_CXXFLAGS"
3576 AC_SUBST(EXTRA_CXXFLAGS)
3578 dnl ---------------------------------------------------------------------------
3579 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3581 dnl Look for an instance of the Berkeley hashed database.
3583 dnl $1 = optional parameter, to specify install-prefix for the database.
3584 AC_DEFUN([CF_HASHED_DB],
3591 if test -d "$1" ; then
3592 CF_ADD_INCDIR($1/include)
3593 CF_ADD_LIBDIR($1/lib)
3597 AC_MSG_WARN(no such directory $1)
3600 CF_FIND_SUB_INCDIR($1)
3601 CF_FIND_SUB_LIBDIR($1)
3607 AC_CHECK_HEADER(db.h,[
3608 CF_HASHED_DB_VERSION
3609 if test "$cf_cv_hashed_db_version" = unknown ; then
3610 AC_MSG_ERROR(Cannot determine version of db)
3613 if test "$cf_cv_hashed_db_libs" = unknown ; then
3614 AC_MSG_ERROR(Cannot determine library for db)
3615 elif test "$cf_cv_hashed_db_libs" != default ; then
3616 CF_ADD_LIB($cf_cv_hashed_db_libs)
3620 AC_MSG_ERROR(Cannot find db.h)
3623 dnl ---------------------------------------------------------------------------
3624 dnl CF_HASHED_DB_LIBS version: 10 updated: 2021/01/02 17:09:14
3625 dnl -----------------
3626 dnl Given that we have the header and version for hashed database, find the
3627 dnl library information.
3628 AC_DEFUN([CF_HASHED_DB_LIBS],
3630 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3631 cf_cv_hashed_db_libs=unknown
3632 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3634 cf_save_libs="$LIBS"
3635 if test -n "$cf_db_libs"; then
3636 CF_ADD_LIB($cf_db_libs)
3638 CF_MSG_LOG(checking for library $cf_db_libs)
3640 $ac_includes_default
3643 char *path = "/tmp/foo";
3644 #ifdef DB_VERSION_MAJOR
3645 #if DB_VERSION_MAJOR >= 4
3647 db_create(&result, NULL, 0);
3648 result->open(result,
3655 #elif DB_VERSION_MAJOR >= 3
3657 db_create(&result, NULL, 0);
3658 result->open(result,
3664 #elif DB_VERSION_MAJOR >= 2
3673 #endif /* DB_VERSION_MAJOR */
3675 DB *result = dbopen(path,
3681 ${cf_cv_main_return:-return}(result != 0)
3683 if test -n "$cf_db_libs" ; then
3684 cf_cv_hashed_db_libs=$cf_db_libs
3686 cf_cv_hashed_db_libs=default
3688 LIBS="$cf_save_libs"
3691 LIBS="$cf_save_libs"
3695 dnl ---------------------------------------------------------------------------
3696 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3697 dnl --------------------
3698 dnl Given that we have the header file for hashed database, find the version
3700 AC_DEFUN([CF_HASHED_DB_VERSION],
3702 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3703 cf_cv_hashed_db_version=unknown
3705 for cf_db_version in 1 2 3 4 5 6
3707 CF_MSG_LOG(checking for db version $cf_db_version)
3709 $ac_includes_default
3712 #ifdef DB_VERSION_MAJOR
3713 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3714 #if $cf_db_version == DB_VERSION_MAJOR
3720 #if $cf_db_version == 1
3721 /* ok: assuming this is DB 1.8.5 */
3727 cf_cv_hashed_db_version=$cf_db_version
3733 dnl ---------------------------------------------------------------------------
3734 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
3736 dnl Construct a search-list of directories for a nonstandard header-file
3739 dnl $1 = the variable to return as result
3740 dnl $2 = the package name
3741 AC_DEFUN([CF_HEADER_PATH],
3745 # collect the current set of include-directories from compiler flags
3746 cf_header_path_list=""
3747 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3748 for cf_header_path in $CPPFLAGS $CFLAGS
3750 case "$cf_header_path" in
3752 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3753 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)