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.192 2021/03/23 00:37:21 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_TEXT version: 1 updated: 2017/02/25 18:58:55
350 dnl use this macro for appending text without introducing an extra blank at
352 define([CF_APPEND_TEXT],
354 test -n "[$]$1" && $1="[$]$1 "
357 dnl ---------------------------------------------------------------------------
358 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
360 dnl Allow user to disable a normally-on option.
361 AC_DEFUN([CF_ARG_DISABLE],
362 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
363 dnl ---------------------------------------------------------------------------
364 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
366 dnl Allow user to enable a normally-off option.
367 AC_DEFUN([CF_ARG_ENABLE],
368 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
369 dnl ---------------------------------------------------------------------------
370 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
372 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
378 dnl $3 = action to perform if option is not default
379 dnl $4 = action if perform if option is default
380 dnl $5 = default option value (either 'yes' or 'no')
381 AC_DEFUN([CF_ARG_OPTION],
382 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
383 if test "$enableval" != "$5" ; then
385 ,[ $3]) ifelse([$4],,,[
388 fi],[enableval=$5 ifelse([$4],,,[
392 dnl ---------------------------------------------------------------------------
393 dnl CF_C11_NORETURN version: 2 updated: 2021/03/22 20:37:21
395 AC_DEFUN([CF_C11_NORETURN],
397 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
398 CF_ARG_ENABLE(stdnoreturn,
399 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics],
400 [enable_stdnoreturn=yes],
401 [enable_stdnoreturn=no])
402 AC_MSG_RESULT($enable_stdnoreturn)
404 if test $enable_stdnoreturn = yes; then
405 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
409 #include <stdnoreturn.h>
410 static void giveup(void) { exit(0); }
412 [if (feof(stdin)) giveup()],
413 cf_cv_c11_noreturn=yes,
414 cf_cv_c11_noreturn=no)
417 cf_cv_c11_noreturn=no,
420 if test "$cf_cv_c11_noreturn" = yes; then
421 AC_DEFINE(HAVE_STDNORETURN_H, 1)
422 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
428 AC_SUBST(HAVE_STDNORETURN_H)
430 dnl ---------------------------------------------------------------------------
431 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
433 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
434 dnl into CC. This will not help with broken scripts that wrap the compiler
435 dnl with options, but eliminates a more common category of user confusion.
437 dnl In particular, it addresses the problem of being able to run the C
438 dnl preprocessor in a consistent manner.
440 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
441 dnl the nuisance of having inconsistent settings for compiler and preprocessor
442 dnl outweighs that limitation.
443 AC_DEFUN([CF_CC_ENV_FLAGS],
445 # This should have been defined by AC_PROG_CC
448 AC_MSG_CHECKING(\$CFLAGS variable)
451 AC_MSG_RESULT(broken)
452 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
455 for cf_arg in $cf_flags
457 CF_ADD_CFLAGS($cf_arg)
465 AC_MSG_CHECKING(\$CC variable)
468 AC_MSG_RESULT(broken)
469 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
471 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
472 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
474 for cf_arg in $cf_flags
478 CF_ADD_CFLAGS($cf_arg)
485 CF_VERBOSE(resulting CC: '$CC')
486 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
487 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
494 dnl ---------------------------------------------------------------------------
495 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
497 dnl Check if we're accidentally using a cache from a different machine.
498 dnl Derive the system name, as a check for reusing the autoconf cache.
500 dnl If we've packaged config.guess and config.sub, run that (since it does a
501 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
502 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
503 dnl which is useful in cross-compiles.
505 dnl Note: we would use $ac_config_sub, but that is one of the places where
506 dnl autoconf 2.5x broke compatibility with autoconf 2.13
507 AC_DEFUN([CF_CHECK_CACHE],
509 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
510 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
511 system_name="$host_os"
513 system_name="`(uname -s -r) 2>/dev/null`"
514 if test -z "$system_name" ; then
515 system_name="`(hostname) 2>/dev/null`"
518 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
519 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
521 test -z "$system_name" && system_name="$cf_cv_system_name"
522 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
524 if test ".$system_name" != ".$cf_cv_system_name" ; then
525 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
526 AC_MSG_ERROR("Please remove config.cache and try again.")
529 dnl ---------------------------------------------------------------------------
530 dnl CF_CHECK_CFLAGS version: 4 updated: 2021/01/02 19:22:58
532 dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
533 dnl a build-configuration such as imake. These have the pitfall that they
534 dnl often contain compiler-specific options which we cannot use, mixed with
535 dnl preprocessor options that we usually can.
536 AC_DEFUN([CF_CHECK_CFLAGS],
538 CF_VERBOSE(checking additions to CFLAGS)
539 cf_check_cflags="$CFLAGS"
540 cf_check_cppflags="$CPPFLAGS"
541 CF_ADD_CFLAGS($1,yes)
542 if test "x$cf_check_cflags" != "x$CFLAGS" ; then
543 AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
544 [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS)
545 if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
546 CF_VERBOSE(but keeping change to \$CPPFLAGS)
548 CFLAGS="$cf_check_cflags"])
551 dnl ---------------------------------------------------------------------------
552 dnl CF_CHECK_CURSES_LIB version: 3 updated: 2021/01/04 19:45:09
553 dnl -------------------
554 dnl $1 = nominal library name, used also for header lookup
555 dnl $2 = suffix to append to library name
556 dnl $3 = function to check for using AC_CHECK_LIB
557 dnl $4 = optional parameter list for $3
558 AC_DEFUN([CF_CHECK_CURSES_LIB],
560 AC_REQUIRE([CF_PKG_CONFIG])
562 cf_have_curses_lib=no
564 : ${NCURSES_CONFIG_PKG:=none}
565 if test "x${NCURSES_CONFIG_PKG}" = xnone; then
567 elif test "x${PKG_CONFIG:=none}" != xnone; then
568 AC_MSG_CHECKING(pkg-config for $1$2)
569 if "$PKG_CONFIG" --exists "$1$2" ; then
572 AC_MSG_CHECKING(if the $1$2 package files work)
574 cf_save_CPPFLAGS="$CPPFLAGS"
577 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags "$1$2"`)
578 CF_ADD_LIBS(`$PKG_CONFIG --libs "$1$2"`)
580 AC_TRY_LINK([#include <$1.h>],
581 [(void) $3 ( ]ifelse([$4],,,[[$4]])[ );],
582 [AC_TRY_RUN([#include <$1.h>
584 { (void) $3 ( ]ifelse([$4],,,[[$4]])[ ); return 0; }],
585 [cf_have_curses_lib=yes],
586 [cf_have_curses_lib=no],
587 [cf_have_curses_lib=maybe])],
588 [cf_have_curses_lib=no])
589 AC_MSG_RESULT($cf_have_curses_lib)
590 test "$cf_have_curses_lib" = maybe && cf_have_curses_lib=yes
591 if test "$cf_have_curses_lib" != "yes"
593 CPPFLAGS="$cf_save_CPPFLAGS"
596 CF_UPPER(cf_upper,have_lib$1)
597 AC_DEFINE_UNQUOTED($cf_upper,1)
601 if test "$cf_have_curses_lib" = no; then
602 AC_CHECK_LIB($1$2,$3,[
603 CF_UPPER(cf_upper,have_lib$1)
605 AC_DEFINE_UNQUOTED($cf_upper,1)])
608 dnl ---------------------------------------------------------------------------
609 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
610 dnl -----------------
611 dnl Check if the given compiler is really clang. clang's C driver defines
612 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
613 dnl not ignore some gcc options.
615 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
616 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
617 dnl the wrappers for gcc and g++ warnings.
619 dnl $1 = GCC (default) or GXX
620 dnl $2 = CLANG_COMPILER (default)
621 dnl $3 = CFLAGS (default) or CXXFLAGS
622 AC_DEFUN([CF_CLANG_COMPILER],[
623 ifelse([$2],,CLANG_COMPILER,[$2])=no
625 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
626 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
627 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
633 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
635 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
636 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
641 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
643 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
644 AC_MSG_WARN(replacing broken compiler alias $CC)
645 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
650 AC_MSG_CHECKING(version of $CC)
651 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.]].*//'`"
652 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
653 AC_MSG_RESULT($CLANG_VERSION)
655 for cf_clang_opt in \
657 -Wno-error=implicit-function-declaration
659 AC_MSG_CHECKING(if option $cf_clang_opt works)
660 cf_save_CFLAGS="$CFLAGS"
661 CFLAGS="$CFLAGS $cf_clang_opt"
663 #include <stdio.h>],[
664 printf("hello!\\n");],[
665 cf_clang_optok=yes],[
667 AC_MSG_RESULT($cf_clang_optok)
668 CFLAGS="$cf_save_CFLAGS"
669 if test "$cf_clang_optok" = yes; then
670 CF_VERBOSE(adding option $cf_clang_opt)
671 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
676 dnl ---------------------------------------------------------------------------
677 dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
678 dnl -----------------
679 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
680 dnl character-strings.
682 dnl It is ambiguous because the specification accommodated the pre-ANSI
683 dnl compilers bundled by more than one vendor in lieu of providing a standard C
684 dnl compiler other than by costly add-ons. Because of this, the specification
685 dnl did not take into account the use of const for telling the compiler that
686 dnl string literals would be in readonly memory.
688 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
689 dnl let the compiler decide how to represent Xt's strings which were #define'd.
690 dnl That does not solve the problem of using the block of Xt's strings which
691 dnl are compiled into the library (and is less efficient than one might want).
693 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
694 dnl when compiling the library and compiling using the library, to tell the
695 dnl compiler that String is const.
696 AC_DEFUN([CF_CONST_X_STRING],
698 AC_REQUIRE([AC_PATH_XTRA])
700 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
705 #include <X11/Intrinsic.h>
707 [String foo = malloc(1); (void)foo],[
709 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
712 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
713 #undef XTSTRINGDEFINES /* X11R5 and later */
715 #include <X11/Intrinsic.h>
716 ],[String foo = malloc(1); *foo = 0],[
717 cf_cv_const_x_string=no
719 cf_cv_const_x_string=yes
723 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
725 case "$cf_cv_const_x_string" in
727 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
730 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
736 dnl ---------------------------------------------------------------------------
737 dnl CF_CURSES_ACS_MAP version: 8 updated: 2021/01/04 19:45:09
738 dnl -----------------
739 dnl Check for likely values of acs_map[]:
740 AC_DEFUN([CF_CURSES_ACS_MAP],
742 AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
743 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
744 cf_cv_curses_acs_map=unknown
745 for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
748 #include <${cf_cv_ncurses_header:-curses.h}>
750 ${name}['k'] = ACS_PLUS
751 ],[cf_cv_curses_acs_map=$name; break])
755 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_])
757 dnl ---------------------------------------------------------------------------
758 dnl CF_CURSES_CHECK_DATA version: 10 updated: 2021/01/04 19:45:09
759 dnl --------------------
760 dnl Check if curses.h defines the given data/variable.
761 dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
763 dnl $1 = data item(s) to check for
764 dnl $2 = action on success, e.g., "break" to quit checking a series of choices
765 AC_DEFUN([CF_CURSES_CHECK_DATA],
769 AC_MSG_CHECKING(for data $cf_data declaration in ${cf_cv_ncurses_header:-curses.h})
771 AC_TRY_COMPILE(CF__CURSES_HEAD,
772 CF__CURSES_DATA(foo,$cf_data)
775 AC_MSG_RESULT($cf_result)
777 if test "$cf_result" = yes ; then
778 CF_UPPER(cf_result,have_curses_data_$cf_data)
779 AC_DEFINE_UNQUOTED($cf_result)
782 AC_MSG_CHECKING(for data $cf_data in library)
783 # BSD linkers insist on making weak linkage, but resolve at runtime.
784 AC_TRY_RUN(CF__CURSES_HEAD
786 extern char $cf_data;
789 ]CF__CURSES_DATA(foo,$cf_data)[
790 ${cf_cv_main_return:-return}(foo == 0);
794 AC_TRY_LINK(CF__CURSES_HEAD
795 [extern char $cf_data;],[
797 ]CF__CURSES_DATA(foo,$cf_data)[
798 ${cf_cv_main_return:-return}(foo == 0);
800 ],[cf_result=yes],[cf_result=no])
802 AC_MSG_RESULT($cf_result)
803 if test "$cf_result" = yes ; then
804 CF_UPPER(cf_result,decl_curses_data_$cf_data)
805 AC_DEFINE_UNQUOTED($cf_result)
806 # do not exit loop here, since we prefer system's declarations
811 dnl ---------------------------------------------------------------------------
812 dnl CF_CURSES_CHECK_TYPE version: 5 updated: 2021/01/04 19:45:09
813 dnl --------------------
814 dnl Check if curses.h defines the given type
815 AC_DEFUN([CF_CURSES_CHECK_TYPE],
817 AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
819 #ifndef _XOPEN_SOURCE_EXTENDED
820 #define _XOPEN_SOURCE_EXTENDED
822 #include <${cf_cv_ncurses_header:-curses.h}>],[
824 ],cf_result=yes,cf_result=no)
825 AC_MSG_RESULT($cf_result)
826 if test "$cf_result" = yes ; then
827 CF_UPPER(cf_result,have_type_$1)
828 AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
830 AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
833 dnl ---------------------------------------------------------------------------
834 dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
836 dnl Tie together the configure-script macros for curses. It may be ncurses,
837 dnl but unless asked, we do not make a special search for ncurses. However,
838 dnl still check for the ncurses version number, for use in other macros.
839 AC_DEFUN([CF_CURSES_CONFIG],
845 dnl ---------------------------------------------------------------------------
846 dnl CF_CURSES_CPPFLAGS version: 14 updated: 2021/01/02 09:31:20
847 dnl ------------------
848 dnl Look for the curses headers.
849 AC_DEFUN([CF_CURSES_CPPFLAGS],[
851 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
852 cf_cv_curses_incdir=no
855 if test "x$cf_cv_screen" = "xcurses_colr"
857 test -d /usr/include/curses_colr && \
858 cf_cv_curses_incdir="-I/usr/include/curses_colr"
862 if test "x$cf_cv_screen" = "xcurses_5lib"
864 test -d /usr/5lib && \
865 test -d /usr/5include && \
866 cf_cv_curses_incdir="-I/usr/5include"
871 if test "$cf_cv_curses_incdir" != no
873 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
879 dnl ---------------------------------------------------------------------------
880 dnl CF_CURSES_FUNCS version: 20 updated: 2020/12/31 20:19:42
882 dnl Curses-functions are a little complicated, since a lot of them are macros.
883 AC_DEFUN([CF_CURSES_FUNCS],
885 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
886 AC_REQUIRE([CF_XOPEN_CURSES])
887 AC_REQUIRE([CF_CURSES_TERM_H])
888 AC_REQUIRE([CF_CURSES_UNCTRL_H])
891 CF_UPPER(cf_tr_func,$cf_func)
892 AC_MSG_CHECKING(for ${cf_func})
893 CF_MSG_LOG(${cf_func})
894 AC_CACHE_VAL(cf_cv_func_$cf_func,[
895 eval cf_result='$ac_cv_func_'$cf_func
896 if test ".$cf_result" != ".no"; then
897 AC_TRY_LINK(CF__CURSES_HEAD,
900 long foo = (long)(&${cf_func});
901 fprintf(stderr, "testing linkage of $cf_func:%p\\n", (void *)foo);
902 if (foo + 1234L > 5678L)
903 ${cf_cv_main_return:-return}(foo != 0);
909 eval 'cf_cv_func_'$cf_func'="$cf_result"'
911 # use the computed/retrieved cache-value:
912 eval 'cf_result=$cf_cv_func_'$cf_func
913 AC_MSG_RESULT($cf_result)
914 if test "$cf_result" != no; then
915 AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
919 dnl ---------------------------------------------------------------------------
920 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
922 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
923 dnl variations of ncurses' installs.
925 dnl $1 = ncurses when looking for ncurses, or is empty
926 AC_DEFUN([CF_CURSES_HEADER],[
927 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
928 cf_cv_ncurses_header=none
930 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
931 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
933 AC_TRY_COMPILE([#include <${cf_header}>],
934 [initscr(); tgoto("?", 0,0)],
935 [cf_cv_ncurses_header=$cf_header; break],[])
939 if test "$cf_cv_ncurses_header" = none ; then
940 AC_MSG_ERROR(No curses header-files found)
943 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
944 AC_CHECK_HEADERS($cf_cv_ncurses_header)
946 dnl ---------------------------------------------------------------------------
947 dnl CF_CURSES_LIBS version: 44 updated: 2021/01/02 09:31:20
949 dnl Look for the curses libraries. Older curses implementations may require
950 dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first.
951 AC_DEFUN([CF_CURSES_LIBS],[
953 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
954 AC_MSG_CHECKING(if we have identified curses libraries)
955 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
956 [initscr(); tgoto("?", 0,0)],
959 AC_MSG_RESULT($cf_result)
961 if test "$cf_result" = no ; then
964 AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
967 # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
968 # next (1998), and xcurses "newer" (2000). There is no header file for
969 # Hcurses; the subdirectory curses_colr has the headers (curses.h and
970 # term.h) for cur_colr
971 if test "x$cf_cv_screen" = "xcurses_colr"
973 AC_CHECK_LIB(cur_colr,initscr,[
974 CF_ADD_LIBS(-lcur_colr)
975 ac_cv_func_initscr=yes
977 AC_CHECK_LIB(Hcurses,initscr,[
978 # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
979 CF_ADD_LIBS(-lHcurses)
980 CF_APPEND_TEXT(CPPFLAGS,-D__HP_CURSES -D_HP_CURSES)
981 ac_cv_func_initscr=yes
986 case `arch 2>/dev/null` in
990 CF_ADD_LIBDIR(/lib64)
1001 if test "x$cf_cv_screen" = "xcurses_5lib"
1003 if test -d /usr/5lib ; then
1004 CF_ADD_LIBDIR(/usr/5lib)
1005 CF_ADD_LIBS(-lcurses -ltermcap)
1008 ac_cv_func_initscr=yes
1012 if test ".$ac_cv_func_initscr" != .yes ; then
1013 cf_save_LIBS="$LIBS"
1015 if test ".${cf_cv_ncurses_version:-no}" != .no
1017 cf_check_list="ncurses curses cursesX"
1019 cf_check_list="cursesX curses ncurses"
1022 # Check for library containing tgoto. Do this before curses library
1023 # because it may be needed to link the test-case for initscr.
1024 if test "x$cf_term_lib" = x
1026 AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
1027 for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
1029 AC_CHECK_LIB($cf_term_lib,tgoto,[
1030 : "${cf_nculib_root:=$cf_term_lib}"
1037 # Check for library containing initscr
1038 test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
1039 if test "x$cf_curs_lib" = x
1041 for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
1043 LIBS="-l$cf_curs_lib $cf_save_LIBS"
1044 if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
1045 AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
1046 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1050 AC_MSG_RESULT($cf_result)
1051 test "$cf_result" = yes && break
1052 elif test "$cf_curs_lib" = "$cf_term_lib" ; then
1054 elif test "$cf_term_lib" != predefined ; then
1055 AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
1056 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1057 [initscr(); tgoto((char *)0, 0, 0);],
1060 LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
1061 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1066 AC_MSG_RESULT($cf_result)
1067 test "$cf_result" != error && break
1071 test "$cf_curs_lib" = unknown && AC_MSG_ERROR(no curses library found)
1076 dnl ---------------------------------------------------------------------------
1077 dnl CF_CURSES_TERM_H version: 15 updated: 2021/01/02 09:31:20
1078 dnl ----------------
1079 dnl SVr4 curses should have term.h as well (where it puts the definitions of
1080 dnl the low-level interface). This may not be true in old/broken implementations,
1081 dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
1082 dnl running with Solaris 2.5.1).
1083 AC_DEFUN([CF_CURSES_TERM_H],
1085 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1087 AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
1089 # If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
1090 # for <term.h> if we do not find the variant.
1092 cf_header_list="term.h ncurses/term.h ncursesw/term.h"
1094 case "${cf_cv_ncurses_header:-curses.h}" in
1096 cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
1097 cf_header_list="$cf_header_item $cf_header_list"
1101 for cf_header in $cf_header_list
1104 #include <${cf_cv_ncurses_header:-curses.h}>
1105 #include <${cf_header}>],
1106 [WINDOW *x; (void)x],
1107 [cf_cv_term_header=$cf_header
1109 [cf_cv_term_header=no])
1112 case "$cf_cv_term_header" in
1114 # If curses is ncurses, some packagers still mess it up by trying to make
1115 # us use GNU termcap. This handles the most common case.
1116 for cf_header in ncurses/term.h ncursesw/term.h
1119 #include <${cf_cv_ncurses_header:-curses.h}>
1120 #ifdef NCURSES_VERSION
1121 #include <${cf_header}>
1125 [WINDOW *x; (void)x],
1126 [cf_cv_term_header=$cf_header
1128 [cf_cv_term_header=no])
1134 case "$cf_cv_term_header" in
1136 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
1139 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
1142 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_CURSES_UNCTRL_H version: 8 updated: 2021/01/02 09:31:20
1148 dnl ------------------
1149 dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
1150 dnl may put it in a subdirectory (along with ncurses' other headers, of
1151 dnl course). Packages which put the headers in inconsistent locations are
1153 AC_DEFUN([CF_CURSES_UNCTRL_H],
1155 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1157 AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
1159 # If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
1160 # for <unctrl.h> if we do not find the variant.
1162 cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
1164 case "${cf_cv_ncurses_header:-curses.h}" in
1166 cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
1167 cf_header_list="$cf_header_item $cf_header_list"
1171 for cf_header in $cf_header_list
1174 #include <${cf_cv_ncurses_header:-curses.h}>
1175 #include <${cf_header}>],
1176 [WINDOW *x; (void)x],
1177 [cf_cv_unctrl_header=$cf_header
1179 [cf_cv_unctrl_header=no])
1183 case "$cf_cv_unctrl_header" in
1185 AC_MSG_WARN(unctrl.h header not found)
1189 case "$cf_cv_unctrl_header" in
1191 AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
1194 AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
1197 AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
1201 dnl ---------------------------------------------------------------------------
1202 dnl CF_CURSES_WACS_MAP version: 8 updated: 2021/01/04 19:45:09
1203 dnl ------------------
1204 dnl Check for likely values of wacs_map[].
1205 AC_DEFUN([CF_CURSES_WACS_MAP],
1207 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
1208 cf_cv_curses_wacs_map=unknown
1209 for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
1212 #ifndef _XOPEN_SOURCE_EXTENDED
1213 #define _XOPEN_SOURCE_EXTENDED
1215 #include <${cf_cv_ncurses_header:-curses.h}>],
1216 [void *foo = &(${name}['k']); (void)foo],
1217 [cf_cv_curses_wacs_map=$name
1221 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])
1223 dnl ---------------------------------------------------------------------------
1224 dnl CF_CURSES_WACS_SYMBOLS version: 4 updated: 2021/01/04 19:45:09
1225 dnl ----------------------
1226 dnl Do a check to see if the WACS_xxx constants are defined compatibly with
1227 dnl X/Open Curses. In particular, NetBSD's implementation of the WACS_xxx
1228 dnl constants is broken since those constants do not point to cchar_t's.
1229 AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
1231 AC_REQUIRE([CF_CURSES_WACS_MAP])
1233 AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
1234 cf_cv_curses_wacs_symbols=no
1235 if test "$cf_cv_curses_wacs_map" != unknown
1238 #ifndef _XOPEN_SOURCE_EXTENDED
1239 #define _XOPEN_SOURCE_EXTENDED
1241 #include <${cf_cv_ncurses_header:-curses.h}>],
1242 [cchar_t *foo = WACS_PLUS;
1243 ${cf_cv_curses_wacs_map}['k'] = *WACS_PLUS; (void)foo],
1244 [cf_cv_curses_wacs_symbols=yes])
1247 #ifndef _XOPEN_SOURCE_EXTENDED
1248 #define _XOPEN_SOURCE_EXTENDED
1250 #include <${cf_cv_ncurses_header:-curses.h}>],
1251 [cchar_t *foo = WACS_PLUS; (void)foo],
1252 [cf_cv_curses_wacs_symbols=yes])
1256 test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
1258 dnl ---------------------------------------------------------------------------
1259 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1261 dnl "dirname" is not portable, so we fake it with a shell script.
1262 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1263 dnl ---------------------------------------------------------------------------
1264 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1266 dnl You can always use "make -n" to see the actual options, but it's hard to
1267 dnl pick out/analyze warning messages when the compile-line is long.
1270 dnl ECHO_LT - symbol to control if libtool is verbose
1271 dnl ECHO_LD - symbol to prefix "cc -o" lines
1272 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1273 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1274 dnl ECHO_CC - symbol to put before any "cc" line
1276 AC_DEFUN([CF_DISABLE_ECHO],[
1277 AC_MSG_CHECKING(if you want to see long compiling messages)
1278 CF_ARG_DISABLE(echo,
1279 [ --disable-echo do not display "compiling" commands],
1282 ECHO_LD='@echo linking [$]@;'
1283 RULE_CC='@echo compiling [$]<'
1284 SHOW_CC='@echo compiling [$]@'
1293 AC_MSG_RESULT($enableval)
1300 dnl ---------------------------------------------------------------------------
1301 dnl CF_DISABLE_LEAKS version: 8 updated: 2021/01/05 20:05:09
1302 dnl ----------------
1303 dnl Combine no-leak checks with the libraries or tools that are used for the
1305 AC_DEFUN([CF_DISABLE_LEAKS],[
1307 AC_REQUIRE([CF_WITH_DMALLOC])
1308 AC_REQUIRE([CF_WITH_DBMALLOC])
1309 AC_REQUIRE([CF_WITH_VALGRIND])
1311 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1312 AC_ARG_ENABLE(leaks,
1313 [ --disable-leaks test: free permanent memory, analyze leaks],
1316 dnl TODO - drop with_no_leaks
1317 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
1318 AC_MSG_RESULT($with_no_leaks)
1320 if test "$enable_leaks" = no ; then
1321 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1322 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1325 dnl ---------------------------------------------------------------------------
1326 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
1327 dnl ---------------------
1328 dnl The rpath-hack makes it simpler to build programs, particularly with the
1329 dnl *BSD ports which may have essential libraries in unusual places. But it
1330 dnl can interfere with building an executable for the base system. Use this
1331 dnl option in that case.
1332 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1334 AC_MSG_CHECKING(if rpath-hack should be disabled)
1335 CF_ARG_DISABLE(rpath-hack,
1336 [ --disable-rpath-hack don't add rpath options for additional libraries],
1337 [enable_rpath_hack=no],
1338 [enable_rpath_hack=yes])
1339 dnl TODO - drop cf_disable_rpath_hack
1340 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
1341 AC_MSG_RESULT($cf_disable_rpath_hack)
1343 if test "$enable_rpath_hack" = yes ; then
1347 dnl ---------------------------------------------------------------------------
1348 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
1349 dnl ----------------------
1350 dnl On a few platforms, the compiler and/or loader nags with untruthful
1351 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1352 dnl and implying that most uses of the recommended alternatives are correct.
1354 dnl Factually speaking, no one has actually counted the number of uses of these
1355 dnl functions versus the total of incorrect uses. Samples of a few thousand
1356 dnl instances are meaningless compared to the hundreds of millions of lines of
1357 dnl existing C code.
1359 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1360 dnl platforms, in implementations of varying quality. Likewise, snprintf is
1361 dnl standard - but evolved through phases, and older implementations are likely
1362 dnl to yield surprising results, as documented in manpages on various systems.
1363 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1365 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1366 AC_ARG_ENABLE(string-hacks,
1367 [ --enable-string-hacks work around bogus compiler/loader warnings],
1368 [enable_string_hacks=$enableval],
1369 [enable_string_hacks=no])
1370 AC_MSG_RESULT($enable_string_hacks)
1372 if test "x$enable_string_hacks" = "xyes"; then
1373 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1374 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1375 AC_CHECK_FUNC(strlcat,[
1376 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1378 AC_CHECK_LIB(bsd,strlcat,[
1380 AC_CHECK_HEADERS(bsd/string.h)
1381 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1384 AC_CHECK_FUNCS( strlcpy snprintf )
1387 dnl ---------------------------------------------------------------------------
1388 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1389 dnl ------------------
1390 dnl Configure-option to enable gcc warnings
1392 dnl $1 = extra options to add, if supported
1393 dnl $2 = option for checking attributes. By default, this is done when
1394 dnl warnings are enabled. For other values:
1395 dnl yes: always do this, e.g., to use in generated library-headers
1396 dnl no: never do this
1397 AC_DEFUN([CF_ENABLE_WARNINGS],[
1398 if test "$GCC" = yes || test "$GXX" = yes
1400 CF_FIX_WARNINGS(CFLAGS)
1401 CF_FIX_WARNINGS(CPPFLAGS)
1402 CF_FIX_WARNINGS(LDFLAGS)
1403 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1404 CF_ARG_ENABLE(warnings,
1405 [ --enable-warnings test: turn on gcc compiler warnings],
1406 [enable_warnings=yes],
1407 [enable_warnings=no])
1408 AC_MSG_RESULT($enable_warnings)
1409 if test "$enable_warnings" = "yes"
1411 ifelse($2,,[CF_GCC_ATTRIBUTES])
1414 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1417 dnl ---------------------------------------------------------------------------
1418 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1420 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1421 dnl prefer a standard location, and use -L options only if we do not find the
1422 dnl library in the standard library location(s).
1423 dnl $1 = library name
1424 dnl $2 = library class, usually the same as library name
1426 dnl $4 = code fragment to compile/link
1427 dnl $5 = corresponding function-name
1428 dnl $6 = flag, nonnull if failure should not cause an error-exit
1430 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1431 dnl to use a -L option.
1432 AC_DEFUN([CF_FIND_LIBRARY],
1434 eval 'cf_cv_have_lib_'"$1"'=no'
1437 eval 'cf_cv_have_lib_'"$1"'=yes',[
1438 cf_save_LIBS="$LIBS"
1439 AC_MSG_CHECKING(for $5 in -l$1)
1441 AC_TRY_LINK([$3],[$4],
1443 eval 'cf_cv_have_lib_'"$1"'=yes'
1446 CF_LIBRARY_PATH(cf_search,$2)
1447 for cf_libdir in $cf_search
1449 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1450 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1451 AC_TRY_LINK([$3],[$4],
1453 eval 'cf_cv_have_lib_'"$1"'=yes'
1456 LIBS="$cf_save_LIBS"])
1460 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1462 if test "$cf_found_library" = no ; then
1463 AC_MSG_ERROR(Cannot link $1 library)
1467 dnl ---------------------------------------------------------------------------
1468 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1470 dnl Find a library (specifically the linkage used in the code fragment),
1471 dnl searching for it if it is not already in the library path.
1472 dnl See also CF_ADD_SEARCHPATH.
1474 dnl Parameters (4-on are optional):
1475 dnl $1 = headers for library entrypoint
1476 dnl $2 = code fragment for library entrypoint
1477 dnl $3 = the library name without the "-l" option or ".so" suffix.
1478 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1479 dnl $5 = action to perform if not successful
1480 dnl $6 = module name, if not the same as the library name
1481 dnl $7 = extra libraries
1483 dnl Sets these variables:
1484 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1485 dnl $cf_cv_header_path_$3 - include-directory if needed
1486 dnl $cf_cv_library_path_$3 - library-directory if needed
1487 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1488 AC_DEFUN([CF_FIND_LINKAGE],[
1490 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1491 # will be set on completion of the AC_TRY_LINK below.
1492 cf_cv_header_path_$3=
1493 cf_cv_library_path_$3=
1495 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1497 cf_save_LIBS="$LIBS"
1499 AC_TRY_LINK([$1],[$2],[
1500 cf_cv_find_linkage_$3=yes
1501 cf_cv_header_path_$3=/usr/include
1502 cf_cv_library_path_$3=/usr/lib
1505 LIBS="-l$3 $7 $cf_save_LIBS"
1507 AC_TRY_LINK([$1],[$2],[
1508 cf_cv_find_linkage_$3=yes
1509 cf_cv_header_path_$3=/usr/include
1510 cf_cv_library_path_$3=/usr/lib
1511 cf_cv_library_file_$3="-l$3"
1513 cf_cv_find_linkage_$3=no
1514 LIBS="$cf_save_LIBS"
1516 CF_VERBOSE(find linkage for $3 library)
1517 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1519 cf_save_CPPFLAGS="$CPPFLAGS"
1520 cf_test_CPPFLAGS="$CPPFLAGS"
1522 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1523 for cf_cv_header_path_$3 in $cf_search
1525 if test -d "$cf_cv_header_path_$3" ; then
1526 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1527 CPPFLAGS="$cf_save_CPPFLAGS"
1528 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1529 AC_TRY_COMPILE([$1],[$2],[
1530 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1531 cf_cv_find_linkage_$3=maybe
1532 cf_test_CPPFLAGS="$CPPFLAGS"
1534 CPPFLAGS="$cf_save_CPPFLAGS"
1539 if test "$cf_cv_find_linkage_$3" = maybe ; then
1541 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1543 cf_save_LIBS="$LIBS"
1544 cf_save_LDFLAGS="$LDFLAGS"
1547 CPPFLAGS="$cf_test_CPPFLAGS"
1548 LIBS="-l$3 $7 $cf_save_LIBS"
1549 AC_TRY_LINK([$1],[$2],[
1550 CF_VERBOSE(... found $3 library in system)
1551 cf_cv_find_linkage_$3=yes])
1552 CPPFLAGS="$cf_save_CPPFLAGS"
1553 LIBS="$cf_save_LIBS"
1556 if test "$cf_cv_find_linkage_$3" != yes ; then
1557 CF_LIBRARY_PATH(cf_search,$3)
1558 for cf_cv_library_path_$3 in $cf_search
1560 if test -d "$cf_cv_library_path_$3" ; then
1561 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1562 CPPFLAGS="$cf_test_CPPFLAGS"
1563 LIBS="-l$3 $7 $cf_save_LIBS"
1564 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1565 AC_TRY_LINK([$1],[$2],[
1566 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1567 cf_cv_find_linkage_$3=yes
1568 cf_cv_library_file_$3="-l$3"
1570 CPPFLAGS="$cf_save_CPPFLAGS"
1571 LIBS="$cf_save_LIBS"
1572 LDFLAGS="$cf_save_LDFLAGS"
1576 CPPFLAGS="$cf_save_CPPFLAGS"
1577 LDFLAGS="$cf_save_LDFLAGS"
1581 cf_cv_find_linkage_$3=no
1586 LIBS="$cf_save_LIBS"
1588 if test "$cf_cv_find_linkage_$3" = yes ; then
1590 CF_ADD_INCDIR($cf_cv_header_path_$3)
1591 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1595 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1598 dnl ---------------------------------------------------------------------------
1599 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1601 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1602 dnl "-Werror" flags can interfere with configure-checks. Those go into
1605 dnl $1 = variable name to repair
1606 define([CF_FIX_WARNINGS],[
1607 if test "$GCC" = yes || test "$GXX" = yes
1611 CF_VERBOSE(repairing $1: [$]$1)
1613 for cf_temp_scan in [$]$1
1615 case "x$cf_temp_scan" in
1617 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1620 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1625 CF_VERBOSE(... fixed [$]$1)
1626 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1630 AC_SUBST(EXTRA_CFLAGS)
1632 dnl ---------------------------------------------------------------------------
1633 dnl CF_FUNC_CURSES_VERSION version: 8 updated: 2021/01/02 09:31:20
1634 dnl ----------------------
1635 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1636 dnl It's a character string "SVR4", not documented.
1637 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1639 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1641 #include <${cf_cv_ncurses_header:-curses.h}>
1645 sprintf(temp, "%s\\n", curses_version());
1646 ${cf_cv_main_return:-return}(0);
1648 ,[cf_cv_func_curses_version=yes]
1649 ,[cf_cv_func_curses_version=no]
1650 ,[cf_cv_func_curses_version=unknown])
1652 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1654 dnl ---------------------------------------------------------------------------
1655 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
1657 dnl Check for openpty() function, along with <pty.h> header. It may need the
1658 dnl "util" library as well.
1659 AC_DEFUN([CF_FUNC_OPENPTY],
1661 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1662 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1663 cf_save_LIBS="$LIBS"
1664 test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
1665 for cf_header in pty.h libutil.h util.h
1668 #include <$cf_header>
1670 int x = openpty((int *)0, (int *)0, (char *)0,
1671 (struct termios *)0, (struct winsize *)0);
1673 cf_cv_func_openpty=$cf_header
1676 cf_cv_func_openpty=no
1679 LIBS="$cf_save_LIBS"
1682 dnl ---------------------------------------------------------------------------
1683 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1684 dnl -----------------
1685 dnl Test for availability of useful gcc __attribute__ directives to quiet
1686 dnl compiler warnings. Though useful, not all are supported -- and contrary
1687 dnl to documentation, unrecognized directives cause older compilers to barf.
1688 AC_DEFUN([CF_GCC_ATTRIBUTES],
1689 [AC_REQUIRE([AC_PROG_FGREP])dnl
1690 AC_REQUIRE([CF_C11_NORETURN])dnl
1692 if test "$GCC" = yes || test "$GXX" = yes
1694 cat > conftest.i <<EOF
1696 #define GCC_PRINTF 0
1701 #ifndef GCC_NORETURN
1702 #define GCC_NORETURN /* nothing */
1705 #define GCC_UNUSED /* nothing */
1708 if test "$GCC" = yes
1710 AC_CHECKING([for $CC __attribute__ directives])
1711 cat > "conftest.$ac_ext" <<EOF
1712 #line __oline__ "${as_me:-configure}"
1713 #include "confdefs.h"
1714 #include "conftest.h"
1715 #include "conftest.i"
1717 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1719 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1722 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1724 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1726 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1727 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1728 extern GCC_NORETURN void foo(void);
1729 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1731 cf_printf_attribute=no
1732 cf_scanf_attribute=no
1733 for cf_attribute in scanf printf unused noreturn
1735 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1736 cf_directive="__attribute__(($cf_attribute))"
1737 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1739 case "$cf_attribute" in
1741 cf_printf_attribute=yes
1742 cat >conftest.h <<EOF
1743 #define GCC_$cf_ATTRIBUTE 1
1747 cf_scanf_attribute=yes
1748 cat >conftest.h <<EOF
1749 #define GCC_$cf_ATTRIBUTE 1
1753 cat >conftest.h <<EOF
1754 #define GCC_$cf_ATTRIBUTE $cf_directive
1759 if AC_TRY_EVAL(ac_compile); then
1760 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1761 cat conftest.h >>confdefs.h
1762 case "$cf_attribute" in
1764 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1767 cf_value='/* nothing */'
1768 if test "$cf_printf_attribute" != no ; then
1769 cf_value='__attribute__((format(printf,fmt,var)))'
1770 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1772 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1775 cf_value='/* nothing */'
1776 if test "$cf_scanf_attribute" != no ; then
1777 cf_value='__attribute__((format(scanf,fmt,var)))'
1778 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1780 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1783 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1789 ${FGREP-fgrep} define conftest.i >>confdefs.h
1794 dnl ---------------------------------------------------------------------------
1795 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1797 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1798 dnl compatible), attempt to determine if icc/clang is actually used.
1799 AC_DEFUN([CF_GCC_VERSION],[
1800 AC_REQUIRE([AC_PROG_CC])
1802 if test "$GCC" = yes ; then
1803 AC_MSG_CHECKING(version of $CC)
1804 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.]].*//'`"
1805 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1806 AC_MSG_RESULT($GCC_VERSION)
1808 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1809 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1811 dnl ---------------------------------------------------------------------------
1812 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1814 dnl Check if the compiler supports useful warning options. There's a few that
1815 dnl we don't use, simply because they're too noisy:
1817 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1818 dnl -Winline (usually not worthwhile)
1819 dnl -Wredundant-decls (system headers make this too noisy)
1820 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1821 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1822 dnl is enabled for ncurses using "--enable-const".
1826 dnl $1 is an optional list of gcc warning flags that a particular
1827 dnl application might want to use, e.g., "no-unused" for
1830 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1832 AC_DEFUN([CF_GCC_WARNINGS],
1834 AC_REQUIRE([CF_GCC_VERSION])
1835 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1836 cat > "conftest.$ac_ext" <<EOF
1837 #line __oline__ "${as_me:-configure}"
1838 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1840 if test "$INTEL_COMPILER" = yes
1842 # The "-wdXXX" options suppress warnings:
1843 # remark #1419: external declaration in primary source file
1844 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1845 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1846 # remark #193: zero used for undefined preprocessing identifier
1847 # remark #593: variable "curs_sb_left_arrow" was set but never used
1848 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1849 # remark #869: parameter "tw" was never referenced
1850 # remark #981: operands are evaluated in unspecified order
1851 # warning #279: controlling expression is constant
1853 AC_CHECKING([for $CC warning options])
1854 cf_save_CFLAGS="$CFLAGS"
1855 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1867 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1868 if AC_TRY_EVAL(ac_compile); then
1869 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1870 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1873 CFLAGS="$cf_save_CFLAGS"
1874 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1876 AC_CHECKING([for $CC warning options])
1877 cf_save_CFLAGS="$CFLAGS"
1879 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1880 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1881 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1882 for cf_opt in W Wall \
1883 Wbad-function-cast \
1886 Wdeclaration-after-statement \
1889 Wmissing-declarations \
1890 Wmissing-prototypes \
1894 Wstrict-prototypes \
1895 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1897 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1898 if AC_TRY_EVAL(ac_compile); then
1899 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1902 case "$GCC_VERSION" in
1904 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1909 case "$GCC_VERSION" in
1911 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1916 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1919 CFLAGS="$cf_save_CFLAGS"
1923 AC_SUBST(EXTRA_CFLAGS)
1925 dnl ---------------------------------------------------------------------------
1926 dnl CF_GETOPT_HEADER version: 7 updated: 2021/01/01 13:31:04
1927 dnl ----------------
1928 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1929 dnl unistd.h or (nonstandard) in getopt.h
1930 AC_DEFUN([CF_GETOPT_HEADER],
1932 AC_HAVE_HEADERS(unistd.h getopt.h)
1933 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1934 cf_cv_getopt_header=none
1935 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1938 #include <$cf_header>],
1939 [int x = optind; char *y = optarg],
1940 [cf_cv_getopt_header=$cf_header
1944 if test "$cf_cv_getopt_header" != none ; then
1945 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1947 if test "$cf_cv_getopt_header" = getopt.h ; then
1948 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1954 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1955 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1956 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1957 dnl since it is interwoven with GNU extensions.
1959 dnl Well, yes we could work around it...
1962 dnl $1 is the nominal value for _XOPEN_SOURCE
1963 AC_DEFUN([CF_GNU_SOURCE],
1965 cf_gnu_xopen_source=ifelse($1,,500,$1)
1967 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1968 AC_TRY_COMPILE([#include <sys/types.h>],[
1969 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1971 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1974 # error not GNU C library
1976 [cf_cv_gnu_library=yes],
1977 [cf_cv_gnu_library=no])
1980 if test x$cf_cv_gnu_library = xyes; then
1982 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1983 # was changed to help a little. newlib incorporated the change about 4
1985 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1987 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1988 AC_TRY_COMPILE([#include <sys/types.h>],[
1989 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1991 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1994 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1996 [cf_cv_gnu_library_219=yes],
1997 [cf_cv_gnu_library_219=no])
2001 if test "x$cf_cv_gnu_library_219" = xyes; then
2003 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
2004 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
2007 #include <sys/types.h>
2009 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
2012 # error GNU C library is too old
2014 [cf_cv_gnu_dftsrc_219=yes],
2015 [cf_cv_gnu_dftsrc_219=no])
2017 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
2019 cf_cv_gnu_dftsrc_219=maybe
2022 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
2024 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2025 AC_TRY_COMPILE([#include <sys/types.h>],[
2026 #ifndef _XOPEN_SOURCE
2027 #error expected _XOPEN_SOURCE to be defined
2029 [cf_cv_gnu_source=no],
2030 [cf_save="$CPPFLAGS"
2031 CF_ADD_CFLAGS(-D_GNU_SOURCE)
2032 AC_TRY_COMPILE([#include <sys/types.h>],[
2033 #ifdef _XOPEN_SOURCE
2034 #error expected _XOPEN_SOURCE to be undefined
2036 [cf_cv_gnu_source=no],
2037 [cf_cv_gnu_source=yes])
2042 if test "$cf_cv_gnu_source" = yes
2044 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2045 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2046 AC_TRY_COMPILE([#include <sys/types.h>],[
2047 #ifdef _DEFAULT_SOURCE
2048 #error expected _DEFAULT_SOURCE to be undefined
2050 [cf_cv_default_source=no],
2051 [cf_cv_default_source=yes])
2053 if test "$cf_cv_default_source" = yes
2055 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2062 dnl ---------------------------------------------------------------------------
2063 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2065 dnl Construct a search-list of directories for a nonstandard header-file
2068 dnl $1 = the variable to return as result
2069 dnl $2 = the package name
2070 AC_DEFUN([CF_HEADER_PATH],
2074 # collect the current set of include-directories from compiler flags
2075 cf_header_path_list=""
2076 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2077 for cf_header_path in $CPPFLAGS $CFLAGS
2079 case "$cf_header_path" in
2081 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2082 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2083 cf_header_path_list="$cf_header_path_list [$]$1"
2089 # add the variations for the package we are looking for
2090 CF_SUBDIR_PATH($1,$2,include)
2092 test "$includedir" != NONE && \
2093 test "$includedir" != "/usr/include" && \
2094 test -d "$includedir" && {
2095 test -d "$includedir" && $1="[$]$1 $includedir"
2096 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2099 test "$oldincludedir" != NONE && \
2100 test "$oldincludedir" != "/usr/include" && \
2101 test -d "$oldincludedir" && {
2102 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
2103 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2106 $1="[$]$1 $cf_header_path_list"
2108 dnl ---------------------------------------------------------------------------
2109 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2111 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2112 AC_DEFUN([CF_HELP_MESSAGE],
2113 [CF_ACVERSION_CHECK(2.53,[],[
2114 AC_DIVERT_HELP($1)])dnl
2116 dnl ---------------------------------------------------------------------------
2117 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2118 dnl -----------------
2119 dnl If we do not have a given script, look for it in the parent directory.
2120 AC_DEFUN([CF_INHERIT_SCRIPT],
2122 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2124 dnl ---------------------------------------------------------------------------
2125 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2127 dnl prompt for/fill-in useful install-program options
2128 AC_DEFUN([CF_INSTALL_OPTS],
2134 dnl ---------------------------------------------------------------------------
2135 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2136 dnl ----------------
2137 dnl Almost all "install" programs default to the current user's ownership.
2138 dnl Almost - MINIX is an exception.
2139 AC_DEFUN([CF_INSTALL_OPT_O],
2141 AC_MSG_CHECKING(if install needs to be told about ownership)
2142 case `$ac_config_guess` in
2151 AC_MSG_RESULT($with_install_o)
2152 if test "x$with_install_o" = xyes
2154 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'`"
2159 AC_SUBST(INSTALL_OPT_O)
2161 dnl ---------------------------------------------------------------------------
2162 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2163 dnl ----------------
2164 dnl Some install-programs accept a "-p" option to preserve file modification
2165 dnl timestamps. That can be useful as an install option, as well as a way to
2166 dnl avoid the need for ranlib after copying a static archive.
2167 AC_DEFUN([CF_INSTALL_OPT_P],
2169 : "${INSTALL:=install}"
2170 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2175 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2177 if test -f conftest.out/conftest.in
2179 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2180 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2181 if test -s conftest.err
2196 dnl ---------------------------------------------------------------------------
2197 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2198 dnl ----------------
2199 dnl By default, we should strip executables which are installed, but leave the
2200 dnl ability to suppress that for unit-testing.
2201 AC_DEFUN([CF_INSTALL_OPT_S],
2203 AC_MSG_CHECKING(if you want to install stripped executables)
2204 CF_ARG_DISABLE(stripping,
2205 [ --disable-stripping do not strip (debug info) installed executables],
2206 [enable_stripping=no],
2207 [enable_stripping=yes])
2208 AC_MSG_RESULT($enable_stripping)
2210 if test "$enable_stripping" = yes
2216 AC_SUBST(INSTALL_OPT_S)
2218 dnl ---------------------------------------------------------------------------
2219 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2220 dnl -----------------
2221 dnl Check if the given compiler is really the Intel compiler for Linux. It
2222 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2223 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2225 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2226 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2227 dnl the wrappers for gcc and g++ warnings.
2229 dnl $1 = GCC (default) or GXX
2230 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2231 dnl $3 = CFLAGS (default) or CXXFLAGS
2232 AC_DEFUN([CF_INTEL_COMPILER],[
2233 AC_REQUIRE([AC_CANONICAL_HOST])
2234 ifelse([$2],,INTEL_COMPILER,[$2])=no
2236 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2239 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2240 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2241 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2243 #ifdef __INTEL_COMPILER
2247 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2248 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2250 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2251 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2256 dnl ---------------------------------------------------------------------------
2257 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2259 dnl For the given system and compiler, find the compiler flags to pass to the
2260 dnl loader to use the "rpath" feature.
2261 AC_DEFUN([CF_LD_RPATH_OPT],
2263 AC_REQUIRE([CF_CHECK_CACHE])
2266 if test "x$cf_cv_enable_rpath" != xno
2268 AC_MSG_CHECKING(for an rpath option)
2269 case "$cf_cv_system_name" in
2271 if test "$GCC" = yes; then
2272 LD_RPATH_OPT="-Wl,-rpath,"
2274 LD_RPATH_OPT="-rpath "
2277 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2278 LD_RPATH_OPT="-Wl,-rpath,"
2280 (openbsd[[2-9]].*|mirbsd*)
2281 LD_RPATH_OPT="-Wl,-rpath,"
2284 LD_RPATH_OPT="-rpath "
2287 LD_RPATH_OPT="-Wl,-rpath,"
2290 LD_RPATH_OPT="-rpath "
2298 AC_MSG_RESULT($LD_RPATH_OPT)
2300 case "x$LD_RPATH_OPT" in
2302 AC_MSG_CHECKING(if we need a space after rpath option)
2303 cf_save_LIBS="$LIBS"
2304 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2305 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2306 LIBS="$cf_save_LIBS"
2307 AC_MSG_RESULT($cf_rpath_space)
2308 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2313 dnl ---------------------------------------------------------------------------
2314 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2316 dnl Construct a search-list of directories for a nonstandard library-file
2319 dnl $1 = the variable to return as result
2320 dnl $2 = the package name
2321 AC_DEFUN([CF_LIBRARY_PATH],
2324 cf_library_path_list=""
2325 if test -n "${LDFLAGS}${LIBS}" ; then
2326 for cf_library_path in $LDFLAGS $LIBS
2328 case "$cf_library_path" in
2330 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2331 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2332 cf_library_path_list="$cf_library_path_list [$]$1"
2338 CF_SUBDIR_PATH($1,$2,lib)
2340 $1="$cf_library_path_list [$]$1"
2342 dnl ---------------------------------------------------------------------------
2343 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2345 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2346 dnl a monocase filesystem.
2347 AC_DEFUN([CF_MAKE_TAGS],[
2348 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2350 AC_CHECK_PROGS(CTAGS, exctags ctags)
2351 AC_CHECK_PROGS(ETAGS, exetags etags)
2353 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2355 if test "$cf_cv_mixedcase" = yes ; then
2356 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2361 if test "$MAKE_UPPER_TAGS" = yes ; then
2367 if test "$MAKE_LOWER_TAGS" = yes ; then
2376 AC_SUBST(MAKE_UPPER_TAGS)
2377 AC_SUBST(MAKE_LOWER_TAGS)
2379 dnl ---------------------------------------------------------------------------
2380 dnl CF_MATH_LIB version: 10 updated: 2020/12/31 18:40:20
2382 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
2383 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
2384 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2385 AC_DEFUN([CF_MATH_LIB],
2387 AC_CACHE_CHECK(if -lm needed for math functions,
2394 [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
2395 [cf_cv_need_libm=no],
2396 [cf_cv_need_libm=yes])])
2397 if test "$cf_cv_need_libm" = yes
2404 dnl ---------------------------------------------------------------------------
2405 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2406 dnl ----------------------
2407 dnl Check if the file-system supports mixed-case filenames. If we're able to
2408 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2409 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2411 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2412 if test "$cross_compiling" = yes ; then
2413 case "$target_alias" in
2414 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2422 rm -f conftest CONFTEST
2424 if test -f CONFTEST ; then
2429 rm -f conftest CONFTEST
2432 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2434 dnl ---------------------------------------------------------------------------
2435 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2437 dnl Write a debug message to config.log, along with the line number in the
2438 dnl configure script.
2439 AC_DEFUN([CF_MSG_LOG],[
2440 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2442 dnl ---------------------------------------------------------------------------
2443 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2444 dnl -------------------
2445 dnl Check if we can compile with ncurses' header file
2446 dnl $1 is the cache variable to set
2447 dnl $2 is the header-file to include
2448 dnl $3 is the root name (ncurses or ncursesw)
2449 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2451 ]ifelse($3,ncursesw,[
2452 #define _XOPEN_SOURCE_EXTENDED
2453 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2454 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2457 #ifdef NCURSES_VERSION
2458 ]ifelse($3,ncursesw,[
2463 printf("%s\\n", NCURSES_VERSION);
2475 dnl ---------------------------------------------------------------------------
2476 dnl CF_NCURSES_CONFIG version: 26 updated: 2021/01/03 08:05:37
2477 dnl -----------------
2478 dnl Tie together the configure-script macros for ncurses, preferring these in
2480 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2481 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2482 dnl c) just plain libraries
2484 dnl $1 is the root library name (default: "ncurses")
2485 AC_DEFUN([CF_NCURSES_CONFIG],[
2486 AC_REQUIRE([CF_PKG_CONFIG])
2487 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2488 cf_have_ncuconfig=no
2490 if test "x${PKG_CONFIG:=none}" != xnone; then
2491 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2492 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2495 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2496 cf_have_ncuconfig=unknown
2498 cf_save_CFLAGS="$CFLAGS"
2499 cf_save_CPPFLAGS="$CPPFLAGS"
2500 cf_save_LIBS="$LIBS"
2502 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2503 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2505 # while -W for passing linker flags is prevalent, it is not "standard".
2506 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2507 # incompatible _and_ non-standard -W option which gives an error. Work
2508 # around that pitfall.
2509 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2511 CF_ADD_CFLAGS($cf_pkg_cflags)
2512 CF_ADD_LIBS($cf_pkg_libs)
2514 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2515 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2516 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2518 { char *xx = curses_version(); return (xx == 0); }],
2519 [cf_test_ncuconfig=yes],
2520 [cf_test_ncuconfig=no],
2521 [cf_test_ncuconfig=maybe])],
2522 [cf_test_ncuconfig=no])
2524 CFLAGS="$cf_save_CFLAGS"
2525 CPPFLAGS="$cf_save_CPPFLAGS"
2526 LIBS="$cf_save_LIBS"
2528 if test "x$cf_test_ncuconfig" != xyes; then
2529 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2530 cf_pkg_cflags="$cf_temp"
2531 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2532 cf_pkg_libs="$cf_temp"
2537 CF_ADD_CFLAGS($cf_pkg_cflags)
2538 CF_ADD_LIBS($cf_pkg_libs)
2540 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2541 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2542 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2544 { char *xx = curses_version(); return (xx == 0); }],
2545 [cf_have_ncuconfig=yes],
2546 [cf_have_ncuconfig=no],
2547 [cf_have_ncuconfig=maybe])],
2548 [cf_have_ncuconfig=no])
2549 AC_MSG_RESULT($cf_have_ncuconfig)
2550 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2551 if test "$cf_have_ncuconfig" != "yes"
2553 CPPFLAGS="$cf_save_CPPFLAGS"
2554 LIBS="$cf_save_LIBS"
2555 NCURSES_CONFIG_PKG=none
2557 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2558 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2564 NCURSES_CONFIG_PKG=none
2567 NCURSES_CONFIG_PKG=none
2570 if test "x$cf_have_ncuconfig" = "xno"; then
2571 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2573 CF_ACVERSION_CHECK(2.52,
2574 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2575 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2577 if test "$NCURSES_CONFIG" != none ; then
2579 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2580 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2582 # even with config script, some packages use no-override for curses.h
2583 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2585 dnl like CF_NCURSES_CPPFLAGS
2586 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2588 dnl like CF_NCURSES_LIBS
2589 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2590 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2592 dnl like CF_NCURSES_VERSION
2593 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
2597 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2598 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2605 dnl ---------------------------------------------------------------------------
2606 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
2607 dnl -------------------
2608 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2609 dnl the CPPFLAGS variable so we can include its header.
2611 dnl The header files may be installed as either curses.h, or ncurses.h (would
2612 dnl be obsolete, except that some packagers prefer this name to distinguish it
2613 dnl from a "native" curses implementation). If not installed for overwrite,
2614 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2615 dnl /usr/include/ncurses), but someone may have installed overwriting the
2616 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2617 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2620 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2621 dnl is already in the include-path, don't even bother with this, since we cannot
2622 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2624 dnl The optional parameter gives the root name of the library, in case it is
2625 dnl not installed as the default curses library. That is how the
2626 dnl wide-character version of ncurses is installed.
2627 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2628 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2630 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2631 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2633 test -n "$cf_cv_curses_dir" && \
2634 test "$cf_cv_curses_dir" != "no" && { \
2635 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2638 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2639 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2640 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
2641 for cf_header in $cf_header_list
2643 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2644 test "$cf_cv_ncurses_h" != no && break
2651 # some applications need this, but should check for NCURSES_VERSION
2652 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2656 dnl ---------------------------------------------------------------------------
2657 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2658 dnl --------------------
2659 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2660 dnl may provide these functions. Define the symbol if it is not defined, and
2662 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2664 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2666 #include <${cf_cv_ncurses_header:-curses.h}>],
2668 int x = NCURSES_EXT_FUNCS
2669 ],[cf_cv_ncurses_ext_funcs=defined],[
2671 #include <${cf_cv_ncurses_header:-curses.h}>],
2673 (void) assume_default_colors (0, 0);
2674 (void) curses_version ();
2675 (void) define_key (0, 0);
2676 (void) is_term_resized (0, 0);
2677 (void) key_defined (0);
2678 (void) keybound (0, 0);
2679 (void) keyok (0, 0);
2680 (void) resize_term (0, 0);
2681 (void) resizeterm (0, 0);
2682 (void) use_default_colors ();
2683 (void) use_extended_names (0);
2684 (void) wresize (0, 0, 0);],
2685 [cf_cv_ncurses_ext_funcs=yes],
2686 [cf_cv_ncurses_ext_funcs=no])
2689 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2691 dnl ---------------------------------------------------------------------------
2692 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
2693 dnl -----------------
2694 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2695 dnl variations of ncurses' installs.
2697 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2698 AC_DEFUN([CF_NCURSES_HEADER],[
2700 if test "$cf_cv_ncurses_h" != no ; then
2701 cf_cv_ncurses_header=$cf_cv_ncurses_h
2704 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2705 test -n "$verbose" && echo
2706 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2707 test -n "$verbose" && echo "search path $cf_search"
2708 cf_save2_CPPFLAGS="$CPPFLAGS"
2709 for cf_incdir in $cf_search
2711 CF_ADD_INCDIR($cf_incdir)
2716 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2717 if test "$cf_cv_ncurses_h2" != no ; then
2718 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2719 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
2722 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2724 CPPFLAGS="$cf_save2_CPPFLAGS"
2725 test "$cf_cv_ncurses_h2" != no && break
2727 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2730 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2731 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
2732 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
2733 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
2735 CF_ADD_INCDIR($cf_1st_incdir)
2739 # Set definitions to allow ifdef'ing for ncurses.h
2741 case "$cf_cv_ncurses_header" in
2743 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2747 case "$cf_cv_ncurses_header" in
2748 (ncurses/curses.h|ncurses/ncurses.h)
2749 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2751 (ncursesw/curses.h|ncursesw/ncurses.h)
2752 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2757 dnl ---------------------------------------------------------------------------
2758 dnl CF_NCURSES_LIBS version: 20 updated: 2021/01/03 08:05:37
2760 dnl Look for the ncurses library. This is a little complicated on Linux,
2761 dnl because it may be linked with the gpm (general purpose mouse) library.
2762 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2763 dnl unusable with ncurses. However, we don't want to link with gpm unless
2764 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2765 dnl and the linker will record a dependency.
2767 dnl The optional parameter gives the root name of the library, in case it is
2768 dnl not installed as the default curses library. That is how the
2769 dnl wide-character version of ncurses is installed.
2770 AC_DEFUN([CF_NCURSES_LIBS],
2771 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2773 cf_nculib_root=ifelse($1,,ncurses,$1)
2774 # This works, except for the special case where we find gpm, but
2775 # ncurses is in a nonstandard location via $LIBS, and we really want
2778 cf_ncurses_SAVE="$LIBS"
2779 AC_CHECK_LIB(gpm,Gpm_Open,
2780 [AC_CHECK_LIB(gpm,initscr,
2781 [LIBS="$cf_ncurses_SAVE"],
2782 [cf_ncurses_LIBS="-lgpm"])])
2786 # This is only necessary if you are linking against an obsolete
2787 # version of ncurses (but it should do no harm, since it's static).
2788 if test "$cf_nculib_root" = ncurses ; then
2789 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2794 CF_ADD_LIBS($cf_ncurses_LIBS)
2796 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
2798 CF_ADD_LIBS(-l$cf_nculib_root)
2800 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2801 [#include <${cf_cv_ncurses_header:-curses.h}>],
2806 if test -n "$cf_ncurses_LIBS" ; then
2807 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2808 cf_ncurses_SAVE="$LIBS"
2809 for p in $cf_ncurses_LIBS ; do
2810 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
2811 if test "$q" != "$LIBS" ; then
2815 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2816 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2817 [AC_MSG_RESULT(yes)],
2819 LIBS="$cf_ncurses_SAVE"])
2822 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2823 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2825 dnl ---------------------------------------------------------------------------
2826 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2827 dnl -------------------
2828 dnl Use this followup check to ensure that we link with pthreads if ncurses
2830 AC_DEFUN([CF_NCURSES_PTHREADS],[
2831 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2832 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2833 cf_cv_ncurses_pthreads=yes,
2834 cf_cv_ncurses_pthreads=no)
2835 if test "$cf_cv_ncurses_pthreads" = yes
2837 CF_ADD_LIBS(-lpthread)
2840 dnl ---------------------------------------------------------------------------
2841 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
2842 dnl ------------------
2843 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2844 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
2845 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2846 AC_DEFUN([CF_NCURSES_VERSION],
2848 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2849 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2850 cf_cv_ncurses_version=no
2852 rm -f "$cf_tempfile"
2854 #include <${cf_cv_ncurses_header:-curses.h}>
2858 FILE *fp = fopen("$cf_tempfile", "w");
2859 #ifdef NCURSES_VERSION
2860 # ifdef NCURSES_VERSION_PATCH
2861 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2863 fprintf(fp, "%s\\n", NCURSES_VERSION);
2867 fprintf(fp, "old\\n");
2872 ${cf_cv_main_return:-return}(0);
2874 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2876 # This will not work if the preprocessor splits the line after the
2877 # Autoconf token. The 'unproto' program does that.
2878 cat > "conftest.$ac_ext" <<EOF
2879 #include <${cf_cv_ncurses_header:-curses.h}>
2881 #ifdef NCURSES_VERSION
2882 Autoconf NCURSES_VERSION
2890 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2892 if test -f conftest.out ; then
2893 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
2894 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2898 rm -f "$cf_tempfile"
2900 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2902 dnl ---------------------------------------------------------------------------
2903 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2904 dnl ----------------------
2905 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2906 dnl wrapped with a function to help with concurrency control.
2907 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2909 AC_MSG_CHECKING(for ncurses wrap-prefix)
2910 AC_ARG_WITH(ncurses-wrap-prefix,
2911 [ --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2912 [NCURSES_WRAP_PREFIX=$withval],
2913 [NCURSES_WRAP_PREFIX=_nc_])
2914 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2916 AC_SUBST(NCURSES_WRAP_PREFIX)
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2920 dnl ----------------
2921 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2922 dnl Some workarounds are needed in client programs to allow them to compile.
2923 AC_DEFUN([CF_NETBSD_FORM_H],[
2924 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2926 #include <${cf_cv_ncurses_header:-curses.h}>
2930 int y = current_field(form)->cursor_ypos;
2931 int x = current_field(form)->cursor_xpos;
2932 ],[cf_cv_netbsd_form_h=yes
2933 ],[cf_cv_netbsd_form_h=no])
2936 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])
2938 dnl ---------------------------------------------------------------------------
2939 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2940 dnl ----------------
2941 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2942 dnl Some workarounds are needed in client programs to allow them to compile.
2943 AC_DEFUN([CF_NETBSD_MENU_H],[
2944 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2946 #include <${cf_cv_ncurses_header:-curses.h}>
2950 int y = menu->max_item_width;
2951 ],[cf_cv_netbsd_menu_h=yes
2952 ],[cf_cv_netbsd_menu_h=no])
2955 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])
2957 dnl ---------------------------------------------------------------------------
2958 dnl CF_NO_LEAKS_OPTION version: 8 updated: 2021/01/05 20:05:09
2959 dnl ------------------
2960 dnl see CF_WITH_NO_LEAKS
2961 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2962 AC_MSG_CHECKING(if you want to use $1 for testing)
2965 [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2968 : "${with_cflags:=-g}"
2969 : "${enable_leaks:=no}"
2972 AC_MSG_RESULT(${with_$1:-no})
2974 case ".$with_cflags" in
2986 dnl ---------------------------------------------------------------------------
2987 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
2989 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
2990 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2991 dnl result begins with 'NONE'. This is necessary to work around autoconf's
2992 dnl delayed evaluation of those symbols.
2993 AC_DEFUN([CF_PATH_SYNTAX],[
2994 if test "x$prefix" != xNONE; then
2995 cf_path_syntax="$prefix"
2997 cf_path_syntax="$ac_default_prefix"
3001 (.\[$]\(*\)*|.\'*\'*)
3005 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3007 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3011 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3016 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3019 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3023 dnl ---------------------------------------------------------------------------
3024 dnl CF_PDCURSES_X11 version: 15 updated: 2021/01/02 09:31:20
3026 dnl Configure for PDCurses' X11 library
3027 AC_DEFUN([CF_PDCURSES_X11],[
3028 AC_REQUIRE([CF_X_ATHENA])
3030 CF_ACVERSION_CHECK(2.52,
3031 [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
3032 [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
3034 if test "$XCURSES_CONFIG" != none ; then
3036 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
3037 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
3039 cf_cv_lib_XCurses=yes
3043 LDFLAGS="$LDFLAGS $X_LIBS"
3044 CF_CHECK_CFLAGS($X_CFLAGS)
3045 AC_CHECK_LIB(X11,XOpenDisplay,
3046 [CF_ADD_LIBS(-lX11)],,
3047 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
3048 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
3049 CF_ADD_LIBS(-lXCurses)
3051 #include <xcurses.h>
3052 char *XCursesProgramName = "test";
3054 [cf_cv_lib_XCurses=yes],
3055 [cf_cv_lib_XCurses=no])
3060 if test "$cf_cv_lib_XCurses" = yes ; then
3061 AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
3062 AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
3063 AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
3065 AC_MSG_ERROR(Cannot link with XCurses)
3068 dnl ---------------------------------------------------------------------------
3069 dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
3071 dnl Check for the package-config program, unless disabled by command-line.
3072 AC_DEFUN([CF_PKG_CONFIG],
3074 AC_MSG_CHECKING(if you want to use pkg-config)
3075 AC_ARG_WITH(pkg-config,
3076 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3077 [cf_pkg_config=$withval],
3078 [cf_pkg_config=yes])
3079 AC_MSG_RESULT($cf_pkg_config)
3081 case "$cf_pkg_config" in
3086 CF_ACVERSION_CHECK(2.52,
3087 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3088 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3095 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3096 if test "$PKG_CONFIG" != none ; then
3097 CF_PATH_SYNTAX(PKG_CONFIG)
3098 elif test "x$cf_pkg_config" != xno ; then
3099 AC_MSG_WARN(pkg-config is not installed)
3102 AC_SUBST(PKG_CONFIG)
3104 dnl ---------------------------------------------------------------------------
3105 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3106 dnl -----------------
3107 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3109 dnl POSIX.1-1990 _POSIX_SOURCE
3110 dnl POSIX.1-1990 and _POSIX_SOURCE and
3111 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3113 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3114 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3115 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3118 dnl $1 is the nominal value for _POSIX_C_SOURCE
3119 AC_DEFUN([CF_POSIX_C_SOURCE],
3120 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3122 if test "$cf_cv_posix_visible" = no; then
3124 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3126 cf_save_CFLAGS="$CFLAGS"
3127 cf_save_CPPFLAGS="$CPPFLAGS"
3129 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3130 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3132 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3133 CF_MSG_LOG(if the symbol is already defined go no further)
3134 AC_TRY_COMPILE([#include <sys/types.h>],[
3135 #ifndef _POSIX_C_SOURCE
3138 [cf_cv_posix_c_source=no],
3139 [cf_want_posix_source=no
3140 case .$cf_POSIX_C_SOURCE in
3142 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3145 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3146 cf_want_posix_source=yes
3149 cf_want_posix_source=yes
3152 if test "$cf_want_posix_source" = yes ; then
3153 AC_TRY_COMPILE([#include <sys/types.h>],[
3154 #ifdef _POSIX_SOURCE
3157 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3159 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3160 CFLAGS="$cf_trim_CFLAGS"
3161 CPPFLAGS="$cf_trim_CPPFLAGS"
3162 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3163 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3164 AC_TRY_COMPILE([#include <sys/types.h>],[
3165 #ifndef _POSIX_C_SOURCE
3168 [cf_cv_posix_c_source=no])
3169 CFLAGS="$cf_save_CFLAGS"
3170 CPPFLAGS="$cf_save_CPPFLAGS"
3174 if test "$cf_cv_posix_c_source" != no ; then
3175 CFLAGS="$cf_trim_CFLAGS"
3176 CPPFLAGS="$cf_trim_CPPFLAGS"
3177 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3180 fi # cf_cv_posix_visible
3183 dnl ---------------------------------------------------------------------------
3184 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3185 dnl ----------------
3186 dnl POSIX documents test-macros which an application may set before any system
3187 dnl headers are included to make features available.
3189 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3190 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3191 dnl recent features visible in the system header files unless the application
3192 dnl overrides the corresponding test-macros. Doing that introduces portability
3195 dnl This macro makes a special check for the symbols used for this, to avoid a
3196 dnl conflicting definition.
3197 AC_DEFUN([CF_POSIX_VISIBLE],
3199 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3200 AC_TRY_COMPILE([#include <stdio.h>],[
3201 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3202 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3203 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3204 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3205 #error conflicting symbols found
3207 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3210 dnl ---------------------------------------------------------------------------
3211 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
3213 dnl Append definitions and rules for the given programs to the subdirectory
3214 dnl Makefiles, and the recursion rule for the top-level Makefile.
3217 dnl $1 = script to run
3218 dnl $2 = list of subdirectories
3222 AC_DEFUN([CF_PRG_RULES],
3226 if test ! -d "$srcdir/$cf_dir" ; then
3228 elif test -f "$srcdir/$cf_dir/programs" ; then
3229 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
3234 dnl ---------------------------------------------------------------------------
3235 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3237 dnl standard check for CC, plus followup sanity checks
3238 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3239 AC_DEFUN([CF_PROG_CC],[
3240 CF_ACVERSION_CHECK(2.53,
3241 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3242 AC_REQUIRE([AC_PROG_CC])],
3244 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3246 CF_ACVERSION_CHECK(2.52,
3251 dnl ---------------------------------------------------------------------------
3252 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3254 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3255 dnl misc/tabset install won't work properly. Usually this happens only when
3256 dnl using the fallback mkinstalldirs script
3257 AC_DEFUN([CF_PROG_INSTALL],
3263 CF_DIRNAME(cf_dir,$INSTALL)
3264 test -z "$cf_dir" && cf_dir=.
3265 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3269 dnl ---------------------------------------------------------------------------
3270 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3272 AC_DEFUN([CF_PROG_LINT],
3274 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3276 (xcppcheck|x*/cppcheck)
3277 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3282 dnl ---------------------------------------------------------------------------
3283 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3284 dnl ----------------
3285 dnl Remove all -U and -D options that refer to the given symbol from a list
3286 dnl of C compiler options. This works around the problem that not all
3287 dnl compilers process -U and -D options from left-to-right, so a -U option
3288 dnl cannot be used to cancel the effect of a preceding -D option.
3290 dnl $1 = target (which could be the same as the source variable)
3291 dnl $2 = source (including '$')
3292 dnl $3 = symbol to remove
3293 define([CF_REMOVE_DEFINE],
3296 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3297 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3299 dnl ---------------------------------------------------------------------------
3300 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3301 dnl ---------------------
3302 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3303 dnl $1 = name of current macro
3304 define([CF_RESTORE_XTRA_FLAGS],
3306 LIBS="$cf_save_LIBS_$1"
3307 CFLAGS="$cf_save_CFLAGS_$1"
3308 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3310 dnl ---------------------------------------------------------------------------
3311 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
3313 AC_DEFUN([CF_RPATH_HACK],
3314 [AC_REQUIRE([AC_PROG_FGREP])dnl
3315 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
3317 AC_MSG_CHECKING(for updated LDFLAGS)
3318 if test -n "$LD_RPATH_OPT" ; then
3319 AC_MSG_RESULT(maybe)
3321 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3322 cf_rpath_list="/usr/lib /lib"
3323 if test "$cf_ldd_prog" != no
3327 AC_TRY_LINK([#include <stdio.h>],
3329 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3330 cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3332 # If we passed the link-test, but get a "not found" on a given library,
3333 # this could be due to inept reconfiguration of gcc to make it only
3334 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
3335 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3336 # /usr/local libraries.
3337 if test -n "$cf_rpath_oops"
3339 for cf_rpath_src in $cf_rpath_oops
3341 for cf_rpath_dir in \
3346 if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
3348 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3349 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3357 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3359 CF_RPATH_HACK_2(LDFLAGS)
3360 CF_RPATH_HACK_2(LIBS)
3362 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3366 AC_SUBST(EXTRA_LDFLAGS)
3368 dnl ---------------------------------------------------------------------------
3369 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
3371 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3372 dnl EXTRA_LDFLAGS for each -L option found.
3374 dnl $cf_rpath_list contains a list of directories to ignore.
3376 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
3377 dnl but LIBS often has misplaced -L options.
3378 AC_DEFUN([CF_RPATH_HACK_2],
3380 CF_VERBOSE(...checking $1 [$]$1)
3383 for cf_rpath_src in [$]$1
3385 case "$cf_rpath_src" in
3388 # check if this refers to a directory which we will ignore
3390 if test -n "$cf_rpath_list"
3392 for cf_rpath_item in $cf_rpath_list
3394 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3402 if test "$cf_rpath_skip" = no
3404 # transform the option
3405 if test "$LD_RPATH_OPT" = "-R " ; then
3406 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3408 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3411 # if we have not already added this, add it now
3412 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3413 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3415 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3416 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3421 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3425 CF_VERBOSE(...checked $1 [$]$1)
3426 AC_SUBST(EXTRA_LDFLAGS)
3428 dnl ---------------------------------------------------------------------------
3429 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3430 dnl ------------------
3431 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3432 dnl and libraries which do not update those variables.
3434 dnl $1 = name of current macro
3435 define([CF_SAVE_XTRA_FLAGS],
3437 cf_save_LIBS_$1="$LIBS"
3438 cf_save_CFLAGS_$1="$CFLAGS"
3439 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3440 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3441 for cf_X_CFLAGS in $X_CFLAGS
3443 case "x$cf_X_CFLAGS" in
3445 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3448 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3453 dnl ---------------------------------------------------------------------------
3454 dnl CF_SIGWINCH version: 6 updated: 2021/01/01 13:31:04
3456 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3457 dnl programs need this test).
3459 dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
3460 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
3461 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3462 dnl break that part of the interface as well.
3463 AC_DEFUN([CF_SIGWINCH],
3465 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3467 #include <sys/types.h>
3468 #include <sys/signal.h>
3469 ],[int x = SIGWINCH; (void)x],
3470 [cf_cv_define_sigwinch=yes],
3472 #undef _XOPEN_SOURCE
3473 #undef _POSIX_SOURCE
3474 #undef _POSIX_C_SOURCE
3475 #include <sys/types.h>
3476 #include <sys/signal.h>
3477 ],[int x = SIGWINCH; (void)x],
3478 [cf_cv_define_sigwinch=maybe],
3479 [cf_cv_define_sigwinch=no])
3483 if test "$cf_cv_define_sigwinch" = maybe ; then
3484 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3485 cf_cv_fixup_sigwinch=unknown
3487 while test "$cf_sigwinch" != 1
3490 #undef _XOPEN_SOURCE
3491 #undef _POSIX_SOURCE
3492 #undef _POSIX_C_SOURCE
3493 #include <sys/types.h>
3494 #include <sys/signal.h>
3496 #if SIGWINCH != $cf_sigwinch
3499 int x = SIGWINCH; (void)x],
3500 [cf_cv_fixup_sigwinch=$cf_sigwinch
3503 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
3507 if test "$cf_cv_fixup_sigwinch" != unknown ; then
3508 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3512 dnl ---------------------------------------------------------------------------
3513 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3515 dnl signal handler, but there are some gcc dependencies in that recommendation.
3517 AC_DEFUN([CF_SIG_ATOMIC_T],
3519 AC_MSG_CHECKING(for signal global datatype)
3520 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3522 "volatile sig_atomic_t" \
3527 #include <sys/types.h>
3533 static void handler(int sig)
3538 [signal(SIGINT, handler);
3540 [cf_cv_sig_atomic_t=$cf_type],
3541 [cf_cv_sig_atomic_t=no])
3542 test "$cf_cv_sig_atomic_t" != no && break
3545 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3546 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3548 dnl ---------------------------------------------------------------------------
3549 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3551 dnl Construct a search-list for a nonstandard header/lib-file
3552 dnl $1 = the variable to return as result
3553 dnl $2 = the package name
3554 dnl $3 = the subdirectory, e.g., bin, include or lib
3555 AC_DEFUN([CF_SUBDIR_PATH],
3559 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3561 for cf_subdir_prefix in \
3569 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3572 dnl ---------------------------------------------------------------------------
3573 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3574 dnl ------------------
3575 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3576 dnl older SCO configurations.
3577 AC_DEFUN([CF_SYS_TIME_SELECT],
3579 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3580 AC_CACHE_VAL(cf_cv_sys_time_select,[
3582 #include <sys/types.h>
3583 #ifdef HAVE_SYS_TIME_H
3584 #include <sys/time.h>
3586 #ifdef HAVE_SYS_SELECT_H
3587 #include <sys/select.h>
3589 ],[],[cf_cv_sys_time_select=yes],
3590 [cf_cv_sys_time_select=no])
3592 AC_MSG_RESULT($cf_cv_sys_time_select)
3593 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>])
3595 dnl ---------------------------------------------------------------------------
3596 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
3598 dnl Look for term.h, which is part of X/Open curses. It defines the interface
3599 dnl to terminfo database. Usually it is in the same include-path as curses.h,
3600 dnl but some packagers change this, breaking various applications.
3601 AC_DEFUN([CF_TERM_HEADER],[
3602 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3603 case "${cf_cv_ncurses_header}" in
3604 (*/ncurses.h|*/ncursesw.h)
3605 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3608 cf_term_header=term.h
3612 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3614 AC_TRY_COMPILE([#include <stdio.h>
3615 #include <${cf_cv_ncurses_header:-curses.h}>
3617 ],[int x = auto_left_margin; (void)x],[
3618 cf_cv_term_header="$cf_test"],[
3619 cf_cv_term_header=unknown
3621 test "$cf_cv_term_header" != unknown && break
3625 # Set definitions to allow ifdef'ing to accommodate subdirectories
3627 case "$cf_cv_term_header" in
3629 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3633 case "$cf_cv_term_header" in
3635 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3638 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3642 dnl ---------------------------------------------------------------------------
3643 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3645 dnl Define a top_builddir symbol, for applications that need an absolute path.
3646 AC_DEFUN([CF_TOP_BUILDDIR],
3648 top_builddir=ifelse($1,,`pwd`,$1)
3649 AC_SUBST(top_builddir)
3651 dnl ---------------------------------------------------------------------------
3652 dnl CF_TPUTS_PROTO version: 4 updated: 2021/01/04 19:45:09
3654 dnl Check for type of function-pointer passed to tputs. Some old
3655 dnl implementations used functions that had different prototypes, making it
3656 dnl hard to compile portable programs using tputs.
3657 AC_DEFUN([CF_TPUTS_PROTO],[
3658 CF_CURSES_FUNCS(tputs)
3659 if test "x$cf_cv_func_tputs" = xyes
3662 for cf_arg in int char
3664 for cf_ret in int void
3666 if test "$cf_ret" = void
3668 cf_return="/* nothing */"
3670 cf_return="return value"
3673 #include <${cf_cv_ncurses_header:-curses.h}>
3674 #include <$cf_cv_term_header>
3676 static $cf_ret outc($cf_arg value) { $cf_return; }
3678 tputs("hello", 0, outc);
3679 ${cf_cv_main_return:-return}(0);
3681 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3682 cat >>confdefs.h <<EOF
3683 #define TPUTS_ARG $cf_arg
3684 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3685 #define TPUTS_RETURN(value) $cf_return
3691 test "$cf_done" = yes && break
3695 dnl ---------------------------------------------------------------------------
3696 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3698 dnl Trim extra base X libraries added as a workaround for inconsistent library
3699 dnl dependencies returned by "new" pkg-config files.
3700 AC_DEFUN([CF_TRIM_X_LIBS],[
3701 for cf_trim_lib in Xmu Xt X11
3704 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3705 LIBS=`echo "$LIBS " | sed -e 's/ / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3706 CF_VERBOSE(..trimmed $LIBS)
3711 dnl ---------------------------------------------------------------------------
3712 dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15
3713 dnl -----------------
3714 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3715 dnl available in that form.
3717 dnl $1 = package name, which may be a shell variable
3718 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3719 dnl $3 = logic to use if pkg-config does not have the package
3720 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3721 AC_REQUIRE([CF_PKG_CONFIG])
3723 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then
3724 CF_VERBOSE(found package $1)
3725 cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`"
3726 cf_pkgconfig_libs="`$PKG_CONFIG --libs "$1" 2>/dev/null`"
3727 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3728 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3729 CF_ADD_CFLAGS($cf_pkgconfig_incs)
3730 CF_ADD_LIBS($cf_pkgconfig_libs)
3731 ifelse([$2],,:,[$2])
3735 ifelse([$3],,:,[$3])
3738 dnl ---------------------------------------------------------------------------
3739 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
3740 dnl -------------------
3741 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3742 dnl can define it successfully.
3743 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3744 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3748 #include <sys/types.h>
3750 #ifndef _XOPEN_SOURCE
3753 [cf_cv_xopen_source=no],
3754 [cf_save="$CPPFLAGS"
3755 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3759 #include <sys/types.h>
3761 #ifdef _XOPEN_SOURCE
3764 [cf_cv_xopen_source=no],
3765 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3770 if test "$cf_cv_xopen_source" != no ; then
3771 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3772 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3773 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3774 CF_ADD_CFLAGS($cf_temp_xopen_source)
3777 dnl ---------------------------------------------------------------------------
3778 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3780 dnl Make an uppercase version of a variable
3781 dnl $1=uppercase($2)
3782 AC_DEFUN([CF_UPPER],
3784 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3786 dnl ---------------------------------------------------------------------------
3787 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3789 dnl Check for multibyte support, and if not found, utf8 compatibility library
3790 AC_DEFUN([CF_UTF8_LIB],
3792 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3793 cf_save_LIBS="$LIBS"
3795 #include <stdlib.h>],[putwc(0,0);],
3796 [cf_cv_utf8_lib=yes],
3798 #include <libutf8.h>],[putwc(0,0);],utf8,
3799 [cf_cv_utf8_lib=add-on],
3800 [cf_cv_utf8_lib=no])
3803 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3805 if test "$cf_cv_utf8_lib" = "add-on" ; then
3806 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3807 CF_ADD_INCDIR($cf_cv_header_path_utf8)
3808 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3809 CF_ADD_LIBS($cf_cv_library_file_utf8)
3812 dnl ---------------------------------------------------------------------------
3813 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3815 dnl Use AC_VERBOSE w/o the warnings
3816 AC_DEFUN([CF_VERBOSE],
3817 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
3820 dnl ---------------------------------------------------------------------------
3821 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3823 dnl Check if type wide-character type $1 is declared, and if so, which header
3824 dnl file is needed. The second parameter is used to set a shell variable when
3825 dnl the type is not found. The first parameter sets a shell variable for the
3827 AC_DEFUN([CF_WCHAR_TYPE],
3829 # This is needed on Tru64 5.0 to declare $1
3830 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3835 #ifdef HAVE_LIBUTF8_H
3836 #include <libutf8.h>
3845 #ifdef HAVE_LIBUTF8_H
3846 #include <libutf8.h>
3850 [cf_cv_$1=unknown])])])
3852 if test "$cf_cv_$1" = yes ; then
3853 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3858 # if we do not find $1 in either place, use substitution to provide a fallback.
3859 if test "$cf_cv_$1" = unknown ; then
3864 # if we find $1 in either place, use substitution to provide a fallback.
3865 if test "$cf_cv_$1" != unknown ; then
3870 dnl ---------------------------------------------------------------------------
3871 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
3872 dnl ------------------
3873 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3875 AC_DEFUN([CF_WITH_CURSES_DIR],[
3877 AC_MSG_CHECKING(for specific curses-directory)
3878 AC_ARG_WITH(curses-dir,
3879 [ --with-curses-dir=DIR directory in which (n)curses is installed],
3880 [cf_cv_curses_dir=$withval],
3881 [cf_cv_curses_dir=no])
3882 AC_MSG_RESULT($cf_cv_curses_dir)
3884 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3886 CF_PATH_SYNTAX(withval)
3887 if test -d "$cf_cv_curses_dir"
3889 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3890 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3894 dnl ---------------------------------------------------------------------------
3895 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3896 dnl ----------------
3897 dnl Configure-option for dbmalloc. The optional parameter is used to override
3898 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3899 AC_DEFUN([CF_WITH_DBMALLOC],[
3900 CF_NO_LEAKS_OPTION(dbmalloc,
3901 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
3904 if test "$with_dbmalloc" = yes ; then
3905 AC_CHECK_HEADER(dbmalloc.h,
3906 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3909 dnl ---------------------------------------------------------------------------
3910 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3912 dnl Configure-option for dmalloc. The optional parameter is used to override
3913 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3914 AC_DEFUN([CF_WITH_DMALLOC],[
3915 CF_NO_LEAKS_OPTION(dmalloc,
3916 [ --with-dmalloc test: use Gray Watson's dmalloc library],
3919 if test "$with_dmalloc" = yes ; then
3920 AC_CHECK_HEADER(dmalloc.h,
3921 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3924 dnl ---------------------------------------------------------------------------
3925 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
3926 dnl --------------------
3927 dnl Allow for overriding the basename of a library, i.e., the part to which
3928 dnl prefixes/suffixes are attached.
3930 dnl $1 = variable to set
3931 dnl $2 = option name
3932 dnl $3 = default basename for library, if omitted use $2
3933 AC_DEFUN([CF_WITH_LIB_BASENAME],
3935 AC_MSG_CHECKING(for desired basename for $2 library)
3936 AC_ARG_WITH($2-libname,
3937 [ --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
3938 [with_lib_basename=$withval],
3939 [with_lib_basename=ifelse($3,,$2,$3)])
3940 $1="$with_lib_basename"
3944 $1=ifelse($3,,$2,$3)
3950 AC_MSG_RESULT([$]$1)
3953 dnl ---------------------------------------------------------------------------
3954 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
3955 dnl -------------------
3956 dnl Use this macro for programs which use any variant of "curses", e.g.,
3957 dnl "ncurses", and "PDCurses". Programs that can use curses and some unrelated
3958 dnl library (such as slang) should use a "--with-screen=XXX" option.
3960 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3961 dnl of the macros inside this one - before this macro.
3962 define([CF_WITH_NCURSES_ETC],[
3967 AC_MSG_CHECKING(for specified curses library type)
3969 [ --with-screen=XXX use specified curses-libraries],
3970 [cf_cv_screen=$withval],[
3972 AC_ARG_WITH(ncursesw,
3973 [ --with-ncursesw use wide ncurses-libraries],
3974 [cf_cv_screen=ncursesw],[
3976 AC_ARG_WITH(ncurses,
3977 [ --with-ncurses use ncurses-libraries],
3978 [cf_cv_screen=ncurses],[
3980 AC_ARG_WITH(pdcurses,
3981 [ --with-pdcurses compile/link with pdcurses X11 library],
3982 [cf_cv_screen=pdcurses],[
3984 AC_ARG_WITH(curses-colr,
3985 [ --with-curses-colr compile/link with HPUX 10.x color-curses],
3986 [cf_cv_screen=curses_colr],[
3988 AC_ARG_WITH(curses-5lib,
3989 [ --with-curses-5lib compile/link with SunOS 5lib curses],
3990 [cf_cv_screen=curses_5lib])])])])])])
3992 AC_MSG_RESULT($cf_cv_screen)
3994 case $cf_cv_screen in
4000 CF_NCURSES_CONFIG($cf_cv_screen)
4003 CF_NCURSES_CONFIG($cf_cv_screen)
4009 AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
4013 CF_NCURSES_PTHREADS($cf_cv_screen)
4016 dnl ---------------------------------------------------------------------------
4017 dnl CF_WITH_SCREEN_PDCURSES version: 1 updated: 2020/08/28 16:56:27
4018 dnl -----------------------
4019 dnl Call this macro before CF_ENABLE_WARNINGS for configure scripts which use
4020 dnl the "--with-screen=pdcurses" selection. Doing that allows the configure
4021 dnl script to search for the X11/Xt header files to declare (or not) the
4022 dnl symbol needed to enable "const" in those header files. If that configure
4023 dnl option is not used, then those checks are unnecessary.
4024 AC_DEFUN([CF_WITH_SCREEN_PDCURSES],[
4025 AC_PROVIDE([AC_PATH_XTRA])
4026 AC_PROVIDE([AC_PATH_X])
4027 if test -n "$with_screen" && test "x$with_screen" = "xpdcurses"
4033 dnl ---------------------------------------------------------------------------
4034 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
4035 dnl ----------------
4036 AC_DEFUN([CF_WITH_VALGRIND],[
4037 CF_NO_LEAKS_OPTION(valgrind,
4038 [ --with-valgrind test: use valgrind],
4041 dnl ---------------------------------------------------------------------------
4042 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
4044 dnl Handle configure option "--with-x11-rgb", setting these shell
4047 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
4048 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
4050 dnl Most Linux's use this:
4051 dnl /usr/share/X11/rgb.txt
4052 dnl Debian uses this:
4053 dnl /etc/X11/rgb.txt
4054 dnl DragonFlyBSD ports uses this:
4055 dnl /usr/pkg/lib/X11/rgb.txt
4056 dnl FreeBSD ports use these:
4057 dnl /usr/local/lib/X11/rgb.txt
4058 dnl /usr/local/share/X11/rgb.txt
4059 dnl Mandriva has these:
4060 dnl /usr/lib/X11/rgb.txt
4061 dnl /usr/lib64/X11/rgb.txt
4062 dnl NetBSD has these
4063 dnl /usr/X11R7/lib/X11/rgb.txt
4064 dnl OpenSolaris uses
4066 dnl /usr/X11/etc/X11/rgb.txt
4067 dnl /usr/X11/share/X11/rgb.txt
4068 dnl /usr/X11/lib/X11/rgb.txt
4070 dnl /opt/local/share/X11/rgb.txt (MacPorts)
4071 dnl /opt/X11/share/X11/rgb.txt (non-ports)
4073 dnl /usr/X11/etc/X11/rgb.txt
4074 dnl /usr/X11/share/X11/rgb.txt (perhaps)
4075 dnl /usr/X11/lib/amd64/X11/rgb.txt
4076 dnl Solaris10 uses (in this order):
4077 dnl /usr/openwin/lib/X11/rgb.txt
4078 dnl /usr/X11/lib/X11/rgb.txt
4079 AC_DEFUN([CF_WITH_X11_RGB],[
4080 AC_MSG_CHECKING(for X11 rgb file)
4081 AC_ARG_WITH(x11-rgb,
4082 [ --with-x11-rgb=FILE file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
4083 [RGB_PATH=$withval],
4086 if test "x[$]RGB_PATH" = xauto
4088 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
4090 /opt/local/share/X11/rgb.txt \
4091 /opt/X11/share/X11/rgb.txt \
4092 /usr/share/X11/rgb.txt \
4093 /usr/X11/share/X11/rgb.txt \
4094 /usr/X11/lib/X11/rgb.txt \
4095 /usr/lib/X11/rgb.txt \
4097 /usr/pkg/lib/X11/rgb.txt \
4098 /usr/X11R7/lib/X11/rgb.txt \
4099 /usr/X11R6/lib/X11/rgb.txt \
4100 /usr/X11R5/lib/X11/rgb.txt \
4101 /usr/X11R4/lib/X11/rgb.txt \
4102 /usr/local/lib/X11/rgb.txt \
4103 /usr/local/share/X11/rgb.txt \
4104 /usr/lib64/X11/rgb.txt
4106 if test -f "$cf_path" ; then
4113 CF_PATH_SYNTAX(cf_path)
4116 AC_MSG_RESULT($RGB_PATH)
4118 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
4121 if test "$RGB_PATH" = no
4125 AC_SUBST(no_x11_rgb)
4127 dnl ---------------------------------------------------------------------------
4128 dnl CF_XOPEN_CURSES version: 16 updated: 2021/01/02 09:31:20
4130 dnl Test if we should define X/Open source for curses, needed on Digital Unix
4131 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
4133 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
4134 dnl as getbegy(). The latter is better design, but the former is standard.
4135 AC_DEFUN([CF_XOPEN_CURSES],
4137 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
4138 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
4139 cf_cv_need_xopen_extension=unknown
4142 #include <${cf_cv_ncurses_header:-curses.h}>],[
4143 #if defined(NCURSES_VERSION_PATCH)
4144 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
4148 #ifdef NCURSES_VERSION
4150 int check2 = curs_set((int)sizeof(check));
4152 long x = winnstr(stdscr, "", 0);
4154 #ifdef NCURSES_VERSION
4157 getbegyx(stdscr, y1, x1);
4162 [cf_cv_need_xopen_extension=none],
4164 for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
4167 #define $cf_try_xopen_extension 1
4169 #include <${cf_cv_ncurses_header:-curses.h}>],[
4170 #ifdef NCURSES_VERSION
4172 int check2 = curs_set((int)sizeof(check));
4174 long x = winnstr(stdscr, "", 0);
4176 getbegyx(stdscr, y1, x1);
4177 #ifdef NCURSES_VERSION
4184 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
4189 case "$cf_cv_need_xopen_extension" in
4191 CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
4196 dnl ---------------------------------------------------------------------------
4197 dnl CF_XOPEN_SOURCE version: 57 updated: 2021/01/01 16:53:59
4199 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4200 dnl or adapt to the vendor's definitions to get equivalent functionality,
4201 dnl without losing the common non-POSIX features.
4204 dnl $1 is the nominal value for _XOPEN_SOURCE
4205 dnl $2 is the nominal value for _POSIX_C_SOURCE
4206 AC_DEFUN([CF_XOPEN_SOURCE],[
4207 AC_REQUIRE([AC_CANONICAL_HOST])
4208 AC_REQUIRE([CF_POSIX_VISIBLE])
4210 if test "$cf_cv_posix_visible" = no; then
4212 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4213 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4218 cf_xopen_source="-D_ALL_SOURCE"
4224 cf_xopen_source="-D_APPLE_C_SOURCE"
4227 cf_xopen_source="-D_DARWIN_C_SOURCE"
4230 (freebsd*|dragonfly*|midnightbsd*)
4231 # 5.x headers associate
4232 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4233 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4234 cf_POSIX_C_SOURCE=200112L
4236 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4239 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4242 cf_xopen_source="-D_HPUX_SOURCE"
4245 cf_xopen_source="-D_SGI_SOURCE"
4248 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4249 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4252 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4255 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4257 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4260 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4263 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4264 cf_xopen_source="-D_BSD_SOURCE"
4268 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4271 cf_xopen_source="-D_OSF_SOURCE"
4274 cf_xopen_source="-D_QNX_SOURCE"
4277 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4280 cf_xopen_source="-D__EXTENSIONS__"
4281 cf_cv_xopen_source=broken
4283 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4289 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4293 if test -n "$cf_xopen_source" ; then
4294 CF_ADD_CFLAGS($cf_xopen_source,true)
4297 dnl In anything but the default case, we may have system-specific setting
4298 dnl which is still not guaranteed to provide all of the entrypoints that
4299 dnl _XOPEN_SOURCE would yield.
4300 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4301 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4302 AC_TRY_COMPILE([#include <stdlib.h>],[
4303 #ifndef _XOPEN_SOURCE
4306 [cf_XOPEN_SOURCE_set=yes],
4307 [cf_XOPEN_SOURCE_set=no])
4308 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4309 if test "$cf_XOPEN_SOURCE_set" = yes
4311 AC_TRY_COMPILE([#include <stdlib.h>],[
4312 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4315 [cf_XOPEN_SOURCE_set_ok=yes],
4316 [cf_XOPEN_SOURCE_set_ok=no])
4317 if test "$cf_XOPEN_SOURCE_set_ok" = no
4319 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4325 fi # cf_cv_posix_visible
4327 dnl ---------------------------------------------------------------------------
4328 dnl CF_X_ATHENA version: 24 updated: 2020/03/10 18:53:47
4330 dnl Check for Xaw (Athena) libraries
4332 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4333 AC_DEFUN([CF_X_ATHENA],
4335 cf_x_athena=${cf_x_athena:-Xaw}
4337 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4340 [ --with-Xaw3d link with Xaw 3d library])
4341 if test "$withval" = yes ; then
4348 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4350 AC_ARG_WITH(Xaw3dxft,
4351 [ --with-Xaw3dxft link with Xaw 3d xft library])
4352 if test "$withval" = yes ; then
4353 cf_x_athena=Xaw3dxft
4359 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4362 [ --with-neXtaw link with neXT Athena library])
4363 if test "$withval" = yes ; then
4370 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4372 AC_ARG_WITH(XawPlus,
4373 [ --with-XawPlus link with Athena-Plus library])
4374 if test "$withval" = yes ; then
4383 if test "$PKG_CONFIG" != none ; then
4385 test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4386 for cf_athena_pkg in \
4389 ${cf_x_athena}-devel \
4391 lib${cf_x_athena}-devel
4393 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4394 cf_x_athena_lib="$cf_pkgconfig_libs"
4395 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4396 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4400 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4402 #include <X11/Xmu/CharSet.h>
4404 int check = XmuCompareISOLatin1("big", "small");
4406 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4408 if test "$cf_cv_xaw_compat" = no
4410 # workaround for broken ".pc" files...
4411 case "$cf_x_athena_lib" in
4415 CF_VERBOSE(work around broken package)
4417 cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4418 CF_TRY_PKG_CONFIG(xmu,[
4420 CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4422 CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4433 if test -z "$cf_x_athena_lib" ; then
4436 CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4437 CF_X_ATHENA_LIBS($cf_x_athena)
4440 dnl ---------------------------------------------------------------------------
4441 dnl CF_X_ATHENA_CPPFLAGS version: 9 updated: 2020/12/31 10:54:15
4442 dnl --------------------
4443 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4444 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4445 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4447 AC_REQUIRE([AC_PATH_XTRA])
4448 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4451 for cf_path in default \
4452 /usr/contrib/X11R6 \
4453 /usr/contrib/X11R5 \
4457 if test -z "$cf_x_athena_inc" ; then
4458 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4459 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4460 if test "$cf_path" != default ; then
4461 CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4462 AC_MSG_CHECKING(for $cf_test in $cf_path)
4464 AC_MSG_CHECKING(for $cf_test)
4467 #include <X11/Intrinsic.h>
4468 #include <$cf_test>],[],
4471 AC_MSG_RESULT($cf_result)
4472 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4473 if test "$cf_result" = yes ; then
4474 test "$cf_path" = default && cf_x_athena_inc=default
4475 test "$cf_path" != default && cf_x_athena_inc="$cf_path/include"
4481 if test -z "$cf_x_athena_inc" ; then
4482 AC_MSG_WARN([Unable to find Athena header files])
4483 elif test "$cf_x_athena_inc" != default ; then
4484 CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4487 dnl ---------------------------------------------------------------------------
4488 dnl CF_X_ATHENA_LIBS version: 13 updated: 2020/01/11 18:16:10
4489 dnl ----------------
4490 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4491 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4492 AC_DEFUN([CF_X_ATHENA_LIBS],
4493 [AC_REQUIRE([CF_X_TOOLKIT])
4494 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4497 for cf_path in default \
4498 /usr/contrib/X11R6 \
4499 /usr/contrib/X11R5 \
4504 ${cf_x_athena_root} \
4505 ${cf_x_athena_root}7 \
4506 ${cf_x_athena_root}6
4510 "-l$cf_lib -lXpm -lXmu" \
4511 "-l${cf_lib}_s -lXmu_s"
4513 test -n "$cf_x_athena_lib" && break
4515 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4516 cf_test=XawSimpleMenuAddGlobalActions
4517 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4518 CF_ADD_LIBS($cf_libs)
4519 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4521 #include <X11/Intrinsic.h>
4522 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4524 $cf_test((XtAppContext) 0)],
4527 AC_MSG_RESULT($cf_result)
4528 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4530 if test "$cf_result" = yes ; then
4531 cf_x_athena_lib="$cf_libs"
4535 test -n "$cf_x_athena_lib" && break
4539 if test -z "$cf_x_athena_lib" ; then
4541 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4544 CF_ADD_LIBS($cf_x_athena_lib)
4545 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4546 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4548 dnl ---------------------------------------------------------------------------
4549 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4551 AC_DEFUN([CF_X_EXT],[
4552 CF_TRY_PKG_CONFIG(Xext,,[
4553 AC_CHECK_LIB(Xext,XextCreateExtension,
4554 [CF_ADD_LIB(Xext)])])
4556 dnl ---------------------------------------------------------------------------
4557 dnl CF_X_TOOLKIT version: 26 updated: 2021/01/02 09:31:20
4559 dnl Check for X Toolkit libraries
4560 AC_DEFUN([CF_X_TOOLKIT],
4562 AC_REQUIRE([AC_PATH_XTRA])
4563 AC_REQUIRE([CF_CHECK_CACHE])
4565 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4566 # in some cases has installed dummy files in the former, other cases replaced
4567 # it with a link to the new location). This complicates the configure script.
4568 # Check for that pitfall, and recover using pkg-config
4570 # If none of these are set, the configuration is almost certainly broken.
4571 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4573 CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4574 CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4575 CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4576 CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4578 LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS"
4583 CF_TRY_PKG_CONFIG(xt,[
4589 # we have an "xt" package, but it may omit Xt's dependency on X11
4590 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4592 #include <X11/Xlib.h>
4594 int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4595 int rc2 = XClearWindow((Display*) 0, (Window) 0);
4596 int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4597 int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4598 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4599 if test "$cf_cv_xt_x11_compat" = no
4601 CF_VERBOSE(work around broken X11 dependency)
4602 # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4603 CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4608 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4610 #include <X11/Shell.h>
4611 ],[int num = IceConnectionNumber(0); (void) num
4612 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4614 if test "$cf_cv_xt_ice_compat" = no
4616 # workaround for broken ".pc" files used for X Toolkit.
4617 case "x$X_PRE_LIBS" in
4623 CF_VERBOSE(work around broken ICE dependency)
4624 CF_TRY_PKG_CONFIG(ice,
4625 [CF_TRY_PKG_CONFIG(sm)],
4626 [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4636 LDFLAGS="$X_LIBS $LDFLAGS"
4637 CF_CHECK_CFLAGS($X_CFLAGS)
4639 AC_CHECK_FUNC(XOpenDisplay,,[
4640 AC_CHECK_LIB(X11,XOpenDisplay,
4641 [CF_ADD_LIB(X11)])])
4643 AC_CHECK_FUNC(XtAppInitialize,,[
4644 AC_CHECK_LIB(Xt, XtAppInitialize,
4645 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4647 LIBS="-lXt $LIBS"])])
4650 if test "$cf_have_X_LIBS" = no ; then
4652 [Unable to successfully link X Toolkit library (-lXt) with
4653 test program. You will have to check and add the proper libraries by hand
4657 dnl ---------------------------------------------------------------------------
4658 dnl CF__CURSES_DATA version: 3 updated: 2021/01/04 19:45:09
4660 dnl Attempt to make a copy of a curses data item. This is needed in the
4661 dnl check-data configure tests when using ncurses, because the symbol may be
4662 dnl actually a function return-value. That could happen if the linker is
4663 dnl broken (does not resolve data-only references), or if ncurses is configured
4664 dnl to support re-entrant code.
4667 define([CF__CURSES_DATA],[
4668 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4669 const void *$1 = (const void *)($2);
4671 const void *$1 = &($2);
4673 fprintf(stderr, "testing linkage of $2:%p\\n", (const void *)$1);
4675 dnl ---------------------------------------------------------------------------
4676 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4678 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4679 dnl are both available.
4680 define([CF__CURSES_HEAD],[
4682 #include <xcurses.h>
4683 char * XCursesProgramName = "test";
4685 #include <${cf_cv_ncurses_header:-curses.h}>
4686 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4687 #include <ncursesw/term.h>
4688 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4689 #include <ncurses/term.h>
4690 #elif defined(HAVE_TERM_H)