1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey *
3 dnl Copyright 2003-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 $Id: aclocal.m4,v 1.198 2021/08/28 20:30:56 tom Exp $
32 dnl Author: Thomas E. Dickey
34 dnl Macros used in NCURSES test programs auto-configuration script.
36 dnl These macros are maintained separately from NCURSES. The copyright on
37 dnl this file applies to the aggregation of macros and does not affect use of
38 dnl these macros in other applications.
40 dnl See these pages for additional information:
41 dnl https://invisible-island.net/autoconf/
42 dnl https://invisible-island.net/autoconf/my-autoconf.html
44 dnl ---------------------------------------------------------------------------
45 dnl ---------------------------------------------------------------------------
46 dnl AM_LANGINFO_CODESET version: 6 updated: 2021/01/01 16:53:59
47 dnl -------------------
48 dnl Inserted as requested by gettext 0.10.40
49 dnl File from /usr/share/aclocal
51 dnl ====================
54 dnl From Bruno Haible.
55 AC_DEFUN([AM_LANGINFO_CODESET],
57 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
58 [AC_TRY_LINK([#include <langinfo.h>],
59 [char* cs = nl_langinfo(CODESET); (void)cs],
60 am_cv_langinfo_codeset=yes,
61 am_cv_langinfo_codeset=no)
63 if test "$am_cv_langinfo_codeset" = yes; then
64 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
65 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
68 dnl ---------------------------------------------------------------------------
69 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
70 dnl ------------------
71 dnl Conditionally generate script according to whether we're using a given autoconf.
73 dnl $1 = version to compare against
74 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
75 dnl $3 = code to use if AC_ACVERSION is older than $1.
76 define([CF_ACVERSION_CHECK],
78 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
79 ifdef([m4_version_compare],
80 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
81 [CF_ACVERSION_COMPARE(
82 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
83 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
84 dnl ---------------------------------------------------------------------------
85 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
86 dnl --------------------
87 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
88 dnl MAJOR2, MINOR2, TERNARY2,
89 dnl PRINTABLE2, not FOUND, FOUND)
90 define([CF_ACVERSION_COMPARE],
91 [ifelse(builtin([eval], [$2 < $5]), 1,
92 [ifelse([$8], , ,[$8])],
93 [ifelse([$9], , ,[$9])])])dnl
94 dnl ---------------------------------------------------------------------------
95 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
97 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
99 dnl $2 = if given makes this macro verbose.
101 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
102 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
103 dnl confused by the quotes (which require backslashes to keep them usable).
104 AC_DEFUN([CF_ADD_CFLAGS],
109 cf_new_extra_cppflags=
111 for cf_add_cflags in $1
113 case "$cf_fix_cppflags" in
115 case "$cf_add_cflags" in
116 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
117 case "$cf_add_cflags" in
119 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
121 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
122 && test -z "${cf_tst_cflags}" \
123 && cf_fix_cppflags=yes
125 if test "$cf_fix_cppflags" = yes ; then
126 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
128 elif test "${cf_tst_cflags}" = "\"'" ; then
129 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
138 case "$cf_add_cflags" in
140 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
141 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
144 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
149 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
154 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
156 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
158 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
159 && test -z "${cf_tst_cflags}" \
160 && cf_fix_cppflags=no
165 if test -n "$cf_new_cflags" ; then
166 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
167 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
170 if test -n "$cf_new_cppflags" ; then
171 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
172 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
175 if test -n "$cf_new_extra_cppflags" ; then
176 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
177 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
180 AC_SUBST(EXTRA_CPPFLAGS)
183 dnl ---------------------------------------------------------------------------
184 dnl CF_ADD_INCDIR version: 16 updated: 2020/12/31 20:19:42
186 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
187 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
188 dnl but old versions (and some misinstalled ones) need that. To make things
189 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
190 dnl the include-path).
191 AC_DEFUN([CF_ADD_INCDIR],
193 if test -n "$1" ; then
194 for cf_add_incdir in $1
196 while test "$cf_add_incdir" != /usr/include
198 if test -d "$cf_add_incdir"
201 if test -n "$CFLAGS$CPPFLAGS" ; then
202 # a loop is needed to ensure we can add subdirs of existing dirs
203 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
204 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
205 cf_have_incdir=yes; break
210 if test "$cf_have_incdir" = no ; then
211 if test "$cf_add_incdir" = /usr/local/include ; then
214 cf_save_CPPFLAGS=$CPPFLAGS
215 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
216 AC_TRY_COMPILE([#include <stdio.h>],
219 [cf_have_incdir=yes])
220 CPPFLAGS=$cf_save_CPPFLAGS
225 if test "$cf_have_incdir" = no ; then
226 CF_VERBOSE(adding $cf_add_incdir to include-path)
227 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
229 cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
230 test "$cf_top_incdir" = "$cf_add_incdir" && break
231 cf_add_incdir="$cf_top_incdir"
242 dnl ---------------------------------------------------------------------------
243 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
245 dnl Add a library, used to enforce consistency.
247 dnl $1 = library to add, without the "-l"
248 dnl $2 = variable to update (default $LIBS)
249 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
250 dnl ---------------------------------------------------------------------------
251 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
253 dnl Adds to the library-path
255 dnl Some machines have trouble with multiple -L options.
257 dnl $1 is the (list of) directory(s) to add
258 dnl $2 is the optional name of the variable to update (default LDFLAGS)
260 AC_DEFUN([CF_ADD_LIBDIR],
262 if test -n "$1" ; then
263 for cf_add_libdir in $1
265 if test "$cf_add_libdir" = /usr/lib ; then
267 elif test -d "$cf_add_libdir"
270 if test -n "$LDFLAGS$LIBS" ; then
271 # a loop is needed to ensure we can add subdirs of existing dirs
272 for cf_test_libdir in $LDFLAGS $LIBS ; do
273 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
274 cf_have_libdir=yes; break
278 if test "$cf_have_libdir" = no ; then
279 CF_VERBOSE(adding $cf_add_libdir to library-path)
280 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
286 dnl ---------------------------------------------------------------------------
287 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
289 dnl Add one or more libraries, used to enforce consistency. Libraries are
290 dnl prepended to an existing list, since their dependencies are assumed to
291 dnl already exist in the list.
293 dnl $1 = libraries to add, with the "-l", etc.
294 dnl $2 = variable to update (default $LIBS)
295 AC_DEFUN([CF_ADD_LIBS],[
296 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
299 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
301 for cf_add_1lib in $cf_add_0lib; do
302 for cf_add_2lib in $cf_add_libs; do
303 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
308 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
310 ifelse($2,,LIBS,[$2])="$cf_add_libs"
312 dnl ---------------------------------------------------------------------------
313 dnl CF_ADD_LIB_AFTER version: 3 updated: 2013/07/09 21:27:22
315 dnl Add a given library after another, e.g., following the one it satisfies a
318 dnl $1 = the first library
319 dnl $2 = its dependency
320 AC_DEFUN([CF_ADD_LIB_AFTER],[
321 CF_VERBOSE(...before $LIBS)
322 LIBS=`echo "$LIBS" | sed -e "s/[[ ]][[ ]]*/ /g" -e "s%$1 %$1 $2 %" -e 's% % %g'`
323 CF_VERBOSE(...after $LIBS)
325 dnl ---------------------------------------------------------------------------
326 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
327 dnl ------------------
328 dnl Append to a search-list for a nonstandard header/lib-file
329 dnl $1 = the variable to return as result
330 dnl $2 = the package name
331 dnl $3 = the subdirectory, e.g., bin, include or lib
332 dnl $4 = the directory under which we will test for subdirectories
333 dnl $5 = a directory that we do not want $4 to match
334 AC_DEFUN([CF_ADD_SUBDIR_PATH],
336 test "x$4" != "x$5" && \
338 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
339 test -n "$verbose" && echo " ... testing for $3-directories under $4"
340 test -d "$4/$3" && $1="[$]$1 $4/$3"
341 test -d "$4/$3/$2" && $1="[$]$1 $4/$3/$2"
342 test -d "$4/$3/$2/$3" && $1="[$]$1 $4/$3/$2/$3"
343 test -d "$4/$2/$3" && $1="[$]$1 $4/$2/$3"
344 test -d "$4/$2/$3/$2" && $1="[$]$1 $4/$2/$3/$2"
347 dnl ---------------------------------------------------------------------------
348 dnl CF_APPEND_CFLAGS version: 1 updated: 2021/08/28 15:20:37
350 dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions.
351 dnl $1 = flags to add
352 dnl $2 = if given makes this macro verbose.
353 define([CF_APPEND_CFLAGS],
355 for cf_add_cflags in $1
357 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2])
358 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2])
360 CF_ADD_CFLAGS([$1],[$2])
362 dnl ---------------------------------------------------------------------------
363 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
365 dnl use this macro for appending text without introducing an extra blank at
367 define([CF_APPEND_TEXT],
369 test -n "[$]$1" && $1="[$]$1 "
372 dnl ---------------------------------------------------------------------------
373 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
375 dnl Allow user to disable a normally-on option.
376 AC_DEFUN([CF_ARG_DISABLE],
377 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
378 dnl ---------------------------------------------------------------------------
379 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
381 dnl Allow user to enable a normally-off option.
382 AC_DEFUN([CF_ARG_ENABLE],
383 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
384 dnl ---------------------------------------------------------------------------
385 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
387 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
393 dnl $3 = action to perform if option is not default
394 dnl $4 = action if perform if option is default
395 dnl $5 = default option value (either 'yes' or 'no')
396 AC_DEFUN([CF_ARG_OPTION],
397 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
398 if test "$enableval" != "$5" ; then
400 ,[ $3]) ifelse([$4],,,[
403 fi],[enableval=$5 ifelse([$4],,,[
407 dnl ---------------------------------------------------------------------------
408 dnl CF_C11_NORETURN version: 3 updated: 2021/03/28 11:36:23
410 AC_DEFUN([CF_C11_NORETURN],
412 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
413 CF_ARG_ENABLE(stdnoreturn,
414 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
415 [enable_stdnoreturn=yes],
416 [enable_stdnoreturn=no])
417 AC_MSG_RESULT($enable_stdnoreturn)
419 if test $enable_stdnoreturn = yes; then
420 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
424 #include <stdnoreturn.h>
425 static _Noreturn void giveup(void) { exit(0); }
427 [if (feof(stdin)) giveup()],
428 cf_cv_c11_noreturn=yes,
429 cf_cv_c11_noreturn=no)
432 cf_cv_c11_noreturn=no,
435 if test "$cf_cv_c11_noreturn" = yes; then
436 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working])
437 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
443 AC_SUBST(HAVE_STDNORETURN_H)
444 AC_SUBST(STDC_NORETURN)
446 dnl ---------------------------------------------------------------------------
447 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
449 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
450 dnl into CC. This will not help with broken scripts that wrap the compiler
451 dnl with options, but eliminates a more common category of user confusion.
453 dnl In particular, it addresses the problem of being able to run the C
454 dnl preprocessor in a consistent manner.
456 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
457 dnl the nuisance of having inconsistent settings for compiler and preprocessor
458 dnl outweighs that limitation.
459 AC_DEFUN([CF_CC_ENV_FLAGS],
461 # This should have been defined by AC_PROG_CC
464 AC_MSG_CHECKING(\$CFLAGS variable)
467 AC_MSG_RESULT(broken)
468 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
471 for cf_arg in $cf_flags
473 CF_ADD_CFLAGS($cf_arg)
481 AC_MSG_CHECKING(\$CC variable)
484 AC_MSG_RESULT(broken)
485 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
487 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
488 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
490 for cf_arg in $cf_flags
494 CF_ADD_CFLAGS($cf_arg)
501 CF_VERBOSE(resulting CC: '$CC')
502 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
503 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
510 dnl ---------------------------------------------------------------------------
511 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
513 dnl Check if we're accidentally using a cache from a different machine.
514 dnl Derive the system name, as a check for reusing the autoconf cache.
516 dnl If we've packaged config.guess and config.sub, run that (since it does a
517 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
518 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
519 dnl which is useful in cross-compiles.
521 dnl Note: we would use $ac_config_sub, but that is one of the places where
522 dnl autoconf 2.5x broke compatibility with autoconf 2.13
523 AC_DEFUN([CF_CHECK_CACHE],
525 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
526 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
527 system_name="$host_os"
529 system_name="`(uname -s -r) 2>/dev/null`"
530 if test -z "$system_name" ; then
531 system_name="`(hostname) 2>/dev/null`"
534 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
535 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
537 test -z "$system_name" && system_name="$cf_cv_system_name"
538 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
540 if test ".$system_name" != ".$cf_cv_system_name" ; then
541 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
542 AC_MSG_ERROR("Please remove config.cache and try again.")
545 dnl ---------------------------------------------------------------------------
546 dnl CF_CHECK_CFLAGS version: 4 updated: 2021/01/02 19:22:58
548 dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
549 dnl a build-configuration such as imake. These have the pitfall that they
550 dnl often contain compiler-specific options which we cannot use, mixed with
551 dnl preprocessor options that we usually can.
552 AC_DEFUN([CF_CHECK_CFLAGS],
554 CF_VERBOSE(checking additions to CFLAGS)
555 cf_check_cflags="$CFLAGS"
556 cf_check_cppflags="$CPPFLAGS"
557 CF_ADD_CFLAGS($1,yes)
558 if test "x$cf_check_cflags" != "x$CFLAGS" ; then
559 AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
560 [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS)
561 if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
562 CF_VERBOSE(but keeping change to \$CPPFLAGS)
564 CFLAGS="$cf_check_cflags"])
567 dnl ---------------------------------------------------------------------------
568 dnl CF_CHECK_CURSES_LIB version: 3 updated: 2021/01/04 19:45:09
569 dnl -------------------
570 dnl $1 = nominal library name, used also for header lookup
571 dnl $2 = suffix to append to library name
572 dnl $3 = function to check for using AC_CHECK_LIB
573 dnl $4 = optional parameter list for $3
574 AC_DEFUN([CF_CHECK_CURSES_LIB],
576 AC_REQUIRE([CF_PKG_CONFIG])
578 cf_have_curses_lib=no
580 : ${NCURSES_CONFIG_PKG:=none}
581 if test "x${NCURSES_CONFIG_PKG}" = xnone; then
583 elif test "x${PKG_CONFIG:=none}" != xnone; then
584 AC_MSG_CHECKING(pkg-config for $1$2)
585 if "$PKG_CONFIG" --exists "$1$2" ; then
588 AC_MSG_CHECKING(if the $1$2 package files work)
590 cf_save_CPPFLAGS="$CPPFLAGS"
593 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags "$1$2"`)
594 CF_ADD_LIBS(`$PKG_CONFIG --libs "$1$2"`)
596 AC_TRY_LINK([#include <$1.h>],
597 [(void) $3 ( ]ifelse([$4],,,[[$4]])[ );],
598 [AC_TRY_RUN([#include <$1.h>
600 { (void) $3 ( ]ifelse([$4],,,[[$4]])[ ); return 0; }],
601 [cf_have_curses_lib=yes],
602 [cf_have_curses_lib=no],
603 [cf_have_curses_lib=maybe])],
604 [cf_have_curses_lib=no])
605 AC_MSG_RESULT($cf_have_curses_lib)
606 test "$cf_have_curses_lib" = maybe && cf_have_curses_lib=yes
607 if test "$cf_have_curses_lib" != "yes"
609 CPPFLAGS="$cf_save_CPPFLAGS"
612 CF_UPPER(cf_upper,have_lib$1)
613 AC_DEFINE_UNQUOTED($cf_upper,1)
617 if test "$cf_have_curses_lib" = no; then
618 AC_CHECK_LIB($1$2,$3,[
619 CF_UPPER(cf_upper,have_lib$1)
621 AC_DEFINE_UNQUOTED($cf_upper,1)])
624 dnl ---------------------------------------------------------------------------
625 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
626 dnl -----------------
627 dnl Check if the given compiler is really clang. clang's C driver defines
628 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
629 dnl not ignore some gcc options.
631 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
632 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
633 dnl the wrappers for gcc and g++ warnings.
635 dnl $1 = GCC (default) or GXX
636 dnl $2 = CLANG_COMPILER (default)
637 dnl $3 = CFLAGS (default) or CXXFLAGS
638 AC_DEFUN([CF_CLANG_COMPILER],[
639 ifelse([$2],,CLANG_COMPILER,[$2])=no
641 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
642 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
643 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
649 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
651 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
652 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
657 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
659 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
660 AC_MSG_WARN(replacing broken compiler alias $CC)
661 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
666 AC_MSG_CHECKING(version of $CC)
667 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.]].*//'`"
668 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
669 AC_MSG_RESULT($CLANG_VERSION)
671 for cf_clang_opt in \
673 -Wno-error=implicit-function-declaration
675 AC_MSG_CHECKING(if option $cf_clang_opt works)
676 cf_save_CFLAGS="$CFLAGS"
677 CFLAGS="$CFLAGS $cf_clang_opt"
679 #include <stdio.h>],[
680 printf("hello!\\n");],[
681 cf_clang_optok=yes],[
683 AC_MSG_RESULT($cf_clang_optok)
684 CFLAGS="$cf_save_CFLAGS"
685 if test "$cf_clang_optok" = yes; then
686 CF_VERBOSE(adding option $cf_clang_opt)
687 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
692 dnl ---------------------------------------------------------------------------
693 dnl CF_CONST_X_STRING version: 7 updated: 2021/06/07 17:39:17
694 dnl -----------------
695 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
696 dnl character-strings.
698 dnl It is ambiguous because the specification accommodated the pre-ANSI
699 dnl compilers bundled by more than one vendor in lieu of providing a standard C
700 dnl compiler other than by costly add-ons. Because of this, the specification
701 dnl did not take into account the use of const for telling the compiler that
702 dnl string literals would be in readonly memory.
704 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
705 dnl let the compiler decide how to represent Xt's strings which were #define'd.
706 dnl That does not solve the problem of using the block of Xt's strings which
707 dnl are compiled into the library (and is less efficient than one might want).
709 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
710 dnl when compiling the library and compiling using the library, to tell the
711 dnl compiler that String is const.
712 AC_DEFUN([CF_CONST_X_STRING],
714 AC_REQUIRE([AC_PATH_XTRA])
716 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
721 #include <X11/Intrinsic.h>
723 [String foo = malloc(1); free((void*)foo)],[
725 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
728 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
729 #undef XTSTRINGDEFINES /* X11R5 and later */
731 #include <X11/Intrinsic.h>
732 ],[String foo = malloc(1); *foo = 0],[
733 cf_cv_const_x_string=no
735 cf_cv_const_x_string=yes
739 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
741 case "$cf_cv_const_x_string" in
743 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
746 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
752 dnl ---------------------------------------------------------------------------
753 dnl CF_CURSES_ACS_MAP version: 8 updated: 2021/01/04 19:45:09
754 dnl -----------------
755 dnl Check for likely values of acs_map[]:
756 AC_DEFUN([CF_CURSES_ACS_MAP],
758 AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
759 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
760 cf_cv_curses_acs_map=unknown
761 for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
764 #include <${cf_cv_ncurses_header:-curses.h}>
766 ${name}['k'] = ACS_PLUS
767 ],[cf_cv_curses_acs_map=$name; break])
771 test "$cf_cv_curses_acs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_ACS_ARRAY,$cf_cv_curses_acs_map,[Define as needed to override ncurses prefix _nc_])
773 dnl ---------------------------------------------------------------------------
774 dnl CF_CURSES_CHECK_DATA version: 10 updated: 2021/01/04 19:45:09
775 dnl --------------------
776 dnl Check if curses.h defines the given data/variable.
777 dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
779 dnl $1 = data item(s) to check for
780 dnl $2 = action on success, e.g., "break" to quit checking a series of choices
781 AC_DEFUN([CF_CURSES_CHECK_DATA],
785 AC_MSG_CHECKING(for data $cf_data declaration in ${cf_cv_ncurses_header:-curses.h})
787 AC_TRY_COMPILE(CF__CURSES_HEAD,
788 CF__CURSES_DATA(foo,$cf_data)
791 AC_MSG_RESULT($cf_result)
793 if test "$cf_result" = yes ; then
794 CF_UPPER(cf_result,have_curses_data_$cf_data)
795 AC_DEFINE_UNQUOTED($cf_result)
798 AC_MSG_CHECKING(for data $cf_data in library)
799 # BSD linkers insist on making weak linkage, but resolve at runtime.
800 AC_TRY_RUN(CF__CURSES_HEAD
802 extern char $cf_data;
805 ]CF__CURSES_DATA(foo,$cf_data)[
806 ${cf_cv_main_return:-return}(foo == 0);
810 AC_TRY_LINK(CF__CURSES_HEAD
811 [extern char $cf_data;],[
813 ]CF__CURSES_DATA(foo,$cf_data)[
814 ${cf_cv_main_return:-return}(foo == 0);
816 ],[cf_result=yes],[cf_result=no])
818 AC_MSG_RESULT($cf_result)
819 if test "$cf_result" = yes ; then
820 CF_UPPER(cf_result,decl_curses_data_$cf_data)
821 AC_DEFINE_UNQUOTED($cf_result)
822 # do not exit loop here, since we prefer system's declarations
827 dnl ---------------------------------------------------------------------------
828 dnl CF_CURSES_CHECK_TYPE version: 5 updated: 2021/01/04 19:45:09
829 dnl --------------------
830 dnl Check if curses.h defines the given type
831 AC_DEFUN([CF_CURSES_CHECK_TYPE],
833 AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
835 #ifndef _XOPEN_SOURCE_EXTENDED
836 #define _XOPEN_SOURCE_EXTENDED
838 #include <${cf_cv_ncurses_header:-curses.h}>],[
840 ],cf_result=yes,cf_result=no)
841 AC_MSG_RESULT($cf_result)
842 if test "$cf_result" = yes ; then
843 CF_UPPER(cf_result,have_type_$1)
844 AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
846 AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
849 dnl ---------------------------------------------------------------------------
850 dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
852 dnl Tie together the configure-script macros for curses. It may be ncurses,
853 dnl but unless asked, we do not make a special search for ncurses. However,
854 dnl still check for the ncurses version number, for use in other macros.
855 AC_DEFUN([CF_CURSES_CONFIG],
861 dnl ---------------------------------------------------------------------------
862 dnl CF_CURSES_CPPFLAGS version: 14 updated: 2021/01/02 09:31:20
863 dnl ------------------
864 dnl Look for the curses headers.
865 AC_DEFUN([CF_CURSES_CPPFLAGS],[
867 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
868 cf_cv_curses_incdir=no
871 if test "x$cf_cv_screen" = "xcurses_colr"
873 test -d /usr/include/curses_colr && \
874 cf_cv_curses_incdir="-I/usr/include/curses_colr"
878 if test "x$cf_cv_screen" = "xcurses_5lib"
880 test -d /usr/5lib && \
881 test -d /usr/5include && \
882 cf_cv_curses_incdir="-I/usr/5include"
887 if test "$cf_cv_curses_incdir" != no
889 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
895 dnl ---------------------------------------------------------------------------
896 dnl CF_CURSES_FUNCS version: 20 updated: 2020/12/31 20:19:42
898 dnl Curses-functions are a little complicated, since a lot of them are macros.
899 AC_DEFUN([CF_CURSES_FUNCS],
901 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
902 AC_REQUIRE([CF_XOPEN_CURSES])
903 AC_REQUIRE([CF_CURSES_TERM_H])
904 AC_REQUIRE([CF_CURSES_UNCTRL_H])
907 CF_UPPER(cf_tr_func,$cf_func)
908 AC_MSG_CHECKING(for ${cf_func})
909 CF_MSG_LOG(${cf_func})
910 AC_CACHE_VAL(cf_cv_func_$cf_func,[
911 eval cf_result='$ac_cv_func_'$cf_func
912 if test ".$cf_result" != ".no"; then
913 AC_TRY_LINK(CF__CURSES_HEAD,
916 long foo = (long)(&${cf_func});
917 fprintf(stderr, "testing linkage of $cf_func:%p\\n", (void *)foo);
918 if (foo + 1234L > 5678L)
919 ${cf_cv_main_return:-return}(foo != 0);
925 eval 'cf_cv_func_'$cf_func'="$cf_result"'
927 # use the computed/retrieved cache-value:
928 eval 'cf_result=$cf_cv_func_'$cf_func
929 AC_MSG_RESULT($cf_result)
930 if test "$cf_result" != no; then
931 AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
935 dnl ---------------------------------------------------------------------------
936 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
938 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
939 dnl variations of ncurses' installs.
941 dnl $1 = ncurses when looking for ncurses, or is empty
942 AC_DEFUN([CF_CURSES_HEADER],[
943 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
944 cf_cv_ncurses_header=none
946 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
947 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
949 AC_TRY_COMPILE([#include <${cf_header}>],
950 [initscr(); tgoto("?", 0,0)],
951 [cf_cv_ncurses_header=$cf_header; break],[])
955 if test "$cf_cv_ncurses_header" = none ; then
956 AC_MSG_ERROR(No curses header-files found)
959 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
960 AC_CHECK_HEADERS($cf_cv_ncurses_header)
962 dnl ---------------------------------------------------------------------------
963 dnl CF_CURSES_LIBS version: 44 updated: 2021/01/02 09:31:20
965 dnl Look for the curses libraries. Older curses implementations may require
966 dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first.
967 AC_DEFUN([CF_CURSES_LIBS],[
969 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
970 AC_MSG_CHECKING(if we have identified curses libraries)
971 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
972 [initscr(); tgoto("?", 0,0)],
975 AC_MSG_RESULT($cf_result)
977 if test "$cf_result" = no ; then
980 AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
983 # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
984 # next (1998), and xcurses "newer" (2000). There is no header file for
985 # Hcurses; the subdirectory curses_colr has the headers (curses.h and
986 # term.h) for cur_colr
987 if test "x$cf_cv_screen" = "xcurses_colr"
989 AC_CHECK_LIB(cur_colr,initscr,[
990 CF_ADD_LIBS(-lcur_colr)
991 ac_cv_func_initscr=yes
993 AC_CHECK_LIB(Hcurses,initscr,[
994 # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
995 CF_ADD_LIBS(-lHcurses)
996 CF_APPEND_TEXT(CPPFLAGS,-D__HP_CURSES -D_HP_CURSES)
997 ac_cv_func_initscr=yes
1002 case `arch 2>/dev/null` in
1006 CF_ADD_LIBDIR(/lib64)
1017 if test "x$cf_cv_screen" = "xcurses_5lib"
1019 if test -d /usr/5lib ; then
1020 CF_ADD_LIBDIR(/usr/5lib)
1021 CF_ADD_LIBS(-lcurses -ltermcap)
1024 ac_cv_func_initscr=yes
1028 if test ".$ac_cv_func_initscr" != .yes ; then
1029 cf_save_LIBS="$LIBS"
1031 if test ".${cf_cv_ncurses_version:-no}" != .no
1033 cf_check_list="ncurses curses cursesX"
1035 cf_check_list="cursesX curses ncurses"
1038 # Check for library containing tgoto. Do this before curses library
1039 # because it may be needed to link the test-case for initscr.
1040 if test "x$cf_term_lib" = x
1042 AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
1043 for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
1045 AC_CHECK_LIB($cf_term_lib,tgoto,[
1046 : "${cf_nculib_root:=$cf_term_lib}"
1053 # Check for library containing initscr
1054 test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
1055 if test "x$cf_curs_lib" = x
1057 for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
1059 LIBS="-l$cf_curs_lib $cf_save_LIBS"
1060 if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
1061 AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
1062 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1066 AC_MSG_RESULT($cf_result)
1067 test "$cf_result" = yes && break
1068 elif test "$cf_curs_lib" = "$cf_term_lib" ; then
1070 elif test "$cf_term_lib" != predefined ; then
1071 AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
1072 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1073 [initscr(); tgoto((char *)0, 0, 0);],
1076 LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
1077 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1082 AC_MSG_RESULT($cf_result)
1083 test "$cf_result" != error && break
1087 test "$cf_curs_lib" = unknown && AC_MSG_ERROR(no curses library found)
1092 dnl ---------------------------------------------------------------------------
1093 dnl CF_CURSES_TERM_H version: 15 updated: 2021/01/02 09:31:20
1094 dnl ----------------
1095 dnl SVr4 curses should have term.h as well (where it puts the definitions of
1096 dnl the low-level interface). This may not be true in old/broken implementations,
1097 dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
1098 dnl running with Solaris 2.5.1).
1099 AC_DEFUN([CF_CURSES_TERM_H],
1101 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1103 AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
1105 # If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
1106 # for <term.h> if we do not find the variant.
1108 cf_header_list="term.h ncurses/term.h ncursesw/term.h"
1110 case "${cf_cv_ncurses_header:-curses.h}" in
1112 cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
1113 cf_header_list="$cf_header_item $cf_header_list"
1117 for cf_header in $cf_header_list
1120 #include <${cf_cv_ncurses_header:-curses.h}>
1121 #include <${cf_header}>],
1122 [WINDOW *x; (void)x],
1123 [cf_cv_term_header=$cf_header
1125 [cf_cv_term_header=no])
1128 case "$cf_cv_term_header" in
1130 # If curses is ncurses, some packagers still mess it up by trying to make
1131 # us use GNU termcap. This handles the most common case.
1132 for cf_header in ncurses/term.h ncursesw/term.h
1135 #include <${cf_cv_ncurses_header:-curses.h}>
1136 #ifdef NCURSES_VERSION
1137 #include <${cf_header}>
1141 [WINDOW *x; (void)x],
1142 [cf_cv_term_header=$cf_header
1144 [cf_cv_term_header=no])
1150 case "$cf_cv_term_header" in
1152 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
1155 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
1158 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
1162 dnl ---------------------------------------------------------------------------
1163 dnl CF_CURSES_UNCTRL_H version: 8 updated: 2021/01/02 09:31:20
1164 dnl ------------------
1165 dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
1166 dnl may put it in a subdirectory (along with ncurses' other headers, of
1167 dnl course). Packages which put the headers in inconsistent locations are
1169 AC_DEFUN([CF_CURSES_UNCTRL_H],
1171 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1173 AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
1175 # If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
1176 # for <unctrl.h> if we do not find the variant.
1178 cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
1180 case "${cf_cv_ncurses_header:-curses.h}" in
1182 cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
1183 cf_header_list="$cf_header_item $cf_header_list"
1187 for cf_header in $cf_header_list
1190 #include <${cf_cv_ncurses_header:-curses.h}>
1191 #include <${cf_header}>],
1192 [WINDOW *x; (void)x],
1193 [cf_cv_unctrl_header=$cf_header
1195 [cf_cv_unctrl_header=no])
1199 case "$cf_cv_unctrl_header" in
1201 AC_MSG_WARN(unctrl.h header not found)
1205 case "$cf_cv_unctrl_header" in
1207 AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
1210 AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
1213 AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
1217 dnl ---------------------------------------------------------------------------
1218 dnl CF_CURSES_WACS_MAP version: 8 updated: 2021/01/04 19:45:09
1219 dnl ------------------
1220 dnl Check for likely values of wacs_map[].
1221 AC_DEFUN([CF_CURSES_WACS_MAP],
1223 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
1224 cf_cv_curses_wacs_map=unknown
1225 for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
1228 #ifndef _XOPEN_SOURCE_EXTENDED
1229 #define _XOPEN_SOURCE_EXTENDED
1231 #include <${cf_cv_ncurses_header:-curses.h}>],
1232 [void *foo = &(${name}['k']); (void)foo],
1233 [cf_cv_curses_wacs_map=$name
1237 test "$cf_cv_curses_wacs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_WACS_ARRAY,$cf_cv_curses_wacs_map,[Define to name of (n)curses wide-character array])
1239 dnl ---------------------------------------------------------------------------
1240 dnl CF_CURSES_WACS_SYMBOLS version: 4 updated: 2021/01/04 19:45:09
1241 dnl ----------------------
1242 dnl Do a check to see if the WACS_xxx constants are defined compatibly with
1243 dnl X/Open Curses. In particular, NetBSD's implementation of the WACS_xxx
1244 dnl constants is broken since those constants do not point to cchar_t's.
1245 AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
1247 AC_REQUIRE([CF_CURSES_WACS_MAP])
1249 AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
1250 cf_cv_curses_wacs_symbols=no
1251 if test "$cf_cv_curses_wacs_map" != unknown
1254 #ifndef _XOPEN_SOURCE_EXTENDED
1255 #define _XOPEN_SOURCE_EXTENDED
1257 #include <${cf_cv_ncurses_header:-curses.h}>],
1258 [cchar_t *foo = WACS_PLUS;
1259 ${cf_cv_curses_wacs_map}['k'] = *WACS_PLUS; (void)foo],
1260 [cf_cv_curses_wacs_symbols=yes])
1263 #ifndef _XOPEN_SOURCE_EXTENDED
1264 #define _XOPEN_SOURCE_EXTENDED
1266 #include <${cf_cv_ncurses_header:-curses.h}>],
1267 [cchar_t *foo = WACS_PLUS; (void)foo],
1268 [cf_cv_curses_wacs_symbols=yes])
1272 test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
1274 dnl ---------------------------------------------------------------------------
1275 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1277 dnl "dirname" is not portable, so we fake it with a shell script.
1278 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1279 dnl ---------------------------------------------------------------------------
1280 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1282 dnl You can always use "make -n" to see the actual options, but it's hard to
1283 dnl pick out/analyze warning messages when the compile-line is long.
1286 dnl ECHO_LT - symbol to control if libtool is verbose
1287 dnl ECHO_LD - symbol to prefix "cc -o" lines
1288 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1289 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1290 dnl ECHO_CC - symbol to put before any "cc" line
1292 AC_DEFUN([CF_DISABLE_ECHO],[
1293 AC_MSG_CHECKING(if you want to see long compiling messages)
1294 CF_ARG_DISABLE(echo,
1295 [ --disable-echo do not display "compiling" commands],
1298 ECHO_LD='@echo linking [$]@;'
1299 RULE_CC='@echo compiling [$]<'
1300 SHOW_CC='@echo compiling [$]@'
1309 AC_MSG_RESULT($enableval)
1316 dnl ---------------------------------------------------------------------------
1317 dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50
1318 dnl ----------------
1319 dnl Combine no-leak checks with the libraries or tools that are used for the
1321 AC_DEFUN([CF_DISABLE_LEAKS],[
1323 AC_REQUIRE([CF_WITH_DMALLOC])
1324 AC_REQUIRE([CF_WITH_DBMALLOC])
1325 AC_REQUIRE([CF_WITH_VALGRIND])
1327 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1328 AC_ARG_ENABLE(leaks,
1329 [ --disable-leaks test: free permanent memory, analyze leaks],
1330 [enable_leaks=$enableval],
1332 dnl with_no_leaks is more readable...
1333 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
1334 AC_MSG_RESULT($with_no_leaks)
1336 if test "$enable_leaks" = no ; then
1337 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1338 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1341 dnl ---------------------------------------------------------------------------
1342 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
1343 dnl ---------------------
1344 dnl The rpath-hack makes it simpler to build programs, particularly with the
1345 dnl *BSD ports which may have essential libraries in unusual places. But it
1346 dnl can interfere with building an executable for the base system. Use this
1347 dnl option in that case.
1348 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1350 AC_MSG_CHECKING(if rpath-hack should be disabled)
1351 CF_ARG_DISABLE(rpath-hack,
1352 [ --disable-rpath-hack don't add rpath options for additional libraries],
1353 [enable_rpath_hack=no],
1354 [enable_rpath_hack=yes])
1355 dnl TODO - drop cf_disable_rpath_hack
1356 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
1357 AC_MSG_RESULT($cf_disable_rpath_hack)
1359 if test "$enable_rpath_hack" = yes ; then
1363 dnl ---------------------------------------------------------------------------
1364 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
1365 dnl ----------------------
1366 dnl On a few platforms, the compiler and/or loader nags with untruthful
1367 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1368 dnl and implying that most uses of the recommended alternatives are correct.
1370 dnl Factually speaking, no one has actually counted the number of uses of these
1371 dnl functions versus the total of incorrect uses. Samples of a few thousand
1372 dnl instances are meaningless compared to the hundreds of millions of lines of
1373 dnl existing C code.
1375 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1376 dnl platforms, in implementations of varying quality. Likewise, snprintf is
1377 dnl standard - but evolved through phases, and older implementations are likely
1378 dnl to yield surprising results, as documented in manpages on various systems.
1379 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1381 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1382 AC_ARG_ENABLE(string-hacks,
1383 [ --enable-string-hacks work around bogus compiler/loader warnings],
1384 [enable_string_hacks=$enableval],
1385 [enable_string_hacks=no])
1386 AC_MSG_RESULT($enable_string_hacks)
1388 if test "x$enable_string_hacks" = "xyes"; then
1389 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1390 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1391 AC_CHECK_FUNC(strlcat,[
1392 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1394 AC_CHECK_LIB(bsd,strlcat,[
1396 AC_CHECK_HEADERS(bsd/string.h)
1397 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1400 AC_CHECK_FUNCS( strlcpy snprintf )
1403 dnl ---------------------------------------------------------------------------
1404 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1405 dnl ------------------
1406 dnl Configure-option to enable gcc warnings
1408 dnl $1 = extra options to add, if supported
1409 dnl $2 = option for checking attributes. By default, this is done when
1410 dnl warnings are enabled. For other values:
1411 dnl yes: always do this, e.g., to use in generated library-headers
1412 dnl no: never do this
1413 AC_DEFUN([CF_ENABLE_WARNINGS],[
1414 if test "$GCC" = yes || test "$GXX" = yes
1416 CF_FIX_WARNINGS(CFLAGS)
1417 CF_FIX_WARNINGS(CPPFLAGS)
1418 CF_FIX_WARNINGS(LDFLAGS)
1419 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1420 CF_ARG_ENABLE(warnings,
1421 [ --enable-warnings test: turn on gcc compiler warnings],
1422 [enable_warnings=yes],
1423 [enable_warnings=no])
1424 AC_MSG_RESULT($enable_warnings)
1425 if test "$enable_warnings" = "yes"
1427 ifelse($2,,[CF_GCC_ATTRIBUTES])
1430 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1433 dnl ---------------------------------------------------------------------------
1434 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1436 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1437 dnl prefer a standard location, and use -L options only if we do not find the
1438 dnl library in the standard library location(s).
1439 dnl $1 = library name
1440 dnl $2 = library class, usually the same as library name
1442 dnl $4 = code fragment to compile/link
1443 dnl $5 = corresponding function-name
1444 dnl $6 = flag, nonnull if failure should not cause an error-exit
1446 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1447 dnl to use a -L option.
1448 AC_DEFUN([CF_FIND_LIBRARY],
1450 eval 'cf_cv_have_lib_'"$1"'=no'
1453 eval 'cf_cv_have_lib_'"$1"'=yes',[
1454 cf_save_LIBS="$LIBS"
1455 AC_MSG_CHECKING(for $5 in -l$1)
1457 AC_TRY_LINK([$3],[$4],
1459 eval 'cf_cv_have_lib_'"$1"'=yes'
1462 CF_LIBRARY_PATH(cf_search,$2)
1463 for cf_libdir in $cf_search
1465 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1466 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1467 AC_TRY_LINK([$3],[$4],
1469 eval 'cf_cv_have_lib_'"$1"'=yes'
1472 LIBS="$cf_save_LIBS"])
1476 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1478 if test "$cf_found_library" = no ; then
1479 AC_MSG_ERROR(Cannot link $1 library)
1483 dnl ---------------------------------------------------------------------------
1484 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1486 dnl Find a library (specifically the linkage used in the code fragment),
1487 dnl searching for it if it is not already in the library path.
1488 dnl See also CF_ADD_SEARCHPATH.
1490 dnl Parameters (4-on are optional):
1491 dnl $1 = headers for library entrypoint
1492 dnl $2 = code fragment for library entrypoint
1493 dnl $3 = the library name without the "-l" option or ".so" suffix.
1494 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1495 dnl $5 = action to perform if not successful
1496 dnl $6 = module name, if not the same as the library name
1497 dnl $7 = extra libraries
1499 dnl Sets these variables:
1500 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1501 dnl $cf_cv_header_path_$3 - include-directory if needed
1502 dnl $cf_cv_library_path_$3 - library-directory if needed
1503 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1504 AC_DEFUN([CF_FIND_LINKAGE],[
1506 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1507 # will be set on completion of the AC_TRY_LINK below.
1508 cf_cv_header_path_$3=
1509 cf_cv_library_path_$3=
1511 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1513 cf_save_LIBS="$LIBS"
1515 AC_TRY_LINK([$1],[$2],[
1516 cf_cv_find_linkage_$3=yes
1517 cf_cv_header_path_$3=/usr/include
1518 cf_cv_library_path_$3=/usr/lib
1521 LIBS="-l$3 $7 $cf_save_LIBS"
1523 AC_TRY_LINK([$1],[$2],[
1524 cf_cv_find_linkage_$3=yes
1525 cf_cv_header_path_$3=/usr/include
1526 cf_cv_library_path_$3=/usr/lib
1527 cf_cv_library_file_$3="-l$3"
1529 cf_cv_find_linkage_$3=no
1530 LIBS="$cf_save_LIBS"
1532 CF_VERBOSE(find linkage for $3 library)
1533 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1535 cf_save_CPPFLAGS="$CPPFLAGS"
1536 cf_test_CPPFLAGS="$CPPFLAGS"
1538 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1539 for cf_cv_header_path_$3 in $cf_search
1541 if test -d "$cf_cv_header_path_$3" ; then
1542 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1543 CPPFLAGS="$cf_save_CPPFLAGS"
1544 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1545 AC_TRY_COMPILE([$1],[$2],[
1546 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1547 cf_cv_find_linkage_$3=maybe
1548 cf_test_CPPFLAGS="$CPPFLAGS"
1550 CPPFLAGS="$cf_save_CPPFLAGS"
1555 if test "$cf_cv_find_linkage_$3" = maybe ; then
1557 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1559 cf_save_LIBS="$LIBS"
1560 cf_save_LDFLAGS="$LDFLAGS"
1563 CPPFLAGS="$cf_test_CPPFLAGS"
1564 LIBS="-l$3 $7 $cf_save_LIBS"
1565 AC_TRY_LINK([$1],[$2],[
1566 CF_VERBOSE(... found $3 library in system)
1567 cf_cv_find_linkage_$3=yes])
1568 CPPFLAGS="$cf_save_CPPFLAGS"
1569 LIBS="$cf_save_LIBS"
1572 if test "$cf_cv_find_linkage_$3" != yes ; then
1573 CF_LIBRARY_PATH(cf_search,$3)
1574 for cf_cv_library_path_$3 in $cf_search
1576 if test -d "$cf_cv_library_path_$3" ; then
1577 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1578 CPPFLAGS="$cf_test_CPPFLAGS"
1579 LIBS="-l$3 $7 $cf_save_LIBS"
1580 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1581 AC_TRY_LINK([$1],[$2],[
1582 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1583 cf_cv_find_linkage_$3=yes
1584 cf_cv_library_file_$3="-l$3"
1586 CPPFLAGS="$cf_save_CPPFLAGS"
1587 LIBS="$cf_save_LIBS"
1588 LDFLAGS="$cf_save_LDFLAGS"
1592 CPPFLAGS="$cf_save_CPPFLAGS"
1593 LDFLAGS="$cf_save_LDFLAGS"
1597 cf_cv_find_linkage_$3=no
1602 LIBS="$cf_save_LIBS"
1604 if test "$cf_cv_find_linkage_$3" = yes ; then
1606 CF_ADD_INCDIR($cf_cv_header_path_$3)
1607 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1611 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1614 dnl ---------------------------------------------------------------------------
1615 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1617 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1618 dnl "-Werror" flags can interfere with configure-checks. Those go into
1621 dnl $1 = variable name to repair
1622 define([CF_FIX_WARNINGS],[
1623 if test "$GCC" = yes || test "$GXX" = yes
1627 CF_VERBOSE(repairing $1: [$]$1)
1629 for cf_temp_scan in [$]$1
1631 case "x$cf_temp_scan" in
1633 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1636 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1641 CF_VERBOSE(... fixed [$]$1)
1642 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1646 AC_SUBST(EXTRA_CFLAGS)
1648 dnl ---------------------------------------------------------------------------
1649 dnl CF_FUNC_CURSES_VERSION version: 8 updated: 2021/01/02 09:31:20
1650 dnl ----------------------
1651 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1652 dnl It's a character string "SVR4", not documented.
1653 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1655 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1657 #include <${cf_cv_ncurses_header:-curses.h}>
1661 sprintf(temp, "%s\\n", curses_version());
1662 ${cf_cv_main_return:-return}(0);
1664 ,[cf_cv_func_curses_version=yes]
1665 ,[cf_cv_func_curses_version=no]
1666 ,[cf_cv_func_curses_version=unknown])
1668 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1670 dnl ---------------------------------------------------------------------------
1671 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
1673 dnl Check for openpty() function, along with <pty.h> header. It may need the
1674 dnl "util" library as well.
1675 AC_DEFUN([CF_FUNC_OPENPTY],
1677 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1678 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1679 cf_save_LIBS="$LIBS"
1680 test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
1681 for cf_header in pty.h libutil.h util.h
1684 #include <$cf_header>
1686 int x = openpty((int *)0, (int *)0, (char *)0,
1687 (struct termios *)0, (struct winsize *)0);
1689 cf_cv_func_openpty=$cf_header
1692 cf_cv_func_openpty=no
1695 LIBS="$cf_save_LIBS"
1698 dnl ---------------------------------------------------------------------------
1699 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1700 dnl -----------------
1701 dnl Test for availability of useful gcc __attribute__ directives to quiet
1702 dnl compiler warnings. Though useful, not all are supported -- and contrary
1703 dnl to documentation, unrecognized directives cause older compilers to barf.
1704 AC_DEFUN([CF_GCC_ATTRIBUTES],
1705 [AC_REQUIRE([AC_PROG_FGREP])dnl
1706 AC_REQUIRE([CF_C11_NORETURN])dnl
1708 if test "$GCC" = yes || test "$GXX" = yes
1710 cat > conftest.i <<EOF
1712 #define GCC_PRINTF 0
1717 #ifndef GCC_NORETURN
1718 #define GCC_NORETURN /* nothing */
1721 #define GCC_UNUSED /* nothing */
1724 if test "$GCC" = yes
1726 AC_CHECKING([for $CC __attribute__ directives])
1727 cat > "conftest.$ac_ext" <<EOF
1728 #line __oline__ "${as_me:-configure}"
1729 #include "confdefs.h"
1730 #include "conftest.h"
1731 #include "conftest.i"
1733 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1735 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1738 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1740 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1742 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1743 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1744 extern GCC_NORETURN void foo(void);
1745 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1747 cf_printf_attribute=no
1748 cf_scanf_attribute=no
1749 for cf_attribute in scanf printf unused noreturn
1751 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1752 cf_directive="__attribute__(($cf_attribute))"
1753 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1755 case "$cf_attribute" in
1757 cf_printf_attribute=yes
1758 cat >conftest.h <<EOF
1759 #define GCC_$cf_ATTRIBUTE 1
1763 cf_scanf_attribute=yes
1764 cat >conftest.h <<EOF
1765 #define GCC_$cf_ATTRIBUTE 1
1769 cat >conftest.h <<EOF
1770 #define GCC_$cf_ATTRIBUTE $cf_directive
1775 if AC_TRY_EVAL(ac_compile); then
1776 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1777 cat conftest.h >>confdefs.h
1778 case "$cf_attribute" in
1780 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1783 cf_value='/* nothing */'
1784 if test "$cf_printf_attribute" != no ; then
1785 cf_value='__attribute__((format(printf,fmt,var)))'
1786 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1788 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1791 cf_value='/* nothing */'
1792 if test "$cf_scanf_attribute" != no ; then
1793 cf_value='__attribute__((format(scanf,fmt,var)))'
1794 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1796 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1799 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1805 ${FGREP-fgrep} define conftest.i >>confdefs.h
1810 dnl ---------------------------------------------------------------------------
1811 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1813 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1814 dnl compatible), attempt to determine if icc/clang is actually used.
1815 AC_DEFUN([CF_GCC_VERSION],[
1816 AC_REQUIRE([AC_PROG_CC])
1818 if test "$GCC" = yes ; then
1819 AC_MSG_CHECKING(version of $CC)
1820 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.]].*//'`"
1821 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1822 AC_MSG_RESULT($GCC_VERSION)
1824 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1825 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1827 dnl ---------------------------------------------------------------------------
1828 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1830 dnl Check if the compiler supports useful warning options. There's a few that
1831 dnl we don't use, simply because they're too noisy:
1833 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1834 dnl -Winline (usually not worthwhile)
1835 dnl -Wredundant-decls (system headers make this too noisy)
1836 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1837 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1838 dnl is enabled for ncurses using "--enable-const".
1842 dnl $1 is an optional list of gcc warning flags that a particular
1843 dnl application might want to use, e.g., "no-unused" for
1846 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1848 AC_DEFUN([CF_GCC_WARNINGS],
1850 AC_REQUIRE([CF_GCC_VERSION])
1851 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1852 cat > "conftest.$ac_ext" <<EOF
1853 #line __oline__ "${as_me:-configure}"
1854 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1856 if test "$INTEL_COMPILER" = yes
1858 # The "-wdXXX" options suppress warnings:
1859 # remark #1419: external declaration in primary source file
1860 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1861 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1862 # remark #193: zero used for undefined preprocessing identifier
1863 # remark #593: variable "curs_sb_left_arrow" was set but never used
1864 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1865 # remark #869: parameter "tw" was never referenced
1866 # remark #981: operands are evaluated in unspecified order
1867 # warning #279: controlling expression is constant
1869 AC_CHECKING([for $CC warning options])
1870 cf_save_CFLAGS="$CFLAGS"
1871 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1883 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1884 if AC_TRY_EVAL(ac_compile); then
1885 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1886 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1889 CFLAGS="$cf_save_CFLAGS"
1890 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1892 AC_CHECKING([for $CC warning options])
1893 cf_save_CFLAGS="$CFLAGS"
1895 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1896 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1897 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1898 for cf_opt in W Wall \
1899 Wbad-function-cast \
1902 Wdeclaration-after-statement \
1905 Wmissing-declarations \
1906 Wmissing-prototypes \
1910 Wstrict-prototypes \
1911 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1913 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1914 if AC_TRY_EVAL(ac_compile); then
1915 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1918 case "$GCC_VERSION" in
1920 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1925 case "$GCC_VERSION" in
1927 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1932 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1935 CFLAGS="$cf_save_CFLAGS"
1939 AC_SUBST(EXTRA_CFLAGS)
1941 dnl ---------------------------------------------------------------------------
1942 dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16
1943 dnl ----------------
1944 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1945 dnl unistd.h or (nonstandard) in getopt.h
1946 AC_DEFUN([CF_GETOPT_HEADER],
1948 AC_HAVE_HEADERS(unistd.h getopt.h)
1949 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1950 cf_cv_getopt_header=none
1951 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1954 #include <$cf_header>],
1955 [int x = optind; char *y = optarg; (void)x; (void)y],
1956 [cf_cv_getopt_header=$cf_header
1960 if test "$cf_cv_getopt_header" != none ; then
1961 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1963 if test "$cf_cv_getopt_header" = getopt.h ; then
1964 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1967 dnl ---------------------------------------------------------------------------
1968 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1970 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1971 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1972 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1973 dnl since it is interwoven with GNU extensions.
1975 dnl Well, yes we could work around it...
1978 dnl $1 is the nominal value for _XOPEN_SOURCE
1979 AC_DEFUN([CF_GNU_SOURCE],
1981 cf_gnu_xopen_source=ifelse($1,,500,$1)
1983 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1984 AC_TRY_COMPILE([#include <sys/types.h>],[
1985 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1987 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1990 # error not GNU C library
1992 [cf_cv_gnu_library=yes],
1993 [cf_cv_gnu_library=no])
1996 if test x$cf_cv_gnu_library = xyes; then
1998 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1999 # was changed to help a little. newlib incorporated the change about 4
2001 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
2003 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2004 AC_TRY_COMPILE([#include <sys/types.h>],[
2005 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
2007 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
2010 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
2012 [cf_cv_gnu_library_219=yes],
2013 [cf_cv_gnu_library_219=no])
2017 if test "x$cf_cv_gnu_library_219" = xyes; then
2019 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
2020 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
2023 #include <sys/types.h>
2025 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
2028 # error GNU C library is too old
2030 [cf_cv_gnu_dftsrc_219=yes],
2031 [cf_cv_gnu_dftsrc_219=no])
2033 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
2035 cf_cv_gnu_dftsrc_219=maybe
2038 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
2040 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2041 AC_TRY_COMPILE([#include <sys/types.h>],[
2042 #ifndef _XOPEN_SOURCE
2043 #error expected _XOPEN_SOURCE to be defined
2045 [cf_cv_gnu_source=no],
2046 [cf_save="$CPPFLAGS"
2047 CF_ADD_CFLAGS(-D_GNU_SOURCE)
2048 AC_TRY_COMPILE([#include <sys/types.h>],[
2049 #ifdef _XOPEN_SOURCE
2050 #error expected _XOPEN_SOURCE to be undefined
2052 [cf_cv_gnu_source=no],
2053 [cf_cv_gnu_source=yes])
2058 if test "$cf_cv_gnu_source" = yes
2060 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2061 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2062 AC_TRY_COMPILE([#include <sys/types.h>],[
2063 #ifdef _DEFAULT_SOURCE
2064 #error expected _DEFAULT_SOURCE to be undefined
2066 [cf_cv_default_source=no],
2067 [cf_cv_default_source=yes])
2069 if test "$cf_cv_default_source" = yes
2071 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2078 dnl ---------------------------------------------------------------------------
2079 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2081 dnl Construct a search-list of directories for a nonstandard header-file
2084 dnl $1 = the variable to return as result
2085 dnl $2 = the package name
2086 AC_DEFUN([CF_HEADER_PATH],
2090 # collect the current set of include-directories from compiler flags
2091 cf_header_path_list=""
2092 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2093 for cf_header_path in $CPPFLAGS $CFLAGS
2095 case "$cf_header_path" in
2097 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2098 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2099 cf_header_path_list="$cf_header_path_list [$]$1"
2105 # add the variations for the package we are looking for
2106 CF_SUBDIR_PATH($1,$2,include)
2108 test "$includedir" != NONE && \
2109 test "$includedir" != "/usr/include" && \
2110 test -d "$includedir" && {
2111 test -d "$includedir" && $1="[$]$1 $includedir"
2112 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2115 test "$oldincludedir" != NONE && \
2116 test "$oldincludedir" != "/usr/include" && \
2117 test -d "$oldincludedir" && {
2118 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2119 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2122 $1="[$]$1 $cf_header_path_list"
2124 dnl ---------------------------------------------------------------------------
2125 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2127 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2128 AC_DEFUN([CF_HELP_MESSAGE],
2129 [CF_ACVERSION_CHECK(2.53,[],[
2130 AC_DIVERT_HELP($1)])dnl
2132 dnl ---------------------------------------------------------------------------
2133 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2134 dnl -----------------
2135 dnl If we do not have a given script, look for it in the parent directory.
2136 AC_DEFUN([CF_INHERIT_SCRIPT],
2138 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2140 dnl ---------------------------------------------------------------------------
2141 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2143 dnl prompt for/fill-in useful install-program options
2144 AC_DEFUN([CF_INSTALL_OPTS],
2150 dnl ---------------------------------------------------------------------------
2151 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2152 dnl ----------------
2153 dnl Almost all "install" programs default to the current user's ownership.
2154 dnl Almost - MINIX is an exception.
2155 AC_DEFUN([CF_INSTALL_OPT_O],
2157 AC_MSG_CHECKING(if install needs to be told about ownership)
2158 case `$ac_config_guess` in
2167 AC_MSG_RESULT($with_install_o)
2168 if test "x$with_install_o" = xyes
2170 INSTALL_OPT_O="`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`"
2175 AC_SUBST(INSTALL_OPT_O)
2177 dnl ---------------------------------------------------------------------------
2178 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2179 dnl ----------------
2180 dnl Some install-programs accept a "-p" option to preserve file modification
2181 dnl timestamps. That can be useful as an install option, as well as a way to
2182 dnl avoid the need for ranlib after copying a static archive.
2183 AC_DEFUN([CF_INSTALL_OPT_P],
2185 : "${INSTALL:=install}"
2186 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2191 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2193 if test -f conftest.out/conftest.in
2195 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2196 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2197 if test -s conftest.err
2212 dnl ---------------------------------------------------------------------------
2213 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2214 dnl ----------------
2215 dnl By default, we should strip executables which are installed, but leave the
2216 dnl ability to suppress that for unit-testing.
2217 AC_DEFUN([CF_INSTALL_OPT_S],
2219 AC_MSG_CHECKING(if you want to install stripped executables)
2220 CF_ARG_DISABLE(stripping,
2221 [ --disable-stripping do not strip (debug info) installed executables],
2222 [enable_stripping=no],
2223 [enable_stripping=yes])
2224 AC_MSG_RESULT($enable_stripping)
2226 if test "$enable_stripping" = yes
2232 AC_SUBST(INSTALL_OPT_S)
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2236 dnl -----------------
2237 dnl Check if the given compiler is really the Intel compiler for Linux. It
2238 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2239 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2241 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2242 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2243 dnl the wrappers for gcc and g++ warnings.
2245 dnl $1 = GCC (default) or GXX
2246 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2247 dnl $3 = CFLAGS (default) or CXXFLAGS
2248 AC_DEFUN([CF_INTEL_COMPILER],[
2249 AC_REQUIRE([AC_CANONICAL_HOST])
2250 ifelse([$2],,INTEL_COMPILER,[$2])=no
2252 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2255 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2256 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2257 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2259 #ifdef __INTEL_COMPILER
2263 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2264 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2266 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2267 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2272 dnl ---------------------------------------------------------------------------
2273 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2275 dnl For the given system and compiler, find the compiler flags to pass to the
2276 dnl loader to use the "rpath" feature.
2277 AC_DEFUN([CF_LD_RPATH_OPT],
2279 AC_REQUIRE([CF_CHECK_CACHE])
2282 if test "x$cf_cv_enable_rpath" != xno
2284 AC_MSG_CHECKING(for an rpath option)
2285 case "$cf_cv_system_name" in
2287 if test "$GCC" = yes; then
2288 LD_RPATH_OPT="-Wl,-rpath,"
2290 LD_RPATH_OPT="-rpath "
2293 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2294 LD_RPATH_OPT="-Wl,-rpath,"
2296 (openbsd[[2-9]].*|mirbsd*)
2297 LD_RPATH_OPT="-Wl,-rpath,"
2300 LD_RPATH_OPT="-rpath "
2303 LD_RPATH_OPT="-Wl,-rpath,"
2306 LD_RPATH_OPT="-rpath "
2314 AC_MSG_RESULT($LD_RPATH_OPT)
2316 case "x$LD_RPATH_OPT" in
2318 AC_MSG_CHECKING(if we need a space after rpath option)
2319 cf_save_LIBS="$LIBS"
2320 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2321 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2322 LIBS="$cf_save_LIBS"
2323 AC_MSG_RESULT($cf_rpath_space)
2324 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2329 dnl ---------------------------------------------------------------------------
2330 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2332 dnl Construct a search-list of directories for a nonstandard library-file
2335 dnl $1 = the variable to return as result
2336 dnl $2 = the package name
2337 AC_DEFUN([CF_LIBRARY_PATH],
2340 cf_library_path_list=""
2341 if test -n "${LDFLAGS}${LIBS}" ; then
2342 for cf_library_path in $LDFLAGS $LIBS
2344 case "$cf_library_path" in
2346 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2347 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2348 cf_library_path_list="$cf_library_path_list [$]$1"
2354 CF_SUBDIR_PATH($1,$2,lib)
2356 $1="$cf_library_path_list [$]$1"
2358 dnl ---------------------------------------------------------------------------
2359 dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21
2361 dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which
2362 dnl acts as a placeholder.
2364 dnl The ".PHONY" feature was proposed in 2011 here
2365 dnl https://www.austingroupbugs.net/view.php?id=523
2366 dnl and is scheduled for release in P1003.1 Issue 8 (late 2022).
2368 dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with
2369 dnl a few others (i.e., GNU make and the non-POSIX "BSD" make):
2371 dnl + This is a GNU make feature (since April 1988, but in turn from binutils,
2372 dnl date unspecified).
2374 dnl + It was adopted in NetBSD make in June 1995.
2376 dnl + The other BSD make programs are derived from the NetBSD make (and for
2377 dnl that reason are not actually different "implementations").
2379 dnl + Some features of NetBSD make were actually adapted from pmake, which
2380 dnl began as a modified GNU make starting in 1993.
2382 dnl + Version 3.8 of the dmake program in January 1992 also implemented this
2383 dnl GNU make extension, but is less well known than the BSD make.
2384 AC_DEFUN([CF_MAKE_PHONY],[
2385 AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[
2388 mkdir conftest || exit 1
2390 cat >makefile <<'CF_EOF'
2394 @echo "** making [$]@ [$](DATA)"
2396 @echo "** making [$]@ [$](DATA)"
2398 @echo "** making [$]@ [$](DATA)"
2399 echo [$](DATA) > [$]@
2401 @echo "** making [$]@ [$](DATA)"
2402 echo [$](DATA) > [$]@
2404 for cf_data in 1 2 3
2406 ${MAKE:-make} always DATA=$cf_data
2407 ${MAKE:-make} once DATA=$cf_data
2408 ${MAKE:-make} -t always once
2409 if test -f always ; then
2410 echo "no (case 1)" > ../conftest.tmp
2411 elif test ! -f always.out ; then
2412 echo "no (case 2)" > ../conftest.tmp
2413 elif test ! -f once.out ; then
2414 echo "no (case 3)" > ../conftest.tmp
2415 elif ! cmp -s always.out once.out ; then
2416 echo "no (case 4)" > ../conftest.tmp
2417 diff always.out once.out
2419 cf_check="`cat always.out`"
2420 if test "x$cf_check" != "x$cf_data" ; then
2421 echo "no (case 5)" > ../conftest.tmp
2423 echo yes > ../conftest.tmp
2431 cf_cv_make_PHONY="`cat conftest.tmp`"
2436 test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY=
2437 test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY=
2438 AC_SUBST(MAKE_NO_PHONY)
2439 AC_SUBST(MAKE_PHONY)
2441 dnl ---------------------------------------------------------------------------
2442 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2444 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2445 dnl a monocase filesystem.
2446 AC_DEFUN([CF_MAKE_TAGS],[
2447 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2449 AC_CHECK_PROGS(CTAGS, exctags ctags)
2450 AC_CHECK_PROGS(ETAGS, exetags etags)
2452 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2454 if test "$cf_cv_mixedcase" = yes ; then
2455 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2460 if test "$MAKE_UPPER_TAGS" = yes ; then
2466 if test "$MAKE_LOWER_TAGS" = yes ; then
2475 AC_SUBST(MAKE_UPPER_TAGS)
2476 AC_SUBST(MAKE_LOWER_TAGS)
2478 dnl ---------------------------------------------------------------------------
2479 dnl CF_MATH_LIB version: 10 updated: 2020/12/31 18:40:20
2481 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
2482 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
2483 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2484 AC_DEFUN([CF_MATH_LIB],
2486 AC_CACHE_CHECK(if -lm needed for math functions,
2493 [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
2494 [cf_cv_need_libm=no],
2495 [cf_cv_need_libm=yes])])
2496 if test "$cf_cv_need_libm" = yes
2503 dnl ---------------------------------------------------------------------------
2504 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2505 dnl ----------------------
2506 dnl Check if the file-system supports mixed-case filenames. If we're able to
2507 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2508 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2510 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2511 if test "$cross_compiling" = yes ; then
2512 case "$target_alias" in
2513 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2521 rm -f conftest CONFTEST
2523 if test -f CONFTEST ; then
2528 rm -f conftest CONFTEST
2531 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2533 dnl ---------------------------------------------------------------------------
2534 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2536 dnl Write a debug message to config.log, along with the line number in the
2537 dnl configure script.
2538 AC_DEFUN([CF_MSG_LOG],[
2539 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2541 dnl ---------------------------------------------------------------------------
2542 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2543 dnl -------------------
2544 dnl Check if we can compile with ncurses' header file
2545 dnl $1 is the cache variable to set
2546 dnl $2 is the header-file to include
2547 dnl $3 is the root name (ncurses or ncursesw)
2548 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2550 ]ifelse($3,ncursesw,[
2551 #define _XOPEN_SOURCE_EXTENDED
2552 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2553 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2556 #ifdef NCURSES_VERSION
2557 ]ifelse($3,ncursesw,[
2562 printf("%s\\n", NCURSES_VERSION);
2574 dnl ---------------------------------------------------------------------------
2575 dnl CF_NCURSES_CONFIG version: 28 updated: 2021/08/28 15:20:37
2576 dnl -----------------
2577 dnl Tie together the configure-script macros for ncurses, preferring these in
2579 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2580 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2581 dnl c) just plain libraries
2583 dnl $1 is the root library name (default: "ncurses")
2584 AC_DEFUN([CF_NCURSES_CONFIG],[
2585 AC_REQUIRE([CF_PKG_CONFIG])
2586 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2587 cf_have_ncuconfig=no
2589 if test "x${PKG_CONFIG:=none}" != xnone; then
2590 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2591 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2594 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2595 cf_have_ncuconfig=unknown
2597 cf_save_CFLAGS="$CFLAGS"
2598 cf_save_CPPFLAGS="$CPPFLAGS"
2599 cf_save_LIBS="$LIBS"
2601 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2602 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2604 # while -W for passing linker flags is prevalent, it is not "standard".
2605 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2606 # incompatible _and_ non-standard -W option which gives an error. Work
2607 # around that pitfall.
2608 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2610 CF_ADD_CFLAGS($cf_pkg_cflags)
2611 CF_ADD_LIBS($cf_pkg_libs)
2613 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2614 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2615 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2617 { const char *xx = curses_version(); return (xx == 0); }],
2618 [cf_test_ncuconfig=yes],
2619 [cf_test_ncuconfig=no],
2620 [cf_test_ncuconfig=maybe])],
2621 [cf_test_ncuconfig=no])
2623 CFLAGS="$cf_save_CFLAGS"
2624 CPPFLAGS="$cf_save_CPPFLAGS"
2625 LIBS="$cf_save_LIBS"
2627 if test "x$cf_test_ncuconfig" != xyes; then
2628 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2629 cf_pkg_cflags="$cf_temp"
2630 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2631 cf_pkg_libs="$cf_temp"
2636 CF_APPEND_CFLAGS($cf_pkg_cflags)
2637 CF_ADD_LIBS($cf_pkg_libs)
2639 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2640 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2641 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2643 { const char *xx = curses_version(); return (xx == 0); }],
2644 [cf_have_ncuconfig=yes],
2645 [cf_have_ncuconfig=no],
2646 [cf_have_ncuconfig=maybe])],
2647 [cf_have_ncuconfig=no])
2648 AC_MSG_RESULT($cf_have_ncuconfig)
2649 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2650 if test "$cf_have_ncuconfig" != "yes"
2652 CPPFLAGS="$cf_save_CPPFLAGS"
2653 LIBS="$cf_save_LIBS"
2654 NCURSES_CONFIG_PKG=none
2656 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2657 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2663 NCURSES_CONFIG_PKG=none
2666 NCURSES_CONFIG_PKG=none
2669 if test "x$cf_have_ncuconfig" = "xno"; then
2670 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2672 CF_ACVERSION_CHECK(2.52,
2673 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2674 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2676 if test "$NCURSES_CONFIG" != none ; then
2678 CF_APPEND_CFLAGS(`$NCURSES_CONFIG --cflags`)
2679 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2681 # even with config script, some packages use no-override for curses.h
2682 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2684 dnl like CF_NCURSES_CPPFLAGS
2685 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2687 dnl like CF_NCURSES_LIBS
2688 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2689 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2691 dnl like CF_NCURSES_VERSION
2692 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
2696 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2697 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2704 dnl ---------------------------------------------------------------------------
2705 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
2706 dnl -------------------
2707 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2708 dnl the CPPFLAGS variable so we can include its header.
2710 dnl The header files may be installed as either curses.h, or ncurses.h (would
2711 dnl be obsolete, except that some packagers prefer this name to distinguish it
2712 dnl from a "native" curses implementation). If not installed for overwrite,
2713 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2714 dnl /usr/include/ncurses), but someone may have installed overwriting the
2715 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2716 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2719 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2720 dnl is already in the include-path, don't even bother with this, since we cannot
2721 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2723 dnl The optional parameter gives the root name of the library, in case it is
2724 dnl not installed as the default curses library. That is how the
2725 dnl wide-character version of ncurses is installed.
2726 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2727 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2729 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2730 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2732 test -n "$cf_cv_curses_dir" && \
2733 test "$cf_cv_curses_dir" != "no" && { \
2734 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2737 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2738 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2739 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
2740 for cf_header in $cf_header_list
2742 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2743 test "$cf_cv_ncurses_h" != no && break
2750 # some applications need this, but should check for NCURSES_VERSION
2751 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2755 dnl ---------------------------------------------------------------------------
2756 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2757 dnl --------------------
2758 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2759 dnl may provide these functions. Define the symbol if it is not defined, and
2761 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2763 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2765 #include <${cf_cv_ncurses_header:-curses.h}>],
2767 int x = NCURSES_EXT_FUNCS
2768 ],[cf_cv_ncurses_ext_funcs=defined],[
2770 #include <${cf_cv_ncurses_header:-curses.h}>],
2772 (void) assume_default_colors (0, 0);
2773 (void) curses_version ();
2774 (void) define_key (0, 0);
2775 (void) is_term_resized (0, 0);
2776 (void) key_defined (0);
2777 (void) keybound (0, 0);
2778 (void) keyok (0, 0);
2779 (void) resize_term (0, 0);
2780 (void) resizeterm (0, 0);
2781 (void) use_default_colors ();
2782 (void) use_extended_names (0);
2783 (void) wresize (0, 0, 0);],
2784 [cf_cv_ncurses_ext_funcs=yes],
2785 [cf_cv_ncurses_ext_funcs=no])
2788 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2790 dnl ---------------------------------------------------------------------------
2791 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
2792 dnl -----------------
2793 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2794 dnl variations of ncurses' installs.
2796 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2797 AC_DEFUN([CF_NCURSES_HEADER],[
2799 if test "$cf_cv_ncurses_h" != no ; then
2800 cf_cv_ncurses_header=$cf_cv_ncurses_h
2803 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2804 test -n "$verbose" && echo
2805 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2806 test -n "$verbose" && echo "search path $cf_search"
2807 cf_save2_CPPFLAGS="$CPPFLAGS"
2808 for cf_incdir in $cf_search
2810 CF_ADD_INCDIR($cf_incdir)
2815 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2816 if test "$cf_cv_ncurses_h2" != no ; then
2817 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2818 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
2821 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2823 CPPFLAGS="$cf_save2_CPPFLAGS"
2824 test "$cf_cv_ncurses_h2" != no && break
2826 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2829 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2830 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
2831 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
2832 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
2834 CF_ADD_INCDIR($cf_1st_incdir)
2838 # Set definitions to allow ifdef'ing for ncurses.h
2840 case "$cf_cv_ncurses_header" in
2842 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2846 case "$cf_cv_ncurses_header" in
2847 (ncurses/curses.h|ncurses/ncurses.h)
2848 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2850 (ncursesw/curses.h|ncursesw/ncurses.h)
2851 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2856 dnl ---------------------------------------------------------------------------
2857 dnl CF_NCURSES_LIBS version: 20 updated: 2021/01/03 08:05:37
2859 dnl Look for the ncurses library. This is a little complicated on Linux,
2860 dnl because it may be linked with the gpm (general purpose mouse) library.
2861 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2862 dnl unusable with ncurses. However, we don't want to link with gpm unless
2863 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2864 dnl and the linker will record a dependency.
2866 dnl The optional parameter gives the root name of the library, in case it is
2867 dnl not installed as the default curses library. That is how the
2868 dnl wide-character version of ncurses is installed.
2869 AC_DEFUN([CF_NCURSES_LIBS],
2870 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2872 cf_nculib_root=ifelse($1,,ncurses,$1)
2873 # This works, except for the special case where we find gpm, but
2874 # ncurses is in a nonstandard location via $LIBS, and we really want
2877 cf_ncurses_SAVE="$LIBS"
2878 AC_CHECK_LIB(gpm,Gpm_Open,
2879 [AC_CHECK_LIB(gpm,initscr,
2880 [LIBS="$cf_ncurses_SAVE"],
2881 [cf_ncurses_LIBS="-lgpm"])])
2885 # This is only necessary if you are linking against an obsolete
2886 # version of ncurses (but it should do no harm, since it's static).
2887 if test "$cf_nculib_root" = ncurses ; then
2888 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2893 CF_ADD_LIBS($cf_ncurses_LIBS)
2895 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
2897 CF_ADD_LIBS(-l$cf_nculib_root)
2899 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2900 [#include <${cf_cv_ncurses_header:-curses.h}>],
2905 if test -n "$cf_ncurses_LIBS" ; then
2906 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2907 cf_ncurses_SAVE="$LIBS"
2908 for p in $cf_ncurses_LIBS ; do
2909 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
2910 if test "$q" != "$LIBS" ; then
2914 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2915 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2916 [AC_MSG_RESULT(yes)],
2918 LIBS="$cf_ncurses_SAVE"])
2921 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2922 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2924 dnl ---------------------------------------------------------------------------
2925 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2926 dnl -------------------
2927 dnl Use this followup check to ensure that we link with pthreads if ncurses
2929 AC_DEFUN([CF_NCURSES_PTHREADS],[
2930 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2931 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2932 cf_cv_ncurses_pthreads=yes,
2933 cf_cv_ncurses_pthreads=no)
2934 if test "$cf_cv_ncurses_pthreads" = yes
2936 CF_ADD_LIBS(-lpthread)
2939 dnl ---------------------------------------------------------------------------
2940 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
2941 dnl ------------------
2942 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2943 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
2944 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2945 AC_DEFUN([CF_NCURSES_VERSION],
2947 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2948 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2949 cf_cv_ncurses_version=no
2951 rm -f "$cf_tempfile"
2953 #include <${cf_cv_ncurses_header:-curses.h}>
2957 FILE *fp = fopen("$cf_tempfile", "w");
2958 #ifdef NCURSES_VERSION
2959 # ifdef NCURSES_VERSION_PATCH
2960 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2962 fprintf(fp, "%s\\n", NCURSES_VERSION);
2966 fprintf(fp, "old\\n");
2971 ${cf_cv_main_return:-return}(0);
2973 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2975 # This will not work if the preprocessor splits the line after the
2976 # Autoconf token. The 'unproto' program does that.
2977 cat > "conftest.$ac_ext" <<EOF
2978 #include <${cf_cv_ncurses_header:-curses.h}>
2980 #ifdef NCURSES_VERSION
2981 Autoconf NCURSES_VERSION
2989 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2991 if test -f conftest.out ; then
2992 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
2993 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2997 rm -f "$cf_tempfile"
2999 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3001 dnl ---------------------------------------------------------------------------
3002 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
3003 dnl ----------------------
3004 dnl Check for ncurses "wrap-prefix" used for public variables which have been
3005 dnl wrapped with a function to help with concurrency control.
3006 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
3008 AC_MSG_CHECKING(for ncurses wrap-prefix)
3009 AC_ARG_WITH(ncurses-wrap-prefix,
3010 [ --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
3011 [NCURSES_WRAP_PREFIX=$withval],
3012 [NCURSES_WRAP_PREFIX=_nc_])
3013 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
3015 AC_SUBST(NCURSES_WRAP_PREFIX)
3017 dnl ---------------------------------------------------------------------------
3018 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
3019 dnl ----------------
3020 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
3021 dnl Some workarounds are needed in client programs to allow them to compile.
3022 AC_DEFUN([CF_NETBSD_FORM_H],[
3023 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
3025 #include <${cf_cv_ncurses_header:-curses.h}>
3029 int y = current_field(form)->cursor_ypos;
3030 int x = current_field(form)->cursor_xpos;
3031 ],[cf_cv_netbsd_form_h=yes
3032 ],[cf_cv_netbsd_form_h=no])
3035 test "$cf_cv_netbsd_form_h" = yes && AC_DEFINE(HAVE_NETBSD_FORM_H,1,[Define to 1 if we appear to be using NetBSD form.h])
3037 dnl ---------------------------------------------------------------------------
3038 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
3039 dnl ----------------
3040 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
3041 dnl Some workarounds are needed in client programs to allow them to compile.
3042 AC_DEFUN([CF_NETBSD_MENU_H],[
3043 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
3045 #include <${cf_cv_ncurses_header:-curses.h}>
3049 int y = menu->max_item_width;
3050 ],[cf_cv_netbsd_menu_h=yes
3051 ],[cf_cv_netbsd_menu_h=no])
3054 test "$cf_cv_netbsd_menu_h" = yes && AC_DEFINE(HAVE_NETBSD_MENU_H,1,[Define to 1 if we appear to be using NetBSD menu.h])
3056 dnl ---------------------------------------------------------------------------
3057 dnl CF_NO_LEAKS_OPTION version: 9 updated: 2021/06/13 19:45:41
3058 dnl ------------------
3059 dnl see CF_WITH_NO_LEAKS
3061 dnl $1 = option/name
3063 dnl $3 = symbol to define if the option is set
3064 dnl $4 = additional actions to take if the option is set
3065 AC_DEFUN([CF_NO_LEAKS_OPTION],[
3066 AC_MSG_CHECKING(if you want to use $1 for testing)
3069 [case "x$withval" in
3072 : "${with_cflags:=-g}"
3073 : "${enable_leaks:=no}"
3075 AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
3081 AC_MSG_RESULT(${with_$1:-no})
3083 case ".$with_cflags" in
3095 dnl ---------------------------------------------------------------------------
3096 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3098 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3099 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3100 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3101 dnl delayed evaluation of those symbols.
3102 AC_DEFUN([CF_PATH_SYNTAX],[
3103 if test "x$prefix" != xNONE; then
3104 cf_path_syntax="$prefix"
3106 cf_path_syntax="$ac_default_prefix"
3110 (.\[$]\(*\)*|.\'*\'*)
3114 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3116 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3120 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3125 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3128 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3132 dnl ---------------------------------------------------------------------------
3133 dnl CF_PDCURSES_X11 version: 15 updated: 2021/01/02 09:31:20
3135 dnl Configure for PDCurses' X11 library
3136 AC_DEFUN([CF_PDCURSES_X11],[
3137 AC_REQUIRE([CF_X_ATHENA])
3139 CF_ACVERSION_CHECK(2.52,
3140 [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
3141 [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
3143 if test "$XCURSES_CONFIG" != none ; then
3145 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
3146 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
3148 cf_cv_lib_XCurses=yes
3152 LDFLAGS="$LDFLAGS $X_LIBS"
3153 CF_CHECK_CFLAGS($X_CFLAGS)
3154 AC_CHECK_LIB(X11,XOpenDisplay,
3155 [CF_ADD_LIBS(-lX11)],,
3156 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
3157 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
3158 CF_ADD_LIBS(-lXCurses)
3160 #include <xcurses.h>
3161 char *XCursesProgramName = "test";
3163 [cf_cv_lib_XCurses=yes],
3164 [cf_cv_lib_XCurses=no])
3169 if test "$cf_cv_lib_XCurses" = yes ; then
3170 AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
3171 AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
3172 AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
3174 AC_MSG_ERROR(Cannot link with XCurses)
3177 dnl ---------------------------------------------------------------------------
3178 dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
3180 dnl Check for the package-config program, unless disabled by command-line.
3181 AC_DEFUN([CF_PKG_CONFIG],
3183 AC_MSG_CHECKING(if you want to use pkg-config)
3184 AC_ARG_WITH(pkg-config,
3185 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3186 [cf_pkg_config=$withval],
3187 [cf_pkg_config=yes])
3188 AC_MSG_RESULT($cf_pkg_config)
3190 case "$cf_pkg_config" in
3195 CF_ACVERSION_CHECK(2.52,
3196 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3197 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3204 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3205 if test "$PKG_CONFIG" != none ; then
3206 CF_PATH_SYNTAX(PKG_CONFIG)
3207 elif test "x$cf_pkg_config" != xno ; then
3208 AC_MSG_WARN(pkg-config is not installed)
3211 AC_SUBST(PKG_CONFIG)
3213 dnl ---------------------------------------------------------------------------
3214 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3215 dnl -----------------
3216 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3218 dnl POSIX.1-1990 _POSIX_SOURCE
3219 dnl POSIX.1-1990 and _POSIX_SOURCE and
3220 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3222 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3223 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3224 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3227 dnl $1 is the nominal value for _POSIX_C_SOURCE
3228 AC_DEFUN([CF_POSIX_C_SOURCE],
3229 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3231 if test "$cf_cv_posix_visible" = no; then
3233 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3235 cf_save_CFLAGS="$CFLAGS"
3236 cf_save_CPPFLAGS="$CPPFLAGS"
3238 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3239 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3241 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3242 CF_MSG_LOG(if the symbol is already defined go no further)
3243 AC_TRY_COMPILE([#include <sys/types.h>],[
3244 #ifndef _POSIX_C_SOURCE
3247 [cf_cv_posix_c_source=no],
3248 [cf_want_posix_source=no
3249 case .$cf_POSIX_C_SOURCE in
3251 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3254 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3255 cf_want_posix_source=yes
3258 cf_want_posix_source=yes
3261 if test "$cf_want_posix_source" = yes ; then
3262 AC_TRY_COMPILE([#include <sys/types.h>],[
3263 #ifdef _POSIX_SOURCE
3266 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3268 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3269 CFLAGS="$cf_trim_CFLAGS"
3270 CPPFLAGS="$cf_trim_CPPFLAGS"
3271 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3272 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3273 AC_TRY_COMPILE([#include <sys/types.h>],[
3274 #ifndef _POSIX_C_SOURCE
3277 [cf_cv_posix_c_source=no])
3278 CFLAGS="$cf_save_CFLAGS"
3279 CPPFLAGS="$cf_save_CPPFLAGS"
3283 if test "$cf_cv_posix_c_source" != no ; then
3284 CFLAGS="$cf_trim_CFLAGS"
3285 CPPFLAGS="$cf_trim_CPPFLAGS"
3286 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3289 fi # cf_cv_posix_visible
3292 dnl ---------------------------------------------------------------------------
3293 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3294 dnl ----------------
3295 dnl POSIX documents test-macros which an application may set before any system
3296 dnl headers are included to make features available.
3298 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3299 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3300 dnl recent features visible in the system header files unless the application
3301 dnl overrides the corresponding test-macros. Doing that introduces portability
3304 dnl This macro makes a special check for the symbols used for this, to avoid a
3305 dnl conflicting definition.
3306 AC_DEFUN([CF_POSIX_VISIBLE],
3308 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3309 AC_TRY_COMPILE([#include <stdio.h>],[
3310 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3311 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3312 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3313 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3314 #error conflicting symbols found
3316 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3319 dnl ---------------------------------------------------------------------------
3320 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
3322 dnl Append definitions and rules for the given programs to the subdirectory
3323 dnl Makefiles, and the recursion rule for the top-level Makefile.
3326 dnl $1 = script to run
3327 dnl $2 = list of subdirectories
3331 AC_DEFUN([CF_PRG_RULES],
3335 if test ! -d "$srcdir/$cf_dir" ; then
3337 elif test -f "$srcdir/$cf_dir/programs" ; then
3338 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
3343 dnl ---------------------------------------------------------------------------
3344 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3346 dnl standard check for CC, plus followup sanity checks
3347 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3348 AC_DEFUN([CF_PROG_CC],[
3349 CF_ACVERSION_CHECK(2.53,
3350 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3351 AC_REQUIRE([AC_PROG_CC])],
3353 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3355 CF_ACVERSION_CHECK(2.52,
3360 dnl ---------------------------------------------------------------------------
3361 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3363 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3364 dnl misc/tabset install won't work properly. Usually this happens only when
3365 dnl using the fallback mkinstalldirs script
3366 AC_DEFUN([CF_PROG_INSTALL],
3372 CF_DIRNAME(cf_dir,$INSTALL)
3373 test -z "$cf_dir" && cf_dir=.
3374 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3378 dnl ---------------------------------------------------------------------------
3379 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3381 AC_DEFUN([CF_PROG_LINT],
3383 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3385 (xcppcheck|x*/cppcheck)
3386 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3391 dnl ---------------------------------------------------------------------------
3392 dnl CF_REMOVE_CFLAGS version: 1 updated: 2021/08/28 15:20:37
3393 dnl ----------------
3394 dnl Remove a given option from CFLAGS/CPPFLAGS
3395 dnl $1 = option to remove
3396 dnl $2 = variable to update
3397 dnl $3 = nonempty to allow verbose message
3398 define([CF_REMOVE_CFLAGS],
3400 cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'`
3401 cf_old_cflag="[$]$2"
3405 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%$cf_tmp_cflag=[[^ ]]*%%g"`
3408 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%${cf_tmp_cflag}.%%"`
3411 cf_old_cflag=`echo "x$cf_old_cflag" | sed -e 's/^.//' -e "s%$cf_tmp_cflag%%"`
3415 if test "[$]$2" != "$cf_old_cflag" ;
3417 ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)])
3421 dnl ---------------------------------------------------------------------------
3422 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3423 dnl ----------------
3424 dnl Remove all -U and -D options that refer to the given symbol from a list
3425 dnl of C compiler options. This works around the problem that not all
3426 dnl compilers process -U and -D options from left-to-right, so a -U option
3427 dnl cannot be used to cancel the effect of a preceding -D option.
3429 dnl $1 = target (which could be the same as the source variable)
3430 dnl $2 = source (including '$')
3431 dnl $3 = symbol to remove
3432 define([CF_REMOVE_DEFINE],
3435 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3436 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3438 dnl ---------------------------------------------------------------------------
3439 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3440 dnl ---------------------
3441 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3442 dnl $1 = name of current macro
3443 define([CF_RESTORE_XTRA_FLAGS],
3445 LIBS="$cf_save_LIBS_$1"
3446 CFLAGS="$cf_save_CFLAGS_$1"
3447 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3449 dnl ---------------------------------------------------------------------------
3450 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
3452 AC_DEFUN([CF_RPATH_HACK],
3453 [AC_REQUIRE([AC_PROG_FGREP])dnl
3454 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
3456 AC_MSG_CHECKING(for updated LDFLAGS)
3457 if test -n "$LD_RPATH_OPT" ; then
3458 AC_MSG_RESULT(maybe)
3460 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3461 cf_rpath_list="/usr/lib /lib"
3462 if test "$cf_ldd_prog" != no
3466 AC_TRY_LINK([#include <stdio.h>],
3468 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3469 cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3471 # If we passed the link-test, but get a "not found" on a given library,
3472 # this could be due to inept reconfiguration of gcc to make it only
3473 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
3474 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3475 # /usr/local libraries.
3476 if test -n "$cf_rpath_oops"
3478 for cf_rpath_src in $cf_rpath_oops
3480 for cf_rpath_dir in \
3485 if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
3487 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3488 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3496 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3498 CF_RPATH_HACK_2(LDFLAGS)
3499 CF_RPATH_HACK_2(LIBS)
3501 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3505 AC_SUBST(EXTRA_LDFLAGS)
3507 dnl ---------------------------------------------------------------------------
3508 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
3510 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3511 dnl EXTRA_LDFLAGS for each -L option found.
3513 dnl $cf_rpath_list contains a list of directories to ignore.
3515 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
3516 dnl but LIBS often has misplaced -L options.
3517 AC_DEFUN([CF_RPATH_HACK_2],
3519 CF_VERBOSE(...checking $1 [$]$1)
3522 for cf_rpath_src in [$]$1
3524 case "$cf_rpath_src" in
3527 # check if this refers to a directory which we will ignore
3529 if test -n "$cf_rpath_list"
3531 for cf_rpath_item in $cf_rpath_list
3533 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3541 if test "$cf_rpath_skip" = no
3543 # transform the option
3544 if test "$LD_RPATH_OPT" = "-R " ; then
3545 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3547 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3550 # if we have not already added this, add it now
3551 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3552 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3554 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3555 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3560 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3564 CF_VERBOSE(...checked $1 [$]$1)
3565 AC_SUBST(EXTRA_LDFLAGS)
3567 dnl ---------------------------------------------------------------------------
3568 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3569 dnl ------------------
3570 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3571 dnl and libraries which do not update those variables.
3573 dnl $1 = name of current macro
3574 define([CF_SAVE_XTRA_FLAGS],
3576 cf_save_LIBS_$1="$LIBS"
3577 cf_save_CFLAGS_$1="$CFLAGS"
3578 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3579 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3580 for cf_X_CFLAGS in $X_CFLAGS
3582 case "x$cf_X_CFLAGS" in
3584 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3587 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3592 dnl ---------------------------------------------------------------------------
3593 dnl CF_SIGWINCH version: 6 updated: 2021/01/01 13:31:04
3595 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3596 dnl programs need this test).
3598 dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
3599 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
3600 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3601 dnl break that part of the interface as well.
3602 AC_DEFUN([CF_SIGWINCH],
3604 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3606 #include <sys/types.h>
3607 #include <sys/signal.h>
3608 ],[int x = SIGWINCH; (void)x],
3609 [cf_cv_define_sigwinch=yes],
3611 #undef _XOPEN_SOURCE
3612 #undef _POSIX_SOURCE
3613 #undef _POSIX_C_SOURCE
3614 #include <sys/types.h>
3615 #include <sys/signal.h>
3616 ],[int x = SIGWINCH; (void)x],
3617 [cf_cv_define_sigwinch=maybe],
3618 [cf_cv_define_sigwinch=no])
3622 if test "$cf_cv_define_sigwinch" = maybe ; then
3623 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3624 cf_cv_fixup_sigwinch=unknown
3626 while test "$cf_sigwinch" != 1
3629 #undef _XOPEN_SOURCE
3630 #undef _POSIX_SOURCE
3631 #undef _POSIX_C_SOURCE
3632 #include <sys/types.h>
3633 #include <sys/signal.h>
3635 #if SIGWINCH != $cf_sigwinch
3638 int x = SIGWINCH; (void)x],
3639 [cf_cv_fixup_sigwinch=$cf_sigwinch
3642 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
3646 if test "$cf_cv_fixup_sigwinch" != unknown ; then
3647 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3651 dnl ---------------------------------------------------------------------------
3652 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3654 dnl signal handler, but there are some gcc dependencies in that recommendation.
3656 AC_DEFUN([CF_SIG_ATOMIC_T],
3658 AC_MSG_CHECKING(for signal global datatype)
3659 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3661 "volatile sig_atomic_t" \
3666 #include <sys/types.h>
3672 static void handler(int sig)
3677 [signal(SIGINT, handler);
3679 [cf_cv_sig_atomic_t=$cf_type],
3680 [cf_cv_sig_atomic_t=no])
3681 test "$cf_cv_sig_atomic_t" != no && break
3684 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3685 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3687 dnl ---------------------------------------------------------------------------
3688 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3690 dnl Construct a search-list for a nonstandard header/lib-file
3691 dnl $1 = the variable to return as result
3692 dnl $2 = the package name
3693 dnl $3 = the subdirectory, e.g., bin, include or lib
3694 AC_DEFUN([CF_SUBDIR_PATH],
3698 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3700 for cf_subdir_prefix in \
3708 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3711 dnl ---------------------------------------------------------------------------
3712 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3713 dnl ------------------
3714 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3715 dnl older SCO configurations.
3716 AC_DEFUN([CF_SYS_TIME_SELECT],
3718 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3719 AC_CACHE_VAL(cf_cv_sys_time_select,[
3721 #include <sys/types.h>
3722 #ifdef HAVE_SYS_TIME_H
3723 #include <sys/time.h>
3725 #ifdef HAVE_SYS_SELECT_H
3726 #include <sys/select.h>
3728 ],[],[cf_cv_sys_time_select=yes],
3729 [cf_cv_sys_time_select=no])
3731 AC_MSG_RESULT($cf_cv_sys_time_select)
3732 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
3734 dnl ---------------------------------------------------------------------------
3735 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
3737 dnl Look for term.h, which is part of X/Open curses. It defines the interface
3738 dnl to terminfo database. Usually it is in the same include-path as curses.h,
3739 dnl but some packagers change this, breaking various applications.
3740 AC_DEFUN([CF_TERM_HEADER],[
3741 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3742 case "${cf_cv_ncurses_header}" in
3743 (*/ncurses.h|*/ncursesw.h)
3744 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3747 cf_term_header=term.h
3751 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3753 AC_TRY_COMPILE([#include <stdio.h>
3754 #include <${cf_cv_ncurses_header:-curses.h}>
3756 ],[int x = auto_left_margin; (void)x],[
3757 cf_cv_term_header="$cf_test"],[
3758 cf_cv_term_header=unknown
3760 test "$cf_cv_term_header" != unknown && break
3764 # Set definitions to allow ifdef'ing to accommodate subdirectories
3766 case "$cf_cv_term_header" in
3768 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3772 case "$cf_cv_term_header" in
3774 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3777 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3781 dnl ---------------------------------------------------------------------------
3782 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3784 dnl Define a top_builddir symbol, for applications that need an absolute path.
3785 AC_DEFUN([CF_TOP_BUILDDIR],
3787 top_builddir=ifelse($1,,`pwd`,$1)
3788 AC_SUBST(top_builddir)
3790 dnl ---------------------------------------------------------------------------
3791 dnl CF_TPUTS_PROTO version: 4 updated: 2021/01/04 19:45:09
3793 dnl Check for type of function-pointer passed to tputs. Some old
3794 dnl implementations used functions that had different prototypes, making it
3795 dnl hard to compile portable programs using tputs.
3796 AC_DEFUN([CF_TPUTS_PROTO],[
3797 CF_CURSES_FUNCS(tputs)
3798 if test "x$cf_cv_func_tputs" = xyes
3801 for cf_arg in int char
3803 for cf_ret in int void
3805 if test "$cf_ret" = void
3807 cf_return="/* nothing */"
3809 cf_return="return value"
3812 #include <${cf_cv_ncurses_header:-curses.h}>
3813 #include <$cf_cv_term_header>
3815 static $cf_ret outc($cf_arg value) { $cf_return; }
3817 tputs("hello", 0, outc);
3818 ${cf_cv_main_return:-return}(0);
3820 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3821 cat >>confdefs.h <<EOF
3822 #define TPUTS_ARG $cf_arg
3823 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3824 #define TPUTS_RETURN(value) $cf_return
3830 test "$cf_done" = yes && break
3834 dnl ---------------------------------------------------------------------------
3835 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3837 dnl Trim extra base X libraries added as a workaround for inconsistent library
3838 dnl dependencies returned by "new" pkg-config files.
3839 AC_DEFUN([CF_TRIM_X_LIBS],[
3840 for cf_trim_lib in Xmu Xt X11
3843 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3844 LIBS=`echo "$LIBS " | sed -e 's/ / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3845 CF_VERBOSE(..trimmed $LIBS)
3850 dnl ---------------------------------------------------------------------------
3851 dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15
3852 dnl -----------------
3853 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3854 dnl available in that form.
3856 dnl $1 = package name, which may be a shell variable
3857 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3858 dnl $3 = logic to use if pkg-config does not have the package
3859 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3860 AC_REQUIRE([CF_PKG_CONFIG])
3862 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then
3863 CF_VERBOSE(found package $1)
3864 cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`"
3865 cf_pkgconfig_libs="`$PKG_CONFIG --libs "$1" 2>/dev/null`"
3866 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3867 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3868 CF_ADD_CFLAGS($cf_pkgconfig_incs)
3869 CF_ADD_LIBS($cf_pkgconfig_libs)
3870 ifelse([$2],,:,[$2])
3874 ifelse([$3],,:,[$3])
3877 dnl ---------------------------------------------------------------------------
3878 dnl CF_TRY_XOPEN_SOURCE version: 3 updated: 2021/08/28 15:20:37
3879 dnl -------------------
3880 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3881 dnl can define it successfully.
3882 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3883 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3887 #include <sys/types.h>
3889 #ifndef _XOPEN_SOURCE
3892 [cf_cv_xopen_source=no],
3893 [cf_save="$CPPFLAGS"
3894 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3898 #include <sys/types.h>
3900 #ifdef _XOPEN_SOURCE
3903 [cf_cv_xopen_source=no],
3904 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3909 if test "$cf_cv_xopen_source" != no ; then
3910 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3911 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3912 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3913 CF_APPEND_CFLAGS($cf_temp_xopen_source)
3916 dnl ---------------------------------------------------------------------------
3917 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3919 dnl Make an uppercase version of a variable
3920 dnl $1=uppercase($2)
3921 AC_DEFUN([CF_UPPER],
3923 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3925 dnl ---------------------------------------------------------------------------
3926 dnl CF_UTF8_LIB version: 9 updated: 2021/05/19 19:35:25
3928 dnl Check for multibyte support, and if not found, utf8 compatibility library
3929 AC_DEFUN([CF_UTF8_LIB],
3931 AC_HAVE_HEADERS(wchar.h)
3932 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3933 cf_save_LIBS="$LIBS"
3941 [cf_cv_utf8_lib=yes],
3943 #include <libutf8.h>],[putwc(0,0);],utf8,
3944 [cf_cv_utf8_lib=add-on],
3945 [cf_cv_utf8_lib=no])
3948 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3950 if test "$cf_cv_utf8_lib" = "add-on" ; then
3951 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3952 CF_ADD_INCDIR($cf_cv_header_path_utf8)
3953 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3954 CF_ADD_LIBS($cf_cv_library_file_utf8)
3957 dnl ---------------------------------------------------------------------------
3958 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3960 dnl Use AC_VERBOSE w/o the warnings
3961 AC_DEFUN([CF_VERBOSE],
3962 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
3965 dnl ---------------------------------------------------------------------------
3966 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3968 dnl Check if type wide-character type $1 is declared, and if so, which header
3969 dnl file is needed. The second parameter is used to set a shell variable when
3970 dnl the type is not found. The first parameter sets a shell variable for the
3972 AC_DEFUN([CF_WCHAR_TYPE],
3974 # This is needed on Tru64 5.0 to declare $1
3975 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3980 #ifdef HAVE_LIBUTF8_H
3981 #include <libutf8.h>
3990 #ifdef HAVE_LIBUTF8_H
3991 #include <libutf8.h>
3995 [cf_cv_$1=unknown])])])
3997 if test "$cf_cv_$1" = yes ; then
3998 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
4003 # if we do not find $1 in either place, use substitution to provide a fallback.
4004 if test "$cf_cv_$1" = unknown ; then
4009 # if we find $1 in either place, use substitution to provide a fallback.
4010 if test "$cf_cv_$1" != unknown ; then
4015 dnl ---------------------------------------------------------------------------
4016 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4017 dnl ------------------
4018 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4020 AC_DEFUN([CF_WITH_CURSES_DIR],[
4022 AC_MSG_CHECKING(for specific curses-directory)
4023 AC_ARG_WITH(curses-dir,
4024 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4025 [cf_cv_curses_dir=$withval],
4026 [cf_cv_curses_dir=no])
4027 AC_MSG_RESULT($cf_cv_curses_dir)
4029 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4031 CF_PATH_SYNTAX(withval)
4032 if test -d "$cf_cv_curses_dir"
4034 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4035 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4039 dnl ---------------------------------------------------------------------------
4040 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
4041 dnl ----------------
4042 dnl Configure-option for dbmalloc. The optional parameter is used to override
4043 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4044 AC_DEFUN([CF_WITH_DBMALLOC],[
4045 CF_NO_LEAKS_OPTION(dbmalloc,
4046 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
4049 if test "$with_dbmalloc" = yes ; then
4050 AC_CHECK_HEADER(dbmalloc.h,
4051 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
4054 dnl ---------------------------------------------------------------------------
4055 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
4057 dnl Configure-option for dmalloc. The optional parameter is used to override
4058 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
4059 AC_DEFUN([CF_WITH_DMALLOC],[
4060 CF_NO_LEAKS_OPTION(dmalloc,
4061 [ --with-dmalloc test: use Gray Watson's dmalloc library],
4064 if test "$with_dmalloc" = yes ; then
4065 AC_CHECK_HEADER(dmalloc.h,
4066 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
4069 dnl ---------------------------------------------------------------------------
4070 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
4071 dnl --------------------
4072 dnl Allow for overriding the basename of a library, i.e., the part to which
4073 dnl prefixes/suffixes are attached.
4075 dnl $1 = variable to set
4076 dnl $2 = option name
4077 dnl $3 = default basename for library, if omitted use $2
4078 AC_DEFUN([CF_WITH_LIB_BASENAME],
4080 AC_MSG_CHECKING(for desired basename for $2 library)
4081 AC_ARG_WITH($2-libname,
4082 [ --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
4083 [with_lib_basename=$withval],
4084 [with_lib_basename=ifelse($3,,$2,$3)])
4085 $1="$with_lib_basename"
4089 $1=ifelse($3,,$2,$3)
4095 AC_MSG_RESULT([$]$1)
4098 dnl ---------------------------------------------------------------------------
4099 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
4100 dnl -------------------
4101 dnl Use this macro for programs which use any variant of "curses", e.g.,
4102 dnl "ncurses", and "PDCurses". Programs that can use curses and some unrelated
4103 dnl library (such as slang) should use a "--with-screen=XXX" option.
4105 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
4106 dnl of the macros inside this one - before this macro.
4107 define([CF_WITH_NCURSES_ETC],[
4112 AC_MSG_CHECKING(for specified curses library type)
4114 [ --with-screen=XXX use specified curses-libraries],
4115 [cf_cv_screen=$withval],[
4117 AC_ARG_WITH(ncursesw,
4118 [ --with-ncursesw use wide ncurses-libraries],
4119 [cf_cv_screen=ncursesw],[
4121 AC_ARG_WITH(ncurses,
4122 [ --with-ncurses use ncurses-libraries],
4123 [cf_cv_screen=ncurses],[
4125 AC_ARG_WITH(pdcurses,
4126 [ --with-pdcurses compile/link with pdcurses X11 library],
4127 [cf_cv_screen=pdcurses],[
4129 AC_ARG_WITH(curses-colr,
4130 [ --with-curses-colr compile/link with HPUX 10.x color-curses],
4131 [cf_cv_screen=curses_colr],[
4133 AC_ARG_WITH(curses-5lib,
4134 [ --with-curses-5lib compile/link with SunOS 5lib curses],
4135 [cf_cv_screen=curses_5lib])])])])])])
4137 AC_MSG_RESULT($cf_cv_screen)
4139 case $cf_cv_screen in
4145 CF_NCURSES_CONFIG($cf_cv_screen)
4148 CF_NCURSES_CONFIG($cf_cv_screen)
4154 AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
4158 CF_NCURSES_PTHREADS($cf_cv_screen)
4161 dnl ---------------------------------------------------------------------------
4162 dnl CF_WITH_SCREEN_PDCURSES version: 1 updated: 2020/08/28 16:56:27
4163 dnl -----------------------
4164 dnl Call this macro before CF_ENABLE_WARNINGS for configure scripts which use
4165 dnl the "--with-screen=pdcurses" selection. Doing that allows the configure
4166 dnl script to search for the X11/Xt header files to declare (or not) the
4167 dnl symbol needed to enable "const" in those header files. If that configure
4168 dnl option is not used, then those checks are unnecessary.
4169 AC_DEFUN([CF_WITH_SCREEN_PDCURSES],[
4170 AC_PROVIDE([AC_PATH_XTRA])
4171 AC_PROVIDE([AC_PATH_X])
4172 if test -n "$with_screen" && test "x$with_screen" = "xpdcurses"
4178 dnl ---------------------------------------------------------------------------
4179 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
4180 dnl ----------------
4181 AC_DEFUN([CF_WITH_VALGRIND],[
4182 CF_NO_LEAKS_OPTION(valgrind,
4183 [ --with-valgrind test: use valgrind],
4186 dnl ---------------------------------------------------------------------------
4187 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
4189 dnl Handle configure option "--with-x11-rgb", setting these shell
4192 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
4193 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
4195 dnl Most Linux's use this:
4196 dnl /usr/share/X11/rgb.txt
4197 dnl Debian uses this:
4198 dnl /etc/X11/rgb.txt
4199 dnl DragonFlyBSD ports uses this:
4200 dnl /usr/pkg/lib/X11/rgb.txt
4201 dnl FreeBSD ports use these:
4202 dnl /usr/local/lib/X11/rgb.txt
4203 dnl /usr/local/share/X11/rgb.txt
4204 dnl Mandriva has these:
4205 dnl /usr/lib/X11/rgb.txt
4206 dnl /usr/lib64/X11/rgb.txt
4207 dnl NetBSD has these
4208 dnl /usr/X11R7/lib/X11/rgb.txt
4209 dnl OpenSolaris uses
4211 dnl /usr/X11/etc/X11/rgb.txt
4212 dnl /usr/X11/share/X11/rgb.txt
4213 dnl /usr/X11/lib/X11/rgb.txt
4215 dnl /opt/local/share/X11/rgb.txt (MacPorts)
4216 dnl /opt/X11/share/X11/rgb.txt (non-ports)
4218 dnl /usr/X11/etc/X11/rgb.txt
4219 dnl /usr/X11/share/X11/rgb.txt (perhaps)
4220 dnl /usr/X11/lib/amd64/X11/rgb.txt
4221 dnl Solaris10 uses (in this order):
4222 dnl /usr/openwin/lib/X11/rgb.txt
4223 dnl /usr/X11/lib/X11/rgb.txt
4224 AC_DEFUN([CF_WITH_X11_RGB],[
4225 AC_MSG_CHECKING(for X11 rgb file)
4226 AC_ARG_WITH(x11-rgb,
4227 [ --with-x11-rgb=FILE file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
4228 [RGB_PATH=$withval],
4231 if test "x[$]RGB_PATH" = xauto
4233 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
4235 /opt/local/share/X11/rgb.txt \
4236 /opt/X11/share/X11/rgb.txt \
4237 /usr/share/X11/rgb.txt \
4238 /usr/X11/share/X11/rgb.txt \
4239 /usr/X11/lib/X11/rgb.txt \
4240 /usr/lib/X11/rgb.txt \
4242 /usr/pkg/lib/X11/rgb.txt \
4243 /usr/X11R7/lib/X11/rgb.txt \
4244 /usr/X11R6/lib/X11/rgb.txt \
4245 /usr/X11R5/lib/X11/rgb.txt \
4246 /usr/X11R4/lib/X11/rgb.txt \
4247 /usr/local/lib/X11/rgb.txt \
4248 /usr/local/share/X11/rgb.txt \
4249 /usr/lib64/X11/rgb.txt
4251 if test -f "$cf_path" ; then
4258 CF_PATH_SYNTAX(cf_path)
4261 AC_MSG_RESULT($RGB_PATH)
4263 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
4266 if test "$RGB_PATH" = no
4270 AC_SUBST(no_x11_rgb)
4272 dnl ---------------------------------------------------------------------------
4273 dnl CF_XOPEN_CURSES version: 17 updated: 2021/07/10 12:22:27
4275 dnl Test if we should define X/Open source for curses, needed on Digital Unix
4276 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
4278 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
4279 dnl as getbegy(). The latter is better design, but the former is standard.
4280 AC_DEFUN([CF_XOPEN_CURSES],
4282 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
4283 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
4284 cf_cv_need_xopen_extension=unknown
4287 #include <${cf_cv_ncurses_header:-curses.h}>],[
4288 #if defined(NCURSES_VERSION_PATCH)
4289 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
4293 #ifdef NCURSES_WIDECHAR
4294 make an error /* prefer to fall-through on the second checks */
4297 int check2 = curs_set((int)sizeof(check));
4298 long x = winnstr(stdscr, "", 0);
4301 getbegyx(stdscr, y1, x1);
4306 [cf_cv_need_xopen_extension=none],
4308 for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
4311 #define $cf_try_xopen_extension 1
4313 #include <${cf_cv_ncurses_header:-curses.h}>],[
4315 int check2 = curs_set((int)sizeof(check));
4316 long x = winnstr(stdscr, "", 0);
4318 getbegyx(stdscr, y1, x1);
4324 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
4329 case "$cf_cv_need_xopen_extension" in
4331 CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
4336 dnl ---------------------------------------------------------------------------
4337 dnl CF_XOPEN_SOURCE version: 59 updated: 2021/08/28 15:20:37
4339 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4340 dnl or adapt to the vendor's definitions to get equivalent functionality,
4341 dnl without losing the common non-POSIX features.
4344 dnl $1 is the nominal value for _XOPEN_SOURCE
4345 dnl $2 is the nominal value for _POSIX_C_SOURCE
4346 AC_DEFUN([CF_XOPEN_SOURCE],[
4347 AC_REQUIRE([AC_CANONICAL_HOST])
4348 AC_REQUIRE([CF_POSIX_VISIBLE])
4350 if test "$cf_cv_posix_visible" = no; then
4352 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4353 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4358 cf_xopen_source="-D_ALL_SOURCE"
4364 cf_xopen_source="-D_APPLE_C_SOURCE"
4367 cf_xopen_source="-D_DARWIN_C_SOURCE"
4370 (freebsd*|dragonfly*|midnightbsd*)
4371 # 5.x headers associate
4372 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4373 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4374 cf_POSIX_C_SOURCE=200112L
4376 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4379 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4382 cf_xopen_source="-D_HPUX_SOURCE"
4385 cf_xopen_source="-D_SGI_SOURCE"
4388 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4389 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4392 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4395 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4397 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4400 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4403 # OpenBSD 6.x has broken locale support, both compile-time and runtime.
4404 # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html
4405 # Abusing the conformance level is a workaround.
4406 AC_MSG_WARN(this system does not provide usable locale support)
4407 cf_xopen_source="-D_BSD_SOURCE"
4411 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4412 cf_xopen_source="-D_BSD_SOURCE"
4416 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4419 cf_xopen_source="-D_OSF_SOURCE"
4422 cf_xopen_source="-D_QNX_SOURCE"
4425 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4428 cf_xopen_source="-D__EXTENSIONS__"
4429 cf_cv_xopen_source=broken
4431 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4437 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4441 if test -n "$cf_xopen_source" ; then
4442 CF_APPEND_CFLAGS($cf_xopen_source,true)
4445 dnl In anything but the default case, we may have system-specific setting
4446 dnl which is still not guaranteed to provide all of the entrypoints that
4447 dnl _XOPEN_SOURCE would yield.
4448 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4449 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4450 AC_TRY_COMPILE([#include <stdlib.h>],[
4451 #ifndef _XOPEN_SOURCE
4454 [cf_XOPEN_SOURCE_set=yes],
4455 [cf_XOPEN_SOURCE_set=no])
4456 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4457 if test "$cf_XOPEN_SOURCE_set" = yes
4459 AC_TRY_COMPILE([#include <stdlib.h>],[
4460 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4463 [cf_XOPEN_SOURCE_set_ok=yes],
4464 [cf_XOPEN_SOURCE_set_ok=no])
4465 if test "$cf_XOPEN_SOURCE_set_ok" = no
4467 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4473 fi # cf_cv_posix_visible
4475 dnl ---------------------------------------------------------------------------
4476 dnl CF_X_ATHENA version: 24 updated: 2020/03/10 18:53:47
4478 dnl Check for Xaw (Athena) libraries
4480 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4481 AC_DEFUN([CF_X_ATHENA],
4483 cf_x_athena=${cf_x_athena:-Xaw}
4485 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4488 [ --with-Xaw3d link with Xaw 3d library])
4489 if test "$withval" = yes ; then
4496 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4498 AC_ARG_WITH(Xaw3dxft,
4499 [ --with-Xaw3dxft link with Xaw 3d xft library])
4500 if test "$withval" = yes ; then
4501 cf_x_athena=Xaw3dxft
4507 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4510 [ --with-neXtaw link with neXT Athena library])
4511 if test "$withval" = yes ; then
4518 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4520 AC_ARG_WITH(XawPlus,
4521 [ --with-XawPlus link with Athena-Plus library])
4522 if test "$withval" = yes ; then
4531 if test "$PKG_CONFIG" != none ; then
4533 test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4534 for cf_athena_pkg in \
4537 ${cf_x_athena}-devel \
4539 lib${cf_x_athena}-devel
4541 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4542 cf_x_athena_lib="$cf_pkgconfig_libs"
4543 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4544 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4548 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4550 #include <X11/Xmu/CharSet.h>
4552 int check = XmuCompareISOLatin1("big", "small");
4554 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4556 if test "$cf_cv_xaw_compat" = no
4558 # workaround for broken ".pc" files...
4559 case "$cf_x_athena_lib" in
4563 CF_VERBOSE(work around broken package)
4565 cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4566 CF_TRY_PKG_CONFIG(xmu,[
4568 CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4570 CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4581 if test -z "$cf_x_athena_lib" ; then
4584 CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4585 CF_X_ATHENA_LIBS($cf_x_athena)
4588 dnl ---------------------------------------------------------------------------
4589 dnl CF_X_ATHENA_CPPFLAGS version: 9 updated: 2020/12/31 10:54:15
4590 dnl --------------------
4591 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4592 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4593 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4595 AC_REQUIRE([AC_PATH_XTRA])
4596 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4599 for cf_path in default \
4600 /usr/contrib/X11R6 \
4601 /usr/contrib/X11R5 \
4605 if test -z "$cf_x_athena_inc" ; then
4606 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4607 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4608 if test "$cf_path" != default ; then
4609 CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4610 AC_MSG_CHECKING(for $cf_test in $cf_path)
4612 AC_MSG_CHECKING(for $cf_test)
4615 #include <X11/Intrinsic.h>
4616 #include <$cf_test>],[],
4619 AC_MSG_RESULT($cf_result)
4620 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4621 if test "$cf_result" = yes ; then
4622 test "$cf_path" = default && cf_x_athena_inc=default
4623 test "$cf_path" != default && cf_x_athena_inc="$cf_path/include"
4629 if test -z "$cf_x_athena_inc" ; then
4630 AC_MSG_WARN([Unable to find Athena header files])
4631 elif test "$cf_x_athena_inc" != default ; then
4632 CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4635 dnl ---------------------------------------------------------------------------
4636 dnl CF_X_ATHENA_LIBS version: 13 updated: 2020/01/11 18:16:10
4637 dnl ----------------
4638 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4639 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4640 AC_DEFUN([CF_X_ATHENA_LIBS],
4641 [AC_REQUIRE([CF_X_TOOLKIT])
4642 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4645 for cf_path in default \
4646 /usr/contrib/X11R6 \
4647 /usr/contrib/X11R5 \
4652 ${cf_x_athena_root} \
4653 ${cf_x_athena_root}7 \
4654 ${cf_x_athena_root}6
4658 "-l$cf_lib -lXpm -lXmu" \
4659 "-l${cf_lib}_s -lXmu_s"
4661 test -n "$cf_x_athena_lib" && break
4663 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4664 cf_test=XawSimpleMenuAddGlobalActions
4665 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4666 CF_ADD_LIBS($cf_libs)
4667 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4669 #include <X11/Intrinsic.h>
4670 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4672 $cf_test((XtAppContext) 0)],
4675 AC_MSG_RESULT($cf_result)
4676 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4678 if test "$cf_result" = yes ; then
4679 cf_x_athena_lib="$cf_libs"
4683 test -n "$cf_x_athena_lib" && break
4687 if test -z "$cf_x_athena_lib" ; then
4689 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4692 CF_ADD_LIBS($cf_x_athena_lib)
4693 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4694 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4696 dnl ---------------------------------------------------------------------------
4697 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4699 AC_DEFUN([CF_X_EXT],[
4700 CF_TRY_PKG_CONFIG(Xext,,[
4701 AC_CHECK_LIB(Xext,XextCreateExtension,
4702 [CF_ADD_LIB(Xext)])])
4704 dnl ---------------------------------------------------------------------------
4705 dnl CF_X_TOOLKIT version: 26 updated: 2021/01/02 09:31:20
4707 dnl Check for X Toolkit libraries
4708 AC_DEFUN([CF_X_TOOLKIT],
4710 AC_REQUIRE([AC_PATH_XTRA])
4711 AC_REQUIRE([CF_CHECK_CACHE])
4713 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4714 # in some cases has installed dummy files in the former, other cases replaced
4715 # it with a link to the new location). This complicates the configure script.
4716 # Check for that pitfall, and recover using pkg-config
4718 # If none of these are set, the configuration is almost certainly broken.
4719 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4721 CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4722 CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4723 CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4724 CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4726 LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS"
4731 CF_TRY_PKG_CONFIG(xt,[
4737 # we have an "xt" package, but it may omit Xt's dependency on X11
4738 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4740 #include <X11/Xlib.h>
4742 int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4743 int rc2 = XClearWindow((Display*) 0, (Window) 0);
4744 int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4745 int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4746 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4747 if test "$cf_cv_xt_x11_compat" = no
4749 CF_VERBOSE(work around broken X11 dependency)
4750 # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4751 CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4756 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4758 #include <X11/Shell.h>
4759 ],[int num = IceConnectionNumber(0); (void) num
4760 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4762 if test "$cf_cv_xt_ice_compat" = no
4764 # workaround for broken ".pc" files used for X Toolkit.
4765 case "x$X_PRE_LIBS" in
4771 CF_VERBOSE(work around broken ICE dependency)
4772 CF_TRY_PKG_CONFIG(ice,
4773 [CF_TRY_PKG_CONFIG(sm)],
4774 [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4784 LDFLAGS="$X_LIBS $LDFLAGS"
4785 CF_CHECK_CFLAGS($X_CFLAGS)
4787 AC_CHECK_FUNC(XOpenDisplay,,[
4788 AC_CHECK_LIB(X11,XOpenDisplay,
4789 [CF_ADD_LIB(X11)])])
4791 AC_CHECK_FUNC(XtAppInitialize,,[
4792 AC_CHECK_LIB(Xt, XtAppInitialize,
4793 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4795 LIBS="-lXt $LIBS"])])
4798 if test "$cf_have_X_LIBS" = no ; then
4800 [Unable to successfully link X Toolkit library (-lXt) with
4801 test program. You will have to check and add the proper libraries by hand
4805 dnl ---------------------------------------------------------------------------
4806 dnl CF__CURSES_DATA version: 3 updated: 2021/01/04 19:45:09
4808 dnl Attempt to make a copy of a curses data item. This is needed in the
4809 dnl check-data configure tests when using ncurses, because the symbol may be
4810 dnl actually a function return-value. That could happen if the linker is
4811 dnl broken (does not resolve data-only references), or if ncurses is configured
4812 dnl to support re-entrant code.
4815 define([CF__CURSES_DATA],[
4816 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4817 const void *$1 = (const void *)($2);
4819 const void *$1 = &($2);
4821 fprintf(stderr, "testing linkage of $2:%p\\n", (const void *)$1);
4823 dnl ---------------------------------------------------------------------------
4824 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4826 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4827 dnl are both available.
4828 define([CF__CURSES_HEAD],[
4830 #include <xcurses.h>
4831 char * XCursesProgramName = "test";
4833 #include <${cf_cv_ncurses_header:-curses.h}>
4834 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4835 #include <ncursesw/term.h>
4836 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4837 #include <ncurses/term.h>
4838 #elif defined(HAVE_TERM_H)