1 dnl***************************************************************************
2 dnl Copyright 2018-2019,2020 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.183 2020/09/26 22:13:19 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: 5 updated: 2020/03/10 18:53:47
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: 14 updated: 2020/04/04 16:16:13
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: 15 updated: 2018/06/20 20:23:13
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: 10 updated: 2015/04/18 08:56:57
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: 4 updated: 2013/10/08 17:47:05
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_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
395 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
396 dnl into CC. This will not help with broken scripts that wrap the compiler
397 dnl with options, but eliminates a more common category of user confusion.
399 dnl In particular, it addresses the problem of being able to run the C
400 dnl preprocessor in a consistent manner.
402 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
403 dnl the nuisance of having inconsistent settings for compiler and preprocessor
404 dnl outweighs that limitation.
405 AC_DEFUN([CF_CC_ENV_FLAGS],
407 # This should have been defined by AC_PROG_CC
410 AC_MSG_CHECKING(\$CFLAGS variable)
413 AC_MSG_RESULT(broken)
414 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
417 for cf_arg in $cf_flags
419 CF_ADD_CFLAGS($cf_arg)
427 AC_MSG_CHECKING(\$CC variable)
430 AC_MSG_RESULT(broken)
431 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
433 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
434 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
436 for cf_arg in $cf_flags
440 CF_ADD_CFLAGS($cf_arg)
447 CF_VERBOSE(resulting CC: '$CC')
448 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
449 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
456 dnl ---------------------------------------------------------------------------
457 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
459 dnl Check if we're accidentally using a cache from a different machine.
460 dnl Derive the system name, as a check for reusing the autoconf cache.
462 dnl If we've packaged config.guess and config.sub, run that (since it does a
463 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
464 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
465 dnl which is useful in cross-compiles.
467 dnl Note: we would use $ac_config_sub, but that is one of the places where
468 dnl autoconf 2.5x broke compatibility with autoconf 2.13
469 AC_DEFUN([CF_CHECK_CACHE],
471 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
472 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
473 system_name="$host_os"
475 system_name="`(uname -s -r) 2>/dev/null`"
476 if test -z "$system_name" ; then
477 system_name="`(hostname) 2>/dev/null`"
480 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
481 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
483 test -z "$system_name" && system_name="$cf_cv_system_name"
484 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
486 if test ".$system_name" != ".$cf_cv_system_name" ; then
487 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
488 AC_MSG_ERROR("Please remove config.cache and try again.")
491 dnl ---------------------------------------------------------------------------
492 dnl CF_CHECK_CFLAGS version: 3 updated: 2014/07/22 05:32:57
494 dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
495 dnl a build-configuration such as imake. These have the pitfall that they
496 dnl often contain compiler-specific options which we cannot use, mixed with
497 dnl preprocessor options that we usually can.
498 AC_DEFUN([CF_CHECK_CFLAGS],
500 CF_VERBOSE(checking additions to CFLAGS)
501 cf_check_cflags="$CFLAGS"
502 cf_check_cppflags="$CPPFLAGS"
503 CF_ADD_CFLAGS($1,yes)
504 if test "x$cf_check_cflags" != "x$CFLAGS" ; then
505 AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
506 [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS)
507 if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
508 CF_VERBOSE(but keeping change to \$CPPFLAGS)
510 CFLAGS="$cf_check_flags"])
513 dnl ---------------------------------------------------------------------------
514 dnl CF_CHECK_CURSES_LIB version: 2 updated: 2018/01/03 04:47:33
515 dnl -------------------
516 dnl $1 = nominal library name, used also for header lookup
517 dnl $2 = suffix to append to library name
518 dnl $3 = function to check for using AC_CHECK_LIB
519 dnl $4 = optional parameter list for $3
520 AC_DEFUN([CF_CHECK_CURSES_LIB],
522 AC_REQUIRE([CF_PKG_CONFIG])
524 cf_have_curses_lib=no
526 : ${NCURSES_CONFIG_PKG:=none}
527 if test "x${NCURSES_CONFIG_PKG}" = xnone; then
529 elif test "x${PKG_CONFIG:=none}" != xnone; then
530 AC_MSG_CHECKING(pkg-config for $1$2)
531 if "$PKG_CONFIG" --exists $1$2 ; then
534 AC_MSG_CHECKING(if the $1$2 package files work)
536 cf_save_CPPFLAGS="$CPPFLAGS"
539 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags $1$2`)
540 CF_ADD_LIBS(`$PKG_CONFIG --libs $1$2`)
542 AC_TRY_LINK([#include <$1.h>],
543 [(void) $3 ( ]ifelse([$4],,,[[$4]])[ );],
544 [AC_TRY_RUN([#include <$1.h>
546 { (void) $3 ( ]ifelse([$4],,,[[$4]])[ ); return 0; }],
547 [cf_have_curses_lib=yes],
548 [cf_have_curses_lib=no],
549 [cf_have_curses_lib=maybe])],
550 [cf_have_curses_lib=no])
551 AC_MSG_RESULT($cf_have_curses_lib)
552 test "$cf_have_curses_lib" = maybe && cf_have_curses_lib=yes
553 if test "$cf_have_curses_lib" != "yes"
555 CPPFLAGS="$cf_save_CPPFLAGS"
558 CF_UPPER(cf_upper,have_lib$1)
559 AC_DEFINE_UNQUOTED($cf_upper,1)
563 if test "$cf_have_curses_lib" = no; then
564 AC_CHECK_LIB($1$2,$3,[
565 CF_UPPER(cf_upper,have_lib$1)
567 AC_DEFINE_UNQUOTED($cf_upper,1)])
570 dnl ---------------------------------------------------------------------------
571 dnl CF_CLANG_COMPILER version: 3 updated: 2020/08/28 04:10:22
572 dnl -----------------
573 dnl Check if the given compiler is really clang. clang's C driver defines
574 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
575 dnl not ignore some gcc options.
577 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
578 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
579 dnl the wrappers for gcc and g++ warnings.
581 dnl $1 = GCC (default) or GXX
582 dnl $2 = CLANG_COMPILER (default)
583 dnl $3 = CFLAGS (default) or CXXFLAGS
584 AC_DEFUN([CF_CLANG_COMPILER],[
585 ifelse([$2],,CLANG_COMPILER,[$2])=no
587 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
588 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
589 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
590 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
596 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
597 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
599 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
600 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
603 if test "x$CLANG_COMPILER" = "xyes" ; then
604 CF_APPEND_TEXT(CFLAGS,-Wno-error=implicit-function-declaration)
607 dnl ---------------------------------------------------------------------------
608 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
609 dnl -----------------
610 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
611 dnl character-strings.
613 dnl It is ambiguous because the specification accommodated the pre-ANSI
614 dnl compilers bundled by more than one vendor in lieu of providing a standard C
615 dnl compiler other than by costly add-ons. Because of this, the specification
616 dnl did not take into account the use of const for telling the compiler that
617 dnl string literals would be in readonly memory.
619 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
620 dnl let the compiler decide how to represent Xt's strings which were #define'd.
621 dnl That does not solve the problem of using the block of Xt's strings which
622 dnl are compiled into the library (and is less efficient than one might want).
624 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
625 dnl when compiling the library and compiling using the library, to tell the
626 dnl compiler that String is const.
627 AC_DEFUN([CF_CONST_X_STRING],
629 AC_REQUIRE([AC_PATH_XTRA])
631 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
636 #include <X11/Intrinsic.h>
638 [String foo = malloc(1); (void)foo],[
640 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
643 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
644 #undef XTSTRINGDEFINES /* X11R5 and later */
646 #include <X11/Intrinsic.h>
647 ],[String foo = malloc(1); *foo = 0],[
648 cf_cv_const_x_string=no
650 cf_cv_const_x_string=yes
654 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
656 case $cf_cv_const_x_string in
658 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
661 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
667 dnl ---------------------------------------------------------------------------
668 dnl CF_CURSES_ACS_MAP version: 7 updated: 2012/10/06 16:39:58
669 dnl -----------------
670 dnl Check for likely values of acs_map[]:
671 AC_DEFUN([CF_CURSES_ACS_MAP],
673 AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
674 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
675 cf_cv_curses_acs_map=unknown
676 for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
679 #include <${cf_cv_ncurses_header:-curses.h}>
681 $name['k'] = ACS_PLUS
682 ],[cf_cv_curses_acs_map=$name; break])
686 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_])
688 dnl ---------------------------------------------------------------------------
689 dnl CF_CURSES_CHECK_DATA version: 9 updated: 2020/02/08 21:00:26
690 dnl --------------------
691 dnl Check if curses.h defines the given data/variable.
692 dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
694 dnl $1 = data item(s) to check for
695 dnl $2 = action on success, e.g., "break" to quit checking a series of choices
696 AC_DEFUN([CF_CURSES_CHECK_DATA],
700 AC_MSG_CHECKING(for data $cf_data declaration in ${cf_cv_ncurses_header:-curses.h})
702 AC_TRY_COMPILE(CF__CURSES_HEAD,
703 CF__CURSES_DATA(foo,$cf_data)
706 AC_MSG_RESULT($cf_result)
708 if test $cf_result = yes ; then
709 CF_UPPER(cf_result,have_curses_data_$cf_data)
710 AC_DEFINE_UNQUOTED($cf_result)
713 AC_MSG_CHECKING(for data $cf_data in library)
714 # BSD linkers insist on making weak linkage, but resolve at runtime.
715 AC_TRY_RUN(CF__CURSES_HEAD
717 extern char $cf_data;
720 ]CF__CURSES_DATA(foo,$cf_data)[
721 ${cf_cv_main_return:-return}(foo == 0);
725 AC_TRY_LINK(CF__CURSES_HEAD
726 [extern char $cf_data;],[
728 ]CF__CURSES_DATA(foo,$cf_data)[
729 ${cf_cv_main_return:-return}(foo == 0);
731 ],[cf_result=yes],[cf_result=no])
733 AC_MSG_RESULT($cf_result)
734 if test $cf_result = yes ; then
735 CF_UPPER(cf_result,decl_curses_data_$cf_data)
736 AC_DEFINE_UNQUOTED($cf_result)
737 # do not exit loop here, since we prefer system's declarations
742 dnl ---------------------------------------------------------------------------
743 dnl CF_CURSES_CHECK_TYPE version: 4 updated: 2012/10/06 16:39:58
744 dnl --------------------
745 dnl Check if curses.h defines the given type
746 AC_DEFUN([CF_CURSES_CHECK_TYPE],
748 AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
750 #ifndef _XOPEN_SOURCE_EXTENDED
751 #define _XOPEN_SOURCE_EXTENDED
753 #include <${cf_cv_ncurses_header:-curses.h}>],[
755 ],cf_result=yes,cf_result=no)
756 AC_MSG_RESULT($cf_result)
757 if test $cf_result = yes ; then
758 CF_UPPER(cf_result,have_type_$1)
759 AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
761 AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
764 dnl ---------------------------------------------------------------------------
765 dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
767 dnl Tie together the configure-script macros for curses. It may be ncurses,
768 dnl but unless asked, we do not make a special search for ncurses. However,
769 dnl still check for the ncurses version number, for use in other macros.
770 AC_DEFUN([CF_CURSES_CONFIG],
776 dnl ---------------------------------------------------------------------------
777 dnl CF_CURSES_CPPFLAGS version: 13 updated: 2018/06/20 20:23:13
778 dnl ------------------
779 dnl Look for the curses headers.
780 AC_DEFUN([CF_CURSES_CPPFLAGS],[
782 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
783 cf_cv_curses_incdir=no
786 if test "x$cf_cv_screen" = "xcurses_colr"
788 test -d /usr/include/curses_colr && \
789 cf_cv_curses_incdir="-I/usr/include/curses_colr"
793 if test "x$cf_cv_screen" = "xcurses_5lib"
795 test -d /usr/5lib && \
796 test -d /usr/5include && \
797 cf_cv_curses_incdir="-I/usr/5include"
802 if test "$cf_cv_curses_incdir" != no
804 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
810 dnl ---------------------------------------------------------------------------
811 dnl CF_CURSES_FUNCS version: 19 updated: 2018/01/03 04:47:33
813 dnl Curses-functions are a little complicated, since a lot of them are macros.
814 AC_DEFUN([CF_CURSES_FUNCS],
816 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
817 AC_REQUIRE([CF_XOPEN_CURSES])
818 AC_REQUIRE([CF_CURSES_TERM_H])
819 AC_REQUIRE([CF_CURSES_UNCTRL_H])
822 CF_UPPER(cf_tr_func,$cf_func)
823 AC_MSG_CHECKING(for ${cf_func})
824 CF_MSG_LOG(${cf_func})
825 AC_CACHE_VAL(cf_cv_func_$cf_func,[
826 eval cf_result='$ac_cv_func_'$cf_func
827 if test ".$cf_result" != ".no"; then
828 AC_TRY_LINK(CF__CURSES_HEAD,
831 long foo = (long)(&${cf_func});
832 fprintf(stderr, "testing linkage of $cf_func:%p\n", (void *)foo);
833 if (foo + 1234L > 5678L)
834 ${cf_cv_main_return:-return}(foo != 0);
840 eval 'cf_cv_func_'$cf_func'=$cf_result'
842 # use the computed/retrieved cache-value:
843 eval 'cf_result=$cf_cv_func_'$cf_func
844 AC_MSG_RESULT($cf_result)
845 if test $cf_result != no; then
846 AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
850 dnl ---------------------------------------------------------------------------
851 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
853 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
854 dnl variations of ncurses' installs.
856 dnl $1 = ncurses when looking for ncurses, or is empty
857 AC_DEFUN([CF_CURSES_HEADER],[
858 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
859 cf_cv_ncurses_header=none
861 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
862 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
864 AC_TRY_COMPILE([#include <${cf_header}>],
865 [initscr(); tgoto("?", 0,0)],
866 [cf_cv_ncurses_header=$cf_header; break],[])
870 if test "$cf_cv_ncurses_header" = none ; then
871 AC_MSG_ERROR(No curses header-files found)
874 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
875 AC_CHECK_HEADERS($cf_cv_ncurses_header)
877 dnl ---------------------------------------------------------------------------
878 dnl CF_CURSES_LIBS version: 42 updated: 2018/06/20 20:23:13
880 dnl Look for the curses libraries. Older curses implementations may require
881 dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first.
882 AC_DEFUN([CF_CURSES_LIBS],[
884 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
885 AC_MSG_CHECKING(if we have identified curses libraries)
886 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
887 [initscr(); tgoto("?", 0,0)],
890 AC_MSG_RESULT($cf_result)
892 if test "$cf_result" = no ; then
895 AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
898 # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
899 # next (1998), and xcurses "newer" (2000). There is no header file for
900 # Hcurses; the subdirectory curses_colr has the headers (curses.h and
901 # term.h) for cur_colr
902 if test "x$cf_cv_screen" = "xcurses_colr"
904 AC_CHECK_LIB(cur_colr,initscr,[
905 CF_ADD_LIBS(-lcur_colr)
906 ac_cv_func_initscr=yes
908 AC_CHECK_LIB(Hcurses,initscr,[
909 # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
910 CF_ADD_LIBS(-lHcurses)
911 CF_APPEND_TEXT(CPPFLAGS,-D__HP_CURSES -D_HP_CURSES)
912 ac_cv_func_initscr=yes
917 case `arch 2>/dev/null` in
921 CF_ADD_LIBDIR(/lib64)
932 if test "x$cf_cv_screen" = "xcurses_5lib"
934 if test -d /usr/5lib ; then
935 CF_ADD_LIBDIR(/usr/5lib)
936 CF_ADD_LIBS(-lcurses -ltermcap)
939 ac_cv_func_initscr=yes
943 if test ".$ac_cv_func_initscr" != .yes ; then
946 if test ".${cf_cv_ncurses_version:-no}" != .no
948 cf_check_list="ncurses curses cursesX"
950 cf_check_list="cursesX curses ncurses"
953 # Check for library containing tgoto. Do this before curses library
954 # because it may be needed to link the test-case for initscr.
955 if test "x$cf_term_lib" = x
957 AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
958 for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
960 AC_CHECK_LIB($cf_term_lib,tgoto,[
961 : ${cf_nculib_root:=$cf_term_lib}
968 # Check for library containing initscr
969 test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
970 if test "x$cf_curs_lib" = x
972 for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
974 LIBS="-l$cf_curs_lib $cf_save_LIBS"
975 if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
976 AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
977 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
981 AC_MSG_RESULT($cf_result)
982 test $cf_result = yes && break
983 elif test "$cf_curs_lib" = "$cf_term_lib" ; then
985 elif test "$cf_term_lib" != predefined ; then
986 AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
987 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
988 [initscr(); tgoto((char *)0, 0, 0);],
991 LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
992 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
997 AC_MSG_RESULT($cf_result)
998 test $cf_result != error && break
1002 test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found)
1007 dnl ---------------------------------------------------------------------------
1008 dnl CF_CURSES_TERM_H version: 12 updated: 2020/03/19 20:23:48
1009 dnl ----------------
1010 dnl SVr4 curses should have term.h as well (where it puts the definitions of
1011 dnl the low-level interface). This may not be true in old/broken implementations,
1012 dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
1013 dnl running with Solaris 2.5.1).
1014 AC_DEFUN([CF_CURSES_TERM_H],
1016 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1018 AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
1020 # If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
1021 # for <term.h> if we do not find the variant.
1023 cf_header_list="term.h ncurses/term.h ncursesw/term.h"
1025 case ${cf_cv_ncurses_header:-curses.h} in
1027 cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
1028 cf_header_list="$cf_header_item $cf_header_list"
1032 for cf_header in $cf_header_list
1035 #include <${cf_cv_ncurses_header:-curses.h}>
1036 #include <${cf_header}>],
1037 [WINDOW *x; (void)x],
1038 [cf_cv_term_header=$cf_header
1040 [cf_cv_term_header=no])
1043 case $cf_cv_term_header in
1045 # If curses is ncurses, some packagers still mess it up by trying to make
1046 # us use GNU termcap. This handles the most common case.
1047 for cf_header in ncurses/term.h ncursesw/term.h
1050 #include <${cf_cv_ncurses_header:-curses.h}>
1051 #ifdef NCURSES_VERSION
1052 #include <${cf_header}>
1056 [WINDOW *x; (void)x],
1057 [cf_cv_term_header=$cf_header
1059 [cf_cv_term_header=no])
1065 case $cf_cv_term_header in
1067 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
1070 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
1073 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
1077 dnl ---------------------------------------------------------------------------
1078 dnl CF_CURSES_UNCTRL_H version: 5 updated: 2020/03/19 20:23:48
1079 dnl ------------------
1080 dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
1081 dnl may put it in a subdirectory (along with ncurses' other headers, of
1082 dnl course). Packages which put the headers in inconsistent locations are
1084 AC_DEFUN([CF_CURSES_UNCTRL_H],
1086 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1088 AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
1090 # If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
1091 # for <unctrl.h> if we do not find the variant.
1093 cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
1095 case ${cf_cv_ncurses_header:-curses.h} in
1097 cf_header_item=`echo ${cf_cv_ncurses_header:-curses.h} | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
1098 cf_header_list="$cf_header_item $cf_header_list"
1102 for cf_header in $cf_header_list
1105 #include <${cf_cv_ncurses_header:-curses.h}>
1106 #include <${cf_header}>],
1107 [WINDOW *x; (void)x],
1108 [cf_cv_unctrl_header=$cf_header
1110 [cf_cv_unctrl_header=no])
1114 case $cf_cv_unctrl_header in
1116 AC_MSG_WARN(unctrl.h header not found)
1120 case $cf_cv_unctrl_header in
1122 AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
1125 AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
1128 AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
1132 dnl ---------------------------------------------------------------------------
1133 dnl CF_CURSES_WACS_MAP version: 7 updated: 2020/03/19 20:23:48
1134 dnl ------------------
1135 dnl Check for likely values of wacs_map[].
1136 AC_DEFUN([CF_CURSES_WACS_MAP],
1138 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
1139 cf_cv_curses_wacs_map=unknown
1140 for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
1143 #ifndef _XOPEN_SOURCE_EXTENDED
1144 #define _XOPEN_SOURCE_EXTENDED
1146 #include <${cf_cv_ncurses_header:-curses.h}>],
1147 [void *foo = &($name['k']); (void)foo],
1148 [cf_cv_curses_wacs_map=$name
1152 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])
1154 dnl ---------------------------------------------------------------------------
1155 dnl CF_CURSES_WACS_SYMBOLS version: 3 updated: 2020/03/19 20:23:48
1156 dnl ----------------------
1157 dnl Do a check to see if the WACS_xxx constants are defined compatibly with
1158 dnl X/Open Curses. In particular, NetBSD's implementation of the WACS_xxx
1159 dnl constants is broken since those constants do not point to cchar_t's.
1160 AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
1162 AC_REQUIRE([CF_CURSES_WACS_MAP])
1164 AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
1165 cf_cv_curses_wacs_symbols=no
1166 if test "$cf_cv_curses_wacs_map" != unknown
1169 #ifndef _XOPEN_SOURCE_EXTENDED
1170 #define _XOPEN_SOURCE_EXTENDED
1172 #include <${cf_cv_ncurses_header:-curses.h}>],
1173 [cchar_t *foo = WACS_PLUS;
1174 $cf_cv_curses_wacs_map['k'] = *WACS_PLUS; (void)foo],
1175 [cf_cv_curses_wacs_symbols=yes])
1178 #ifndef _XOPEN_SOURCE_EXTENDED
1179 #define _XOPEN_SOURCE_EXTENDED
1181 #include <${cf_cv_ncurses_header:-curses.h}>],
1182 [cchar_t *foo = WACS_PLUS; (void)foo],
1183 [cf_cv_curses_wacs_symbols=yes])
1187 test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
1189 dnl ---------------------------------------------------------------------------
1190 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1192 dnl "dirname" is not portable, so we fake it with a shell script.
1193 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1194 dnl ---------------------------------------------------------------------------
1195 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1197 dnl You can always use "make -n" to see the actual options, but it's hard to
1198 dnl pick out/analyze warning messages when the compile-line is long.
1201 dnl ECHO_LT - symbol to control if libtool is verbose
1202 dnl ECHO_LD - symbol to prefix "cc -o" lines
1203 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1204 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1205 dnl ECHO_CC - symbol to put before any "cc" line
1207 AC_DEFUN([CF_DISABLE_ECHO],[
1208 AC_MSG_CHECKING(if you want to see long compiling messages)
1209 CF_ARG_DISABLE(echo,
1210 [ --disable-echo do not display "compiling" commands],
1213 ECHO_LD='@echo linking [$]@;'
1214 RULE_CC='@echo compiling [$]<'
1215 SHOW_CC='@echo compiling [$]@'
1224 AC_MSG_RESULT($enableval)
1231 dnl ---------------------------------------------------------------------------
1232 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1233 dnl ----------------
1234 dnl Combine no-leak checks with the libraries or tools that are used for the
1236 AC_DEFUN([CF_DISABLE_LEAKS],[
1238 AC_REQUIRE([CF_WITH_DMALLOC])
1239 AC_REQUIRE([CF_WITH_DBMALLOC])
1240 AC_REQUIRE([CF_WITH_VALGRIND])
1242 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1243 AC_ARG_ENABLE(leaks,
1244 [ --disable-leaks test: free permanent memory, analyze leaks],
1245 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1246 : ${with_no_leaks:=no})
1247 AC_MSG_RESULT($with_no_leaks)
1249 if test "$with_no_leaks" = yes ; then
1250 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1251 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1254 dnl ---------------------------------------------------------------------------
1255 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1256 dnl ---------------------
1257 dnl The rpath-hack makes it simpler to build programs, particularly with the
1258 dnl *BSD ports which may have essential libraries in unusual places. But it
1259 dnl can interfere with building an executable for the base system. Use this
1260 dnl option in that case.
1261 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1263 AC_MSG_CHECKING(if rpath-hack should be disabled)
1264 CF_ARG_DISABLE(rpath-hack,
1265 [ --disable-rpath-hack don't add rpath options for additional libraries],
1266 [cf_disable_rpath_hack=yes],
1267 [cf_disable_rpath_hack=no])
1268 AC_MSG_RESULT($cf_disable_rpath_hack)
1269 if test "$cf_disable_rpath_hack" = no ; then
1273 dnl ---------------------------------------------------------------------------
1274 dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11
1275 dnl ----------------------
1276 dnl On a few platforms, the compiler and/or loader nags with untruthful
1277 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1278 dnl and implying that most uses of the recommended alternatives are correct.
1280 dnl Factually speaking, no one has actually counted the number of uses of these
1281 dnl functions versus the total of incorrect uses. Samples of a few thousand
1282 dnl instances are meaningless compared to the hundreds of millions of lines of
1283 dnl existing C code.
1285 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1286 dnl platforms, in implementations of varying quality. Likewise, snprintf is
1287 dnl standard - but evolved through phases, and older implementations are likely
1288 dnl to yield surprising results, as documented in manpages on various systems.
1289 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1291 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1292 AC_ARG_ENABLE(string-hacks,
1293 [ --enable-string-hacks work around bogus compiler/loader warnings],
1294 [with_string_hacks=$enableval],
1295 [with_string_hacks=no])
1296 AC_MSG_RESULT($with_string_hacks)
1298 if test "x$with_string_hacks" = "xyes"; then
1299 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1300 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1301 AC_CHECK_FUNC(strlcat,[
1302 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1304 AC_CHECK_LIB(bsd,strlcat,[
1306 AC_CHECK_HEADERS(bsd/string.h)
1307 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1310 AC_CHECK_FUNCS( strlcpy snprintf )
1313 dnl ---------------------------------------------------------------------------
1314 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
1315 dnl ------------------
1316 dnl Configure-option to enable gcc warnings
1318 dnl $1 = extra options to add, if supported
1319 dnl $2 = option for checking attributes. By default, this is done when
1320 dnl warnings are enabled. For other values:
1321 dnl yes: always do this, e.g., to use in generated library-headers
1322 dnl no: never do this
1323 AC_DEFUN([CF_ENABLE_WARNINGS],[
1324 if ( test "$GCC" = yes || test "$GXX" = yes )
1326 CF_FIX_WARNINGS(CFLAGS)
1327 CF_FIX_WARNINGS(CPPFLAGS)
1328 CF_FIX_WARNINGS(LDFLAGS)
1329 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1330 CF_ARG_ENABLE(warnings,
1331 [ --enable-warnings test: turn on gcc compiler warnings],
1332 [with_warnings=yes],
1334 AC_MSG_RESULT($with_warnings)
1335 if test "$with_warnings" = "yes"
1337 ifelse($2,,[CF_GCC_ATTRIBUTES])
1340 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1343 dnl ---------------------------------------------------------------------------
1344 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
1346 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1347 dnl prefer a standard location, and use -L options only if we do not find the
1348 dnl library in the standard library location(s).
1349 dnl $1 = library name
1350 dnl $2 = library class, usually the same as library name
1352 dnl $4 = code fragment to compile/link
1353 dnl $5 = corresponding function-name
1354 dnl $6 = flag, nonnull if failure should not cause an error-exit
1356 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1357 dnl to use a -L option.
1358 AC_DEFUN([CF_FIND_LIBRARY],
1360 eval 'cf_cv_have_lib_'$1'=no'
1363 eval 'cf_cv_have_lib_'$1'=yes',[
1364 cf_save_LIBS="$LIBS"
1365 AC_MSG_CHECKING(for $5 in -l$1)
1367 AC_TRY_LINK([$3],[$4],
1369 eval 'cf_cv_have_lib_'$1'=yes'
1372 CF_LIBRARY_PATH(cf_search,$2)
1373 for cf_libdir in $cf_search
1375 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1376 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1377 AC_TRY_LINK([$3],[$4],
1379 eval 'cf_cv_have_lib_'$1'=yes'
1382 LIBS="$cf_save_LIBS"])
1386 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
1388 if test $cf_found_library = no ; then
1389 AC_MSG_ERROR(Cannot link $1 library)
1393 dnl ---------------------------------------------------------------------------
1394 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
1396 dnl Find a library (specifically the linkage used in the code fragment),
1397 dnl searching for it if it is not already in the library path.
1398 dnl See also CF_ADD_SEARCHPATH.
1400 dnl Parameters (4-on are optional):
1401 dnl $1 = headers for library entrypoint
1402 dnl $2 = code fragment for library entrypoint
1403 dnl $3 = the library name without the "-l" option or ".so" suffix.
1404 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1405 dnl $5 = action to perform if not successful
1406 dnl $6 = module name, if not the same as the library name
1407 dnl $7 = extra libraries
1409 dnl Sets these variables:
1410 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1411 dnl $cf_cv_header_path_$3 - include-directory if needed
1412 dnl $cf_cv_library_path_$3 - library-directory if needed
1413 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1414 AC_DEFUN([CF_FIND_LINKAGE],[
1416 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1417 # will be set on completion of the AC_TRY_LINK below.
1418 cf_cv_header_path_$3=
1419 cf_cv_library_path_$3=
1421 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1423 cf_save_LIBS="$LIBS"
1425 AC_TRY_LINK([$1],[$2],[
1426 cf_cv_find_linkage_$3=yes
1427 cf_cv_header_path_$3=/usr/include
1428 cf_cv_library_path_$3=/usr/lib
1431 LIBS="-l$3 $7 $cf_save_LIBS"
1433 AC_TRY_LINK([$1],[$2],[
1434 cf_cv_find_linkage_$3=yes
1435 cf_cv_header_path_$3=/usr/include
1436 cf_cv_library_path_$3=/usr/lib
1437 cf_cv_library_file_$3="-l$3"
1439 cf_cv_find_linkage_$3=no
1440 LIBS="$cf_save_LIBS"
1442 CF_VERBOSE(find linkage for $3 library)
1443 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1445 cf_save_CPPFLAGS="$CPPFLAGS"
1446 cf_test_CPPFLAGS="$CPPFLAGS"
1448 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1449 for cf_cv_header_path_$3 in $cf_search
1451 if test -d $cf_cv_header_path_$3 ; then
1452 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1453 CPPFLAGS="$cf_save_CPPFLAGS"
1454 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1455 AC_TRY_COMPILE([$1],[$2],[
1456 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1457 cf_cv_find_linkage_$3=maybe
1458 cf_test_CPPFLAGS="$CPPFLAGS"
1460 CPPFLAGS="$cf_save_CPPFLAGS"
1465 if test "$cf_cv_find_linkage_$3" = maybe ; then
1467 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1469 cf_save_LIBS="$LIBS"
1470 cf_save_LDFLAGS="$LDFLAGS"
1473 CPPFLAGS="$cf_test_CPPFLAGS"
1474 LIBS="-l$3 $7 $cf_save_LIBS"
1475 AC_TRY_LINK([$1],[$2],[
1476 CF_VERBOSE(... found $3 library in system)
1477 cf_cv_find_linkage_$3=yes])
1478 CPPFLAGS="$cf_save_CPPFLAGS"
1479 LIBS="$cf_save_LIBS"
1482 if test "$cf_cv_find_linkage_$3" != yes ; then
1483 CF_LIBRARY_PATH(cf_search,$3)
1484 for cf_cv_library_path_$3 in $cf_search
1486 if test -d $cf_cv_library_path_$3 ; then
1487 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1488 CPPFLAGS="$cf_test_CPPFLAGS"
1489 LIBS="-l$3 $7 $cf_save_LIBS"
1490 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1491 AC_TRY_LINK([$1],[$2],[
1492 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1493 cf_cv_find_linkage_$3=yes
1494 cf_cv_library_file_$3="-l$3"
1496 CPPFLAGS="$cf_save_CPPFLAGS"
1497 LIBS="$cf_save_LIBS"
1498 LDFLAGS="$cf_save_LDFLAGS"
1502 CPPFLAGS="$cf_save_CPPFLAGS"
1503 LDFLAGS="$cf_save_LDFLAGS"
1507 cf_cv_find_linkage_$3=no
1512 LIBS="$cf_save_LIBS"
1514 if test "$cf_cv_find_linkage_$3" = yes ; then
1516 CF_ADD_INCDIR($cf_cv_header_path_$3)
1517 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1521 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1524 dnl ---------------------------------------------------------------------------
1525 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
1527 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1528 dnl "-Werror" flags can interfere with configure-checks. Those go into
1531 dnl $1 = variable name to repair
1532 define([CF_FIX_WARNINGS],[
1533 if ( test "$GCC" = yes || test "$GXX" = yes )
1537 CF_VERBOSE(repairing $1: [$]$1)
1539 for cf_temp_scan in [$]$1
1541 case "x$cf_temp_scan" in
1543 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
1546 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
1551 CF_VERBOSE(... fixed [$]$1)
1552 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1556 AC_SUBST(EXTRA_CFLAGS)
1558 dnl ---------------------------------------------------------------------------
1559 dnl CF_FUNC_CURSES_VERSION version: 7 updated: 2017/05/10 18:31:29
1560 dnl ----------------------
1561 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1562 dnl It's a character string "SVR4", not documented.
1563 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1565 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1567 #include <${cf_cv_ncurses_header:-curses.h}>
1571 sprintf(temp, "%s\n", curses_version());
1572 ${cf_cv_main_return:-return}(0);
1574 ,[cf_cv_func_curses_version=yes]
1575 ,[cf_cv_func_curses_version=no]
1576 ,[cf_cv_func_curses_version=unknown])
1578 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1580 dnl ---------------------------------------------------------------------------
1581 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
1583 dnl Check for openpty() function, along with <pty.h> header. It may need the
1584 dnl "util" library as well.
1585 AC_DEFUN([CF_FUNC_OPENPTY],
1587 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1588 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1589 cf_save_LIBS="$LIBS"
1590 test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
1591 for cf_header in pty.h libutil.h util.h
1594 #include <$cf_header>
1596 int x = openpty((int *)0, (int *)0, (char *)0,
1597 (struct termios *)0, (struct winsize *)0);
1599 cf_cv_func_openpty=$cf_header
1602 cf_cv_func_openpty=no
1605 LIBS="$cf_save_LIBS"
1608 dnl ---------------------------------------------------------------------------
1609 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
1610 dnl -----------------
1611 dnl Test for availability of useful gcc __attribute__ directives to quiet
1612 dnl compiler warnings. Though useful, not all are supported -- and contrary
1613 dnl to documentation, unrecognized directives cause older compilers to barf.
1614 AC_DEFUN([CF_GCC_ATTRIBUTES],
1616 if ( test "$GCC" = yes || test "$GXX" = yes )
1618 cat > conftest.i <<EOF
1620 #define GCC_PRINTF 0
1625 #ifndef GCC_NORETURN
1626 #define GCC_NORETURN /* nothing */
1629 #define GCC_UNUSED /* nothing */
1632 if test "$GCC" = yes
1634 AC_CHECKING([for $CC __attribute__ directives])
1635 cat > conftest.$ac_ext <<EOF
1636 #line __oline__ "${as_me:-configure}"
1637 #include "confdefs.h"
1638 #include "conftest.h"
1639 #include "conftest.i"
1641 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1643 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1646 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1648 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1650 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1651 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1652 extern void foo(void) GCC_NORETURN;
1653 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1655 cf_printf_attribute=no
1656 cf_scanf_attribute=no
1657 for cf_attribute in scanf printf unused noreturn
1659 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1660 cf_directive="__attribute__(($cf_attribute))"
1661 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1663 case $cf_attribute in
1665 cf_printf_attribute=yes
1666 cat >conftest.h <<EOF
1667 #define GCC_$cf_ATTRIBUTE 1
1671 cf_scanf_attribute=yes
1672 cat >conftest.h <<EOF
1673 #define GCC_$cf_ATTRIBUTE 1
1677 cat >conftest.h <<EOF
1678 #define GCC_$cf_ATTRIBUTE $cf_directive
1683 if AC_TRY_EVAL(ac_compile); then
1684 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1685 cat conftest.h >>confdefs.h
1686 case $cf_attribute in
1688 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1691 cf_value='/* nothing */'
1692 if test "$cf_printf_attribute" != no ; then
1693 cf_value='__attribute__((format(printf,fmt,var)))'
1694 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1696 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1699 cf_value='/* nothing */'
1700 if test "$cf_scanf_attribute" != no ; then
1701 cf_value='__attribute__((format(scanf,fmt,var)))'
1702 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1704 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1707 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1713 fgrep define conftest.i >>confdefs.h
1718 dnl ---------------------------------------------------------------------------
1719 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1721 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1722 dnl compatible), attempt to determine if icc/clang is actually used.
1723 AC_DEFUN([CF_GCC_VERSION],[
1724 AC_REQUIRE([AC_PROG_CC])
1726 if test "$GCC" = yes ; then
1727 AC_MSG_CHECKING(version of $CC)
1728 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.]].*//'`"
1729 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1730 AC_MSG_RESULT($GCC_VERSION)
1732 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1733 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1735 dnl ---------------------------------------------------------------------------
1736 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
1738 dnl Check if the compiler supports useful warning options. There's a few that
1739 dnl we don't use, simply because they're too noisy:
1741 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1742 dnl -Winline (usually not worthwhile)
1743 dnl -Wredundant-decls (system headers make this too noisy)
1744 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1745 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1746 dnl is enabled for ncurses using "--enable-const".
1750 dnl $1 is an optional list of gcc warning flags that a particular
1751 dnl application might want to use, e.g., "no-unused" for
1754 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1756 AC_DEFUN([CF_GCC_WARNINGS],
1758 AC_REQUIRE([CF_GCC_VERSION])
1759 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1760 cat > conftest.$ac_ext <<EOF
1761 #line __oline__ "${as_me:-configure}"
1762 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1764 if test "$INTEL_COMPILER" = yes
1766 # The "-wdXXX" options suppress warnings:
1767 # remark #1419: external declaration in primary source file
1768 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1769 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1770 # remark #193: zero used for undefined preprocessing identifier
1771 # remark #593: variable "curs_sb_left_arrow" was set but never used
1772 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1773 # remark #869: parameter "tw" was never referenced
1774 # remark #981: operands are evaluated in unspecified order
1775 # warning #279: controlling expression is constant
1777 AC_CHECKING([for $CC warning options])
1778 cf_save_CFLAGS="$CFLAGS"
1779 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1791 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1792 if AC_TRY_EVAL(ac_compile); then
1793 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1794 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1797 CFLAGS="$cf_save_CFLAGS"
1798 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1800 AC_CHECKING([for $CC warning options])
1801 cf_save_CFLAGS="$CFLAGS"
1803 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1804 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1805 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1806 for cf_opt in W Wall \
1807 Wbad-function-cast \
1810 Wdeclaration-after-statement \
1813 Wmissing-declarations \
1814 Wmissing-prototypes \
1818 Wstrict-prototypes \
1819 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1821 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1822 if AC_TRY_EVAL(ac_compile); then
1823 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1826 case $GCC_VERSION in
1828 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1833 case $GCC_VERSION in
1835 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1840 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1843 CFLAGS="$cf_save_CFLAGS"
1847 AC_SUBST(EXTRA_CFLAGS)
1849 dnl ---------------------------------------------------------------------------
1850 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
1851 dnl ----------------
1852 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1853 dnl unistd.h or (nonstandard) in getopt.h
1854 AC_DEFUN([CF_GETOPT_HEADER],
1856 AC_HAVE_HEADERS(unistd.h getopt.h)
1857 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1858 cf_cv_getopt_header=none
1859 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1862 #include <$cf_header>],
1863 [int x = optind; char *y = optarg],
1864 [cf_cv_getopt_header=$cf_header
1868 if test $cf_cv_getopt_header != none ; then
1869 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1871 if test $cf_cv_getopt_header = getopt.h ; then
1872 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1875 dnl ---------------------------------------------------------------------------
1876 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1878 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1879 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1880 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1881 dnl since it is interwoven with GNU extensions.
1883 dnl Well, yes we could work around it...
1886 dnl $1 is the nominal value for _XOPEN_SOURCE
1887 AC_DEFUN([CF_GNU_SOURCE],
1889 cf_gnu_xopen_source=ifelse($1,,500,$1)
1891 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1892 AC_TRY_COMPILE([#include <sys/types.h>],[
1893 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1895 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1898 # error not GNU C library
1900 [cf_cv_gnu_library=yes],
1901 [cf_cv_gnu_library=no])
1904 if test x$cf_cv_gnu_library = xyes; then
1906 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1907 # was changed to help a little. newlib incorporated the change about 4
1909 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1911 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1912 AC_TRY_COMPILE([#include <sys/types.h>],[
1913 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1915 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1918 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1920 [cf_cv_gnu_library_219=yes],
1921 [cf_cv_gnu_library_219=no])
1925 if test "x$cf_cv_gnu_library_219" = xyes; then
1927 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1928 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1931 #include <sys/types.h>
1933 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1936 # error GNU C library is too old
1938 [cf_cv_gnu_dftsrc_219=yes],
1939 [cf_cv_gnu_dftsrc_219=no])
1941 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1943 cf_cv_gnu_dftsrc_219=maybe
1946 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1948 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1949 AC_TRY_COMPILE([#include <sys/types.h>],[
1950 #ifndef _XOPEN_SOURCE
1951 #error expected _XOPEN_SOURCE to be defined
1953 [cf_cv_gnu_source=no],
1954 [cf_save="$CPPFLAGS"
1955 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1956 AC_TRY_COMPILE([#include <sys/types.h>],[
1957 #ifdef _XOPEN_SOURCE
1958 #error expected _XOPEN_SOURCE to be undefined
1960 [cf_cv_gnu_source=no],
1961 [cf_cv_gnu_source=yes])
1966 if test "$cf_cv_gnu_source" = yes
1968 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1969 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1970 AC_TRY_COMPILE([#include <sys/types.h>],[
1971 #ifdef _DEFAULT_SOURCE
1972 #error expected _DEFAULT_SOURCE to be undefined
1974 [cf_cv_default_source=no],
1975 [cf_cv_default_source=yes])
1977 if test "$cf_cv_default_source" = yes
1979 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1986 dnl ---------------------------------------------------------------------------
1987 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1989 dnl Construct a search-list of directories for a nonstandard header-file
1992 dnl $1 = the variable to return as result
1993 dnl $2 = the package name
1994 AC_DEFUN([CF_HEADER_PATH],
1998 # collect the current set of include-directories from compiler flags
1999 cf_header_path_list=""
2000 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2001 for cf_header_path in $CPPFLAGS $CFLAGS
2003 case $cf_header_path in
2005 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2006 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2007 cf_header_path_list="$cf_header_path_list [$]$1"
2013 # add the variations for the package we are looking for
2014 CF_SUBDIR_PATH($1,$2,include)
2016 test "$includedir" != NONE && \
2017 test "$includedir" != "/usr/include" && \
2018 test -d "$includedir" && {
2019 test -d $includedir && $1="[$]$1 $includedir"
2020 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
2023 test "$oldincludedir" != NONE && \
2024 test "$oldincludedir" != "/usr/include" && \
2025 test -d "$oldincludedir" && {
2026 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
2027 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
2030 $1="[$]$1 $cf_header_path_list"
2032 dnl ---------------------------------------------------------------------------
2033 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2035 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2036 AC_DEFUN([CF_HELP_MESSAGE],
2037 [CF_ACVERSION_CHECK(2.53,[],[
2038 AC_DIVERT_HELP($1)])dnl
2040 dnl ---------------------------------------------------------------------------
2041 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2042 dnl -----------------
2043 dnl If we do not have a given script, look for it in the parent directory.
2044 AC_DEFUN([CF_INHERIT_SCRIPT],
2046 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2048 dnl ---------------------------------------------------------------------------
2049 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2051 dnl prompt for/fill-in useful install-program options
2052 AC_DEFUN([CF_INSTALL_OPTS],
2058 dnl ---------------------------------------------------------------------------
2059 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
2060 dnl ----------------
2061 dnl Almost all "install" programs default to the current user's ownership.
2062 dnl Almost - MINIX is an exception.
2063 AC_DEFUN([CF_INSTALL_OPT_O],
2065 AC_MSG_CHECKING(if install needs to be told about ownership)
2066 case `$ac_config_guess` in
2075 AC_MSG_RESULT($with_install_o)
2076 if test "x$with_install_o" = xyes
2078 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'`
2083 AC_SUBST(INSTALL_OPT_O)
2085 dnl ---------------------------------------------------------------------------
2086 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
2087 dnl ----------------
2088 dnl Some install-programs accept a "-p" option to preserve file modification
2089 dnl timestamps. That can be useful as an install option, as well as a way to
2090 dnl avoid the need for ranlib after copying a static archive.
2091 AC_DEFUN([CF_INSTALL_OPT_P],
2093 : ${INSTALL:=install}
2094 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2099 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2101 if test -f conftest.out/conftest.in
2103 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2104 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2105 if test -s conftest.err
2120 dnl ---------------------------------------------------------------------------
2121 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
2122 dnl ----------------
2123 dnl By default, we should strip executables which are installed, but leave the
2124 dnl ability to suppress that for unit-testing.
2125 AC_DEFUN([CF_INSTALL_OPT_S],
2127 AC_MSG_CHECKING(if you want to install stripped executables)
2128 CF_ARG_DISABLE(stripping,
2129 [ --disable-stripping do not strip (debug info) installed executables],
2130 [with_stripping=no],
2131 [with_stripping=yes])
2132 AC_MSG_RESULT($with_stripping)
2134 if test "$with_stripping" = yes
2140 AC_SUBST(INSTALL_OPT_S)
2142 dnl ---------------------------------------------------------------------------
2143 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
2144 dnl -----------------
2145 dnl Check if the given compiler is really the Intel compiler for Linux. It
2146 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2147 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2149 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2150 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2151 dnl the wrappers for gcc and g++ warnings.
2153 dnl $1 = GCC (default) or GXX
2154 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2155 dnl $3 = CFLAGS (default) or CXXFLAGS
2156 AC_DEFUN([CF_INTEL_COMPILER],[
2157 AC_REQUIRE([AC_CANONICAL_HOST])
2158 ifelse([$2],,INTEL_COMPILER,[$2])=no
2160 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2163 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2164 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2165 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2167 #ifdef __INTEL_COMPILER
2171 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2172 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2174 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2175 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2180 dnl ---------------------------------------------------------------------------
2181 dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
2183 dnl For the given system and compiler, find the compiler flags to pass to the
2184 dnl loader to use the "rpath" feature.
2185 AC_DEFUN([CF_LD_RPATH_OPT],
2187 AC_REQUIRE([CF_CHECK_CACHE])
2190 if test "x$cf_cv_enable_rpath" != xno
2192 AC_MSG_CHECKING(for an rpath option)
2193 case $cf_cv_system_name in
2195 if test "$GCC" = yes; then
2196 LD_RPATH_OPT="-Wl,-rpath,"
2198 LD_RPATH_OPT="-rpath "
2201 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2202 LD_RPATH_OPT="-Wl,-rpath,"
2204 (openbsd[[2-9]].*|mirbsd*)
2205 LD_RPATH_OPT="-Wl,-rpath,"
2208 LD_RPATH_OPT="-rpath "
2211 LD_RPATH_OPT="-Wl,-rpath,"
2214 LD_RPATH_OPT="-rpath "
2222 AC_MSG_RESULT($LD_RPATH_OPT)
2224 case "x$LD_RPATH_OPT" in
2226 AC_MSG_CHECKING(if we need a space after rpath option)
2227 cf_save_LIBS="$LIBS"
2228 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2229 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2230 LIBS="$cf_save_LIBS"
2231 AC_MSG_RESULT($cf_rpath_space)
2232 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2237 dnl ---------------------------------------------------------------------------
2238 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
2240 dnl Construct a search-list of directories for a nonstandard library-file
2243 dnl $1 = the variable to return as result
2244 dnl $2 = the package name
2245 AC_DEFUN([CF_LIBRARY_PATH],
2248 cf_library_path_list=""
2249 if test -n "${LDFLAGS}${LIBS}" ; then
2250 for cf_library_path in $LDFLAGS $LIBS
2252 case $cf_library_path in
2254 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2255 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2256 cf_library_path_list="$cf_library_path_list [$]$1"
2262 CF_SUBDIR_PATH($1,$2,lib)
2264 $1="$cf_library_path_list [$]$1"
2266 dnl ---------------------------------------------------------------------------
2267 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2269 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2270 dnl a monocase filesystem.
2271 AC_DEFUN([CF_MAKE_TAGS],[
2272 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2274 AC_CHECK_PROGS(CTAGS, exctags ctags)
2275 AC_CHECK_PROGS(ETAGS, exetags etags)
2277 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2279 if test "$cf_cv_mixedcase" = yes ; then
2280 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2285 if test "$MAKE_UPPER_TAGS" = yes ; then
2291 if test "$MAKE_LOWER_TAGS" = yes ; then
2300 AC_SUBST(MAKE_UPPER_TAGS)
2301 AC_SUBST(MAKE_LOWER_TAGS)
2303 dnl ---------------------------------------------------------------------------
2304 dnl CF_MATH_LIB version: 9 updated: 2017/01/21 11:06:25
2306 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
2307 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
2308 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2309 AC_DEFUN([CF_MATH_LIB],
2311 AC_CACHE_CHECK(if -lm needed for math functions,
2318 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
2319 [cf_cv_need_libm=no],
2320 [cf_cv_need_libm=yes])])
2321 if test "$cf_cv_need_libm" = yes
2328 dnl ---------------------------------------------------------------------------
2329 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
2330 dnl ----------------------
2331 dnl Check if the file-system supports mixed-case filenames. If we're able to
2332 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2333 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2335 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2336 if test "$cross_compiling" = yes ; then
2337 case $target_alias in
2338 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
2346 rm -f conftest CONFTEST
2348 if test -f CONFTEST ; then
2353 rm -f conftest CONFTEST
2356 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2358 dnl ---------------------------------------------------------------------------
2359 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2361 dnl Write a debug message to config.log, along with the line number in the
2362 dnl configure script.
2363 AC_DEFUN([CF_MSG_LOG],[
2364 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2366 dnl ---------------------------------------------------------------------------
2367 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2368 dnl -------------------
2369 dnl Check if we can compile with ncurses' header file
2370 dnl $1 is the cache variable to set
2371 dnl $2 is the header-file to include
2372 dnl $3 is the root name (ncurses or ncursesw)
2373 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2375 ]ifelse($3,ncursesw,[
2376 #define _XOPEN_SOURCE_EXTENDED
2377 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2378 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2381 #ifdef NCURSES_VERSION
2382 ]ifelse($3,ncursesw,[
2387 printf("%s\n", NCURSES_VERSION);
2399 dnl ---------------------------------------------------------------------------
2400 dnl CF_NCURSES_CONFIG version: 23 updated: 2020/02/27 05:21:59
2401 dnl -----------------
2402 dnl Tie together the configure-script macros for ncurses, preferring these in
2404 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2405 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2406 dnl c) just plain libraries
2408 dnl $1 is the root library name (default: "ncurses")
2409 AC_DEFUN([CF_NCURSES_CONFIG],[
2410 AC_REQUIRE([CF_PKG_CONFIG])
2411 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2412 cf_have_ncuconfig=no
2414 if test "x${PKG_CONFIG:=none}" != xnone; then
2415 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2416 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2419 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2420 cf_have_ncuconfig=unknown
2422 cf_save_CFLAGS="$CFLAGS"
2423 cf_save_CPPFLAGS="$CPPFLAGS"
2424 cf_save_LIBS="$LIBS"
2426 cf_pkg_cflags=`$PKG_CONFIG --cflags $cf_ncuconfig_root`
2427 cf_pkg_libs=`$PKG_CONFIG --libs $cf_ncuconfig_root`
2429 # while -W for passing linker flags is prevalent, it is not "standard".
2430 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2431 # incompatible _and_ non-standard -W option which gives an error. Work
2432 # around that pitfall.
2433 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2435 CF_ADD_CFLAGS($cf_pkg_cflags)
2436 CF_ADD_LIBS($cf_pkg_libs)
2438 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2439 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2440 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2442 { char *xx = curses_version(); return (xx == 0); }],
2443 [cf_test_ncuconfig=yes],
2444 [cf_test_ncuconfig=no],
2445 [cf_test_ncuconfig=maybe])],
2446 [cf_test_ncuconfig=no])
2448 CFLAGS="$cf_save_CFLAGS"
2449 CPPFLAGS="$cf_save_CPPFLAGS"
2450 LIBS="$cf_save_LIBS"
2452 if test "x$cf_test_ncuconfig" != xyes; then
2453 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2454 cf_pkg_cflags="$cf_temp"
2455 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2456 cf_pkg_libs="$cf_temp"
2461 CF_ADD_CFLAGS($cf_pkg_cflags)
2462 CF_ADD_LIBS($cf_pkg_libs)
2464 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2465 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2466 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2468 { char *xx = curses_version(); return (xx == 0); }],
2469 [cf_have_ncuconfig=yes],
2470 [cf_have_ncuconfig=no],
2471 [cf_have_ncuconfig=maybe])],
2472 [cf_have_ncuconfig=no])
2473 AC_MSG_RESULT($cf_have_ncuconfig)
2474 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2475 if test "$cf_have_ncuconfig" != "yes"
2477 CPPFLAGS="$cf_save_CPPFLAGS"
2478 LIBS="$cf_save_LIBS"
2479 NCURSES_CONFIG_PKG=none
2481 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2482 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2488 NCURSES_CONFIG_PKG=none
2491 NCURSES_CONFIG_PKG=none
2494 if test "x$cf_have_ncuconfig" = "xno"; then
2495 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2497 CF_ACVERSION_CHECK(2.52,
2498 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2499 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2501 if test "$NCURSES_CONFIG" != none ; then
2503 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2504 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2506 # even with config script, some packages use no-override for curses.h
2507 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2509 dnl like CF_NCURSES_CPPFLAGS
2510 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2512 dnl like CF_NCURSES_LIBS
2513 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2514 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2516 dnl like CF_NCURSES_VERSION
2517 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2521 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2522 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2529 dnl ---------------------------------------------------------------------------
2530 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2531 dnl -------------------
2532 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2533 dnl the CPPFLAGS variable so we can include its header.
2535 dnl The header files may be installed as either curses.h, or ncurses.h (would
2536 dnl be obsolete, except that some packagers prefer this name to distinguish it
2537 dnl from a "native" curses implementation). If not installed for overwrite,
2538 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2539 dnl /usr/include/ncurses), but someone may have installed overwriting the
2540 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2541 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2544 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2545 dnl is already in the include-path, don't even bother with this, since we cannot
2546 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2548 dnl The optional parameter gives the root name of the library, in case it is
2549 dnl not installed as the default curses library. That is how the
2550 dnl wide-character version of ncurses is installed.
2551 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2552 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2554 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2555 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2557 test -n "$cf_cv_curses_dir" && \
2558 test "$cf_cv_curses_dir" != "no" && { \
2559 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2562 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2563 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2564 ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2565 for cf_header in $cf_header_list
2567 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2568 test "$cf_cv_ncurses_h" != no && break
2575 # some applications need this, but should check for NCURSES_VERSION
2576 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2580 dnl ---------------------------------------------------------------------------
2581 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2582 dnl --------------------
2583 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2584 dnl may provide these functions. Define the symbol if it is not defined, and
2586 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2588 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2590 #include <${cf_cv_ncurses_header:-curses.h}>],
2592 int x = NCURSES_EXT_FUNCS
2593 ],[cf_cv_ncurses_ext_funcs=defined],[
2595 #include <${cf_cv_ncurses_header:-curses.h}>],
2597 (void) assume_default_colors (0, 0);
2598 (void) curses_version ();
2599 (void) define_key (0, 0);
2600 (void) is_term_resized (0, 0);
2601 (void) key_defined (0);
2602 (void) keybound (0, 0);
2603 (void) keyok (0, 0);
2604 (void) resize_term (0, 0);
2605 (void) resizeterm (0, 0);
2606 (void) use_default_colors ();
2607 (void) use_extended_names (0);
2608 (void) wresize (0, 0, 0);],
2609 [cf_cv_ncurses_ext_funcs=yes],
2610 [cf_cv_ncurses_ext_funcs=no])
2613 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2615 dnl ---------------------------------------------------------------------------
2616 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2617 dnl -----------------
2618 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2619 dnl variations of ncurses' installs.
2621 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2622 AC_DEFUN([CF_NCURSES_HEADER],[
2624 if test "$cf_cv_ncurses_h" != no ; then
2625 cf_cv_ncurses_header=$cf_cv_ncurses_h
2628 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2629 test -n "$verbose" && echo
2630 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2631 test -n "$verbose" && echo search path $cf_search
2632 cf_save2_CPPFLAGS="$CPPFLAGS"
2633 for cf_incdir in $cf_search
2635 CF_ADD_INCDIR($cf_incdir)
2640 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2641 if test "$cf_cv_ncurses_h2" != no ; then
2642 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2643 test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG
2646 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2648 CPPFLAGS="$cf_save2_CPPFLAGS"
2649 test "$cf_cv_ncurses_h2" != no && break
2651 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2654 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2655 cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2656 if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2657 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2659 CF_ADD_INCDIR($cf_1st_incdir)
2663 # Set definitions to allow ifdef'ing for ncurses.h
2665 case $cf_cv_ncurses_header in
2667 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2671 case $cf_cv_ncurses_header in
2672 (ncurses/curses.h|ncurses/ncurses.h)
2673 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2675 (ncursesw/curses.h|ncursesw/ncurses.h)
2676 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2681 dnl ---------------------------------------------------------------------------
2682 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2684 dnl Look for the ncurses library. This is a little complicated on Linux,
2685 dnl because it may be linked with the gpm (general purpose mouse) library.
2686 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2687 dnl unusable with ncurses. However, we don't want to link with gpm unless
2688 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2689 dnl and the linker will record a dependency.
2691 dnl The optional parameter gives the root name of the library, in case it is
2692 dnl not installed as the default curses library. That is how the
2693 dnl wide-character version of ncurses is installed.
2694 AC_DEFUN([CF_NCURSES_LIBS],
2695 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2697 cf_nculib_root=ifelse($1,,ncurses,$1)
2698 # This works, except for the special case where we find gpm, but
2699 # ncurses is in a nonstandard location via $LIBS, and we really want
2702 cf_ncurses_SAVE="$LIBS"
2703 AC_CHECK_LIB(gpm,Gpm_Open,
2704 [AC_CHECK_LIB(gpm,initscr,
2705 [LIBS="$cf_ncurses_SAVE"],
2706 [cf_ncurses_LIBS="-lgpm"])])
2710 # This is only necessary if you are linking against an obsolete
2711 # version of ncurses (but it should do no harm, since it's static).
2712 if test "$cf_nculib_root" = ncurses ; then
2713 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2718 CF_ADD_LIBS($cf_ncurses_LIBS)
2720 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2722 CF_ADD_LIBS(-l$cf_nculib_root)
2724 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2725 [#include <${cf_cv_ncurses_header:-curses.h}>],
2730 if test -n "$cf_ncurses_LIBS" ; then
2731 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2732 cf_ncurses_SAVE="$LIBS"
2733 for p in $cf_ncurses_LIBS ; do
2734 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2735 if test "$q" != "$LIBS" ; then
2739 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2740 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2741 [AC_MSG_RESULT(yes)],
2743 LIBS="$cf_ncurses_SAVE"])
2746 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2747 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2749 dnl ---------------------------------------------------------------------------
2750 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2751 dnl -------------------
2752 dnl Use this followup check to ensure that we link with pthreads if ncurses
2754 AC_DEFUN([CF_NCURSES_PTHREADS],[
2755 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2756 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2757 cf_cv_ncurses_pthreads=yes,
2758 cf_cv_ncurses_pthreads=no)
2759 if test "$cf_cv_ncurses_pthreads" = yes
2761 CF_ADD_LIBS(-lpthread)
2764 dnl ---------------------------------------------------------------------------
2765 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
2766 dnl ------------------
2767 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2768 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
2769 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2770 AC_DEFUN([CF_NCURSES_VERSION],
2772 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2773 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2774 cf_cv_ncurses_version=no
2778 #include <${cf_cv_ncurses_header:-curses.h}>
2782 FILE *fp = fopen("$cf_tempfile", "w");
2783 #ifdef NCURSES_VERSION
2784 # ifdef NCURSES_VERSION_PATCH
2785 fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2787 fprintf(fp, "%s\n", NCURSES_VERSION);
2791 fprintf(fp, "old\n");
2796 ${cf_cv_main_return:-return}(0);
2798 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2800 # This will not work if the preprocessor splits the line after the
2801 # Autoconf token. The 'unproto' program does that.
2802 cat > conftest.$ac_ext <<EOF
2803 #include <${cf_cv_ncurses_header:-curses.h}>
2805 #ifdef NCURSES_VERSION
2806 Autoconf NCURSES_VERSION
2814 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2816 if test -f conftest.out ; then
2817 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2818 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2824 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2826 dnl ---------------------------------------------------------------------------
2827 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2828 dnl ----------------------
2829 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2830 dnl wrapped with a function to help with concurrency control.
2831 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2833 AC_MSG_CHECKING(for ncurses wrap-prefix)
2834 AC_ARG_WITH(ncurses-wrap-prefix,
2835 [ --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2836 [NCURSES_WRAP_PREFIX=$withval],
2837 [NCURSES_WRAP_PREFIX=_nc_])
2838 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2840 AC_SUBST(NCURSES_WRAP_PREFIX)
2842 dnl ---------------------------------------------------------------------------
2843 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2844 dnl ----------------
2845 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2846 dnl Some workarounds are needed in client programs to allow them to compile.
2847 AC_DEFUN([CF_NETBSD_FORM_H],[
2848 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2850 #include <${cf_cv_ncurses_header:-curses.h}>
2854 int y = current_field(form)->cursor_ypos;
2855 int x = current_field(form)->cursor_xpos;
2856 ],[cf_cv_netbsd_form_h=yes
2857 ],[cf_cv_netbsd_form_h=no])
2860 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])
2862 dnl ---------------------------------------------------------------------------
2863 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2864 dnl ----------------
2865 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2866 dnl Some workarounds are needed in client programs to allow them to compile.
2867 AC_DEFUN([CF_NETBSD_MENU_H],[
2868 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2870 #include <${cf_cv_ncurses_header:-curses.h}>
2874 int y = menu->max_item_width;
2875 ],[cf_cv_netbsd_menu_h=yes
2876 ],[cf_cv_netbsd_menu_h=no])
2879 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])
2881 dnl ---------------------------------------------------------------------------
2882 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
2883 dnl ------------------
2884 dnl see CF_WITH_NO_LEAKS
2885 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2886 AC_MSG_CHECKING(if you want to use $1 for testing)
2889 [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2892 : ${with_cflags:=-g}
2893 : ${with_no_leaks:=yes}
2896 AC_MSG_RESULT(${with_$1:-no})
2898 case .$with_cflags in
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
2913 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
2914 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2915 dnl result begins with 'NONE'. This is necessary to work around autoconf's
2916 dnl delayed evaluation of those symbols.
2917 AC_DEFUN([CF_PATH_SYNTAX],[
2918 if test "x$prefix" != xNONE; then
2919 cf_path_syntax="$prefix"
2921 cf_path_syntax="$ac_default_prefix"
2925 (.\[$]\(*\)*|.\'*\'*)
2929 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
2931 (.\[$]{*prefix}*|.\[$]{*dir}*)
2935 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2940 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
2943 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
2947 dnl ---------------------------------------------------------------------------
2948 dnl CF_PDCURSES_X11 version: 14 updated: 2018/06/20 20:23:13
2950 dnl Configure for PDCurses' X11 library
2951 AC_DEFUN([CF_PDCURSES_X11],[
2952 AC_REQUIRE([CF_X_ATHENA])
2954 CF_ACVERSION_CHECK(2.52,
2955 [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
2956 [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
2958 if test "$XCURSES_CONFIG" != none ; then
2960 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
2961 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
2963 cf_cv_lib_XCurses=yes
2967 LDFLAGS="$LDFLAGS $X_LIBS"
2968 CF_CHECK_CFLAGS($X_CFLAGS)
2969 AC_CHECK_LIB(X11,XOpenDisplay,
2970 [CF_ADD_LIBS(-lX11)],,
2971 [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
2972 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
2973 CF_ADD_LIBS(-lXCurses)
2975 #include <xcurses.h>
2976 char *XCursesProgramName = "test";
2978 [cf_cv_lib_XCurses=yes],
2979 [cf_cv_lib_XCurses=no])
2984 if test $cf_cv_lib_XCurses = yes ; then
2985 AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
2986 AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
2987 AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
2989 AC_MSG_ERROR(Cannot link with XCurses)
2992 dnl ---------------------------------------------------------------------------
2993 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
2995 dnl Check for the package-config program, unless disabled by command-line.
2996 AC_DEFUN([CF_PKG_CONFIG],
2998 AC_MSG_CHECKING(if you want to use pkg-config)
2999 AC_ARG_WITH(pkg-config,
3000 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3001 [cf_pkg_config=$withval],
3002 [cf_pkg_config=yes])
3003 AC_MSG_RESULT($cf_pkg_config)
3005 case $cf_pkg_config in
3010 CF_ACVERSION_CHECK(2.52,
3011 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3012 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3019 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3020 if test "$PKG_CONFIG" != none ; then
3021 CF_PATH_SYNTAX(PKG_CONFIG)
3022 elif test "x$cf_pkg_config" != xno ; then
3023 AC_MSG_WARN(pkg-config is not installed)
3026 AC_SUBST(PKG_CONFIG)
3028 dnl ---------------------------------------------------------------------------
3029 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3030 dnl -----------------
3031 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3033 dnl POSIX.1-1990 _POSIX_SOURCE
3034 dnl POSIX.1-1990 and _POSIX_SOURCE and
3035 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3037 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3038 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3039 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3042 dnl $1 is the nominal value for _POSIX_C_SOURCE
3043 AC_DEFUN([CF_POSIX_C_SOURCE],
3044 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3046 if test "$cf_cv_posix_visible" = no; then
3048 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3050 cf_save_CFLAGS="$CFLAGS"
3051 cf_save_CPPFLAGS="$CPPFLAGS"
3053 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3054 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3056 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3057 CF_MSG_LOG(if the symbol is already defined go no further)
3058 AC_TRY_COMPILE([#include <sys/types.h>],[
3059 #ifndef _POSIX_C_SOURCE
3062 [cf_cv_posix_c_source=no],
3063 [cf_want_posix_source=no
3064 case .$cf_POSIX_C_SOURCE in
3066 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3069 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3070 cf_want_posix_source=yes
3073 cf_want_posix_source=yes
3076 if test "$cf_want_posix_source" = yes ; then
3077 AC_TRY_COMPILE([#include <sys/types.h>],[
3078 #ifdef _POSIX_SOURCE
3081 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3083 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3084 CFLAGS="$cf_trim_CFLAGS"
3085 CPPFLAGS="$cf_trim_CPPFLAGS"
3086 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3087 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3088 AC_TRY_COMPILE([#include <sys/types.h>],[
3089 #ifndef _POSIX_C_SOURCE
3092 [cf_cv_posix_c_source=no])
3093 CFLAGS="$cf_save_CFLAGS"
3094 CPPFLAGS="$cf_save_CPPFLAGS"
3098 if test "$cf_cv_posix_c_source" != no ; then
3099 CFLAGS="$cf_trim_CFLAGS"
3100 CPPFLAGS="$cf_trim_CPPFLAGS"
3101 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3104 fi # cf_cv_posix_visible
3107 dnl ---------------------------------------------------------------------------
3108 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3109 dnl ----------------
3110 dnl POSIX documents test-macros which an application may set before any system
3111 dnl headers are included to make features available.
3113 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3114 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3115 dnl recent features visible in the system header files unless the application
3116 dnl overrides the corresponding test-macros. Doing that introduces portability
3119 dnl This macro makes a special check for the symbols used for this, to avoid a
3120 dnl conflicting definition.
3121 AC_DEFUN([CF_POSIX_VISIBLE],
3123 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3124 AC_TRY_COMPILE([#include <stdio.h>],[
3125 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3126 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3127 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3128 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3129 #error conflicting symbols found
3131 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3134 dnl ---------------------------------------------------------------------------
3135 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
3137 dnl Append definitions and rules for the given programs to the subdirectory
3138 dnl Makefiles, and the recursion rule for the top-level Makefile.
3141 dnl $1 = script to run
3142 dnl $2 = list of subdirectories
3146 AC_DEFUN([CF_PRG_RULES],
3150 if test ! -d $srcdir/$cf_dir; then
3152 elif test -f $srcdir/$cf_dir/programs; then
3153 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
3158 dnl ---------------------------------------------------------------------------
3159 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3161 dnl standard check for CC, plus followup sanity checks
3162 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3163 AC_DEFUN([CF_PROG_CC],[
3164 CF_ACVERSION_CHECK(2.53,
3165 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3166 AC_REQUIRE([AC_PROG_CC])],
3168 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3170 CF_ACVERSION_CHECK(2.52,
3175 dnl ---------------------------------------------------------------------------
3176 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
3178 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3179 dnl misc/tabset install won't work properly. Usually this happens only when
3180 dnl using the fallback mkinstalldirs script
3181 AC_DEFUN([CF_PROG_INSTALL],
3187 CF_DIRNAME(cf_dir,$INSTALL)
3188 test -z "$cf_dir" && cf_dir=.
3189 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3193 dnl ---------------------------------------------------------------------------
3194 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3196 AC_DEFUN([CF_PROG_LINT],
3198 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3200 (xcppcheck|x*/cppcheck)
3201 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3206 dnl ---------------------------------------------------------------------------
3207 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3208 dnl ----------------
3209 dnl Remove all -U and -D options that refer to the given symbol from a list
3210 dnl of C compiler options. This works around the problem that not all
3211 dnl compilers process -U and -D options from left-to-right, so a -U option
3212 dnl cannot be used to cancel the effect of a preceding -D option.
3214 dnl $1 = target (which could be the same as the source variable)
3215 dnl $2 = source (including '$')
3216 dnl $3 = symbol to remove
3217 define([CF_REMOVE_DEFINE],
3220 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3221 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3223 dnl ---------------------------------------------------------------------------
3224 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3225 dnl ---------------------
3226 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3227 dnl $1 = name of current macro
3228 define([CF_RESTORE_XTRA_FLAGS],
3230 LIBS="$cf_save_LIBS_$1"
3231 CFLAGS="$cf_save_CFLAGS_$1"
3232 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3234 dnl ---------------------------------------------------------------------------
3235 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
3237 AC_DEFUN([CF_RPATH_HACK],
3239 AC_REQUIRE([CF_LD_RPATH_OPT])
3240 AC_MSG_CHECKING(for updated LDFLAGS)
3241 if test -n "$LD_RPATH_OPT" ; then
3242 AC_MSG_RESULT(maybe)
3244 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3245 cf_rpath_list="/usr/lib /lib"
3246 if test "$cf_ldd_prog" != no
3250 AC_TRY_LINK([#include <stdio.h>],
3252 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3253 cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3255 # If we passed the link-test, but get a "not found" on a given library,
3256 # this could be due to inept reconfiguration of gcc to make it only
3257 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
3258 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3259 # /usr/local libraries.
3260 if test -n "$cf_rpath_oops"
3262 for cf_rpath_src in $cf_rpath_oops
3264 for cf_rpath_dir in \
3269 if test -f $cf_rpath_dir/lib/$cf_rpath_src
3271 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3272 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3280 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3282 CF_RPATH_HACK_2(LDFLAGS)
3283 CF_RPATH_HACK_2(LIBS)
3285 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3289 AC_SUBST(EXTRA_LDFLAGS)
3291 dnl ---------------------------------------------------------------------------
3292 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
3294 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3295 dnl EXTRA_LDFLAGS for each -L option found.
3297 dnl $cf_rpath_list contains a list of directories to ignore.
3299 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
3300 dnl but LIBS often has misplaced -L options.
3301 AC_DEFUN([CF_RPATH_HACK_2],
3303 CF_VERBOSE(...checking $1 [$]$1)
3306 for cf_rpath_src in [$]$1
3308 case $cf_rpath_src in
3311 # check if this refers to a directory which we will ignore
3313 if test -n "$cf_rpath_list"
3315 for cf_rpath_item in $cf_rpath_list
3317 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3325 if test "$cf_rpath_skip" = no
3327 # transform the option
3328 if test "$LD_RPATH_OPT" = "-R " ; then
3329 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3331 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3334 # if we have not already added this, add it now
3335 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3336 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3338 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3339 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3344 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3348 CF_VERBOSE(...checked $1 [$]$1)
3349 AC_SUBST(EXTRA_LDFLAGS)
3351 dnl ---------------------------------------------------------------------------
3352 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3353 dnl ------------------
3354 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3355 dnl and libraries which do not update those variables.
3357 dnl $1 = name of current macro
3358 define([CF_SAVE_XTRA_FLAGS],
3360 cf_save_LIBS_$1="$LIBS"
3361 cf_save_CFLAGS_$1="$CFLAGS"
3362 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3363 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3364 for cf_X_CFLAGS in $X_CFLAGS
3366 case "x$cf_X_CFLAGS" in
3368 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3371 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3376 dnl ---------------------------------------------------------------------------
3377 dnl CF_SIGWINCH version: 3 updated: 2020/03/10 18:53:47
3379 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3380 dnl programs need this test).
3382 dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
3383 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
3384 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3385 dnl break that part of the interface as well.
3386 AC_DEFUN([CF_SIGWINCH],
3388 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3390 #include <sys/types.h>
3391 #include <sys/signal.h>
3392 ],[int x = SIGWINCH; (void)x],
3393 [cf_cv_define_sigwinch=yes],
3395 #undef _XOPEN_SOURCE
3396 #undef _POSIX_SOURCE
3397 #undef _POSIX_C_SOURCE
3398 #include <sys/types.h>
3399 #include <sys/signal.h>
3400 ],[int x = SIGWINCH; (void)x],
3401 [cf_cv_define_sigwinch=maybe],
3402 [cf_cv_define_sigwinch=no])
3406 if test "$cf_cv_define_sigwinch" = maybe ; then
3407 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3408 cf_cv_fixup_sigwinch=unknown
3410 while test $cf_sigwinch != 1
3413 #undef _XOPEN_SOURCE
3414 #undef _POSIX_SOURCE
3415 #undef _POSIX_C_SOURCE
3416 #include <sys/types.h>
3417 #include <sys/signal.h>
3419 #if SIGWINCH != $cf_sigwinch
3422 int x = SIGWINCH; (void)x],
3423 [cf_cv_fixup_sigwinch=$cf_sigwinch
3426 cf_sigwinch=`expr $cf_sigwinch - 1`
3430 if test "$cf_cv_fixup_sigwinch" != unknown ; then
3431 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3435 dnl ---------------------------------------------------------------------------
3436 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3438 dnl signal handler, but there are some gcc dependencies in that recommendation.
3440 AC_DEFUN([CF_SIG_ATOMIC_T],
3442 AC_MSG_CHECKING(for signal global datatype)
3443 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3445 "volatile sig_atomic_t" \
3450 #include <sys/types.h>
3456 static void handler(int sig)
3461 [signal(SIGINT, handler);
3463 [cf_cv_sig_atomic_t=$cf_type],
3464 [cf_cv_sig_atomic_t=no])
3465 test "$cf_cv_sig_atomic_t" != no && break
3468 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3469 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3471 dnl ---------------------------------------------------------------------------
3472 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3474 dnl Construct a search-list for a nonstandard header/lib-file
3475 dnl $1 = the variable to return as result
3476 dnl $2 = the package name
3477 dnl $3 = the subdirectory, e.g., bin, include or lib
3478 AC_DEFUN([CF_SUBDIR_PATH],
3482 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3484 for cf_subdir_prefix in \
3492 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3495 dnl ---------------------------------------------------------------------------
3496 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3497 dnl ------------------
3498 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3499 dnl older SCO configurations.
3500 AC_DEFUN([CF_SYS_TIME_SELECT],
3502 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3503 AC_CACHE_VAL(cf_cv_sys_time_select,[
3505 #include <sys/types.h>
3506 #ifdef HAVE_SYS_TIME_H
3507 #include <sys/time.h>
3509 #ifdef HAVE_SYS_SELECT_H
3510 #include <sys/select.h>
3512 ],[],[cf_cv_sys_time_select=yes],
3513 [cf_cv_sys_time_select=no])
3515 AC_MSG_RESULT($cf_cv_sys_time_select)
3516 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>])
3518 dnl ---------------------------------------------------------------------------
3519 dnl CF_TERM_HEADER version: 5 updated: 2020/03/19 20:23:48
3521 dnl Look for term.h, which is part of X/Open curses. It defines the interface
3522 dnl to terminfo database. Usually it is in the same include-path as curses.h,
3523 dnl but some packagers change this, breaking various applications.
3524 AC_DEFUN([CF_TERM_HEADER],[
3525 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3526 case ${cf_cv_ncurses_header} in
3527 (*/ncurses.h|*/ncursesw.h)
3528 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3531 cf_term_header=term.h
3535 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3537 AC_TRY_COMPILE([#include <stdio.h>
3538 #include <${cf_cv_ncurses_header:-curses.h}>
3540 ],[int x = auto_left_margin; (void)x],[
3541 cf_cv_term_header="$cf_test"],[
3542 cf_cv_term_header=unknown
3544 test "$cf_cv_term_header" != unknown && break
3548 # Set definitions to allow ifdef'ing to accommodate subdirectories
3550 case $cf_cv_term_header in
3552 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3556 case $cf_cv_term_header in
3558 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3561 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3565 dnl ---------------------------------------------------------------------------
3566 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3568 dnl Define a top_builddir symbol, for applications that need an absolute path.
3569 AC_DEFUN([CF_TOP_BUILDDIR],
3571 top_builddir=ifelse($1,,`pwd`,$1)
3572 AC_SUBST(top_builddir)
3574 dnl ---------------------------------------------------------------------------
3575 dnl CF_TPUTS_PROTO version: 3 updated: 2015/04/17 21:26:14
3577 dnl Check for type of function-pointer passed to tputs. Some old
3578 dnl implementations used functions that had different prototypes, making it
3579 dnl hard to compile portable programs using tputs.
3580 AC_DEFUN([CF_TPUTS_PROTO],[
3581 CF_CURSES_FUNCS(tputs)
3582 if test x$cf_cv_func_tputs = xyes
3585 for cf_arg in int char
3587 for cf_ret in int void
3589 if test $cf_ret = void
3591 cf_return="/* nothing */"
3593 cf_return="return value"
3596 #include <${cf_cv_ncurses_header:-curses.h}>
3597 #include <$cf_cv_term_header>
3599 static $cf_ret outc($cf_arg value) { $cf_return; }
3601 tputs("hello", 0, outc);
3602 ${cf_cv_main_return:-return}(0);
3604 CF_VERBOSE([prototype $cf_ret func($cf_arg value)])
3605 cat >>confdefs.h <<EOF
3606 #define TPUTS_ARG $cf_arg
3607 #define TPUTS_PROTO(func,value) $cf_ret func(TPUTS_ARG value)
3608 #define TPUTS_RETURN(value) $cf_return
3614 test $cf_done = yes && break
3618 dnl ---------------------------------------------------------------------------
3619 dnl CF_TRIM_X_LIBS version: 3 updated: 2015/04/12 15:39:00
3621 dnl Trim extra base X libraries added as a workaround for inconsistent library
3622 dnl dependencies returned by "new" pkg-config files.
3623 AC_DEFUN([CF_TRIM_X_LIBS],[
3624 for cf_trim_lib in Xmu Xt X11
3627 (*-l$cf_trim_lib\ *-l$cf_trim_lib*)
3628 LIBS=`echo "$LIBS " | sed -e 's/ / /g' -e 's%-l'"$cf_trim_lib"' %%' -e 's/ $//'`
3629 CF_VERBOSE(..trimmed $LIBS)
3634 dnl ---------------------------------------------------------------------------
3635 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
3636 dnl -----------------
3637 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
3638 dnl available in that form.
3640 dnl $1 = package name
3641 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
3642 dnl $3 = logic to use if pkg-config does not have the package
3643 AC_DEFUN([CF_TRY_PKG_CONFIG],[
3644 AC_REQUIRE([CF_PKG_CONFIG])
3646 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
3647 CF_VERBOSE(found package $1)
3648 cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
3649 cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`"
3650 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
3651 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
3652 CF_ADD_CFLAGS($cf_pkgconfig_incs)
3653 CF_ADD_LIBS($cf_pkgconfig_libs)
3654 ifelse([$2],,:,[$2])
3658 ifelse([$3],,:,[$3])
3661 dnl ---------------------------------------------------------------------------
3662 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
3663 dnl -------------------
3664 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
3665 dnl can define it successfully.
3666 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
3667 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
3671 #include <sys/types.h>
3673 #ifndef _XOPEN_SOURCE
3676 [cf_cv_xopen_source=no],
3677 [cf_save="$CPPFLAGS"
3678 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
3682 #include <sys/types.h>
3684 #ifdef _XOPEN_SOURCE
3687 [cf_cv_xopen_source=no],
3688 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
3693 if test "$cf_cv_xopen_source" != no ; then
3694 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
3695 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
3696 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
3697 CF_ADD_CFLAGS($cf_temp_xopen_source)
3700 dnl ---------------------------------------------------------------------------
3701 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
3703 dnl Make an uppercase version of a variable
3704 dnl $1=uppercase($2)
3705 AC_DEFUN([CF_UPPER],
3707 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
3709 dnl ---------------------------------------------------------------------------
3710 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
3712 dnl Check for multibyte support, and if not found, utf8 compatibility library
3713 AC_DEFUN([CF_UTF8_LIB],
3715 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
3716 cf_save_LIBS="$LIBS"
3718 #include <stdlib.h>],[putwc(0,0);],
3719 [cf_cv_utf8_lib=yes],
3721 #include <libutf8.h>],[putwc(0,0);],utf8,
3722 [cf_cv_utf8_lib=add-on],
3723 [cf_cv_utf8_lib=no])
3726 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
3728 if test "$cf_cv_utf8_lib" = "add-on" ; then
3729 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
3730 CF_ADD_INCDIR($cf_cv_header_path_utf8)
3731 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
3732 CF_ADD_LIBS($cf_cv_library_file_utf8)
3735 dnl ---------------------------------------------------------------------------
3736 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
3738 dnl Use AC_VERBOSE w/o the warnings
3739 AC_DEFUN([CF_VERBOSE],
3740 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
3743 dnl ---------------------------------------------------------------------------
3744 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
3746 dnl Check if type wide-character type $1 is declared, and if so, which header
3747 dnl file is needed. The second parameter is used to set a shell variable when
3748 dnl the type is not found. The first parameter sets a shell variable for the
3750 AC_DEFUN([CF_WCHAR_TYPE],
3752 # This is needed on Tru64 5.0 to declare $1
3753 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
3758 #ifdef HAVE_LIBUTF8_H
3759 #include <libutf8.h>
3768 #ifdef HAVE_LIBUTF8_H
3769 #include <libutf8.h>
3773 [cf_cv_$1=unknown])])])
3775 if test "$cf_cv_$1" = yes ; then
3776 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
3781 # if we do not find $1 in either place, use substitution to provide a fallback.
3782 if test "$cf_cv_$1" = unknown ; then
3787 # if we find $1 in either place, use substitution to provide a fallback.
3788 if test "$cf_cv_$1" != unknown ; then
3793 dnl ---------------------------------------------------------------------------
3794 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
3795 dnl ------------------
3796 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
3798 AC_DEFUN([CF_WITH_CURSES_DIR],[
3800 AC_MSG_CHECKING(for specific curses-directory)
3801 AC_ARG_WITH(curses-dir,
3802 [ --with-curses-dir=DIR directory in which (n)curses is installed],
3803 [cf_cv_curses_dir=$withval],
3804 [cf_cv_curses_dir=no])
3805 AC_MSG_RESULT($cf_cv_curses_dir)
3807 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
3809 CF_PATH_SYNTAX(withval)
3810 if test -d "$cf_cv_curses_dir"
3812 CF_ADD_INCDIR($cf_cv_curses_dir/include)
3813 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
3817 dnl ---------------------------------------------------------------------------
3818 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
3819 dnl ----------------
3820 dnl Configure-option for dbmalloc. The optional parameter is used to override
3821 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3822 AC_DEFUN([CF_WITH_DBMALLOC],[
3823 CF_NO_LEAKS_OPTION(dbmalloc,
3824 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
3827 if test "$with_dbmalloc" = yes ; then
3828 AC_CHECK_HEADER(dbmalloc.h,
3829 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
3832 dnl ---------------------------------------------------------------------------
3833 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
3835 dnl Configure-option for dmalloc. The optional parameter is used to override
3836 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
3837 AC_DEFUN([CF_WITH_DMALLOC],[
3838 CF_NO_LEAKS_OPTION(dmalloc,
3839 [ --with-dmalloc test: use Gray Watson's dmalloc library],
3842 if test "$with_dmalloc" = yes ; then
3843 AC_CHECK_HEADER(dmalloc.h,
3844 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
3847 dnl ---------------------------------------------------------------------------
3848 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
3849 dnl --------------------
3850 dnl Allow for overriding the basename of a library, i.e., the part to which
3851 dnl prefixes/suffixes are attached.
3853 dnl $1 = variable to set
3854 dnl $2 = option name
3855 dnl $3 = default basename for library, if omitted use $2
3856 AC_DEFUN([CF_WITH_LIB_BASENAME],
3858 AC_MSG_CHECKING(for desired basename for $2 library)
3859 AC_ARG_WITH($2-libname,
3860 [ --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
3861 [with_lib_basename=$withval],
3862 [with_lib_basename=ifelse($3,,$2,$3)])
3863 $1="$with_lib_basename"
3867 $1=ifelse($3,,$2,$3)
3873 AC_MSG_RESULT([$]$1)
3876 dnl ---------------------------------------------------------------------------
3877 dnl CF_WITH_NCURSES_ETC version: 5 updated: 2016/02/20 19:23:20
3878 dnl -------------------
3879 dnl Use this macro for programs which use any variant of "curses", e.g.,
3880 dnl "ncurses", and "PDCurses". Programs that can use curses and some unrelated
3881 dnl library (such as slang) should use a "--with-screen=XXX" option.
3883 dnl This does not use AC_DEFUN, because that would tell autoconf to run each
3884 dnl of the macros inside this one - before this macro.
3885 define([CF_WITH_NCURSES_ETC],[
3890 AC_MSG_CHECKING(for specified curses library type)
3892 [ --with-screen=XXX use specified curses-libraries],
3893 [cf_cv_screen=$withval],[
3895 AC_ARG_WITH(ncursesw,
3896 [ --with-ncursesw use wide ncurses-libraries],
3897 [cf_cv_screen=ncursesw],[
3899 AC_ARG_WITH(ncurses,
3900 [ --with-ncurses use ncurses-libraries],
3901 [cf_cv_screen=ncurses],[
3903 AC_ARG_WITH(pdcurses,
3904 [ --with-pdcurses compile/link with pdcurses X11 library],
3905 [cf_cv_screen=pdcurses],[
3907 AC_ARG_WITH(curses-colr,
3908 [ --with-curses-colr compile/link with HPUX 10.x color-curses],
3909 [cf_cv_screen=curses_colr],[
3911 AC_ARG_WITH(curses-5lib,
3912 [ --with-curses-5lib compile/link with SunOS 5lib curses],
3913 [cf_cv_screen=curses_5lib])])])])])])
3915 AC_MSG_RESULT($cf_cv_screen)
3917 case $cf_cv_screen in
3923 CF_NCURSES_CONFIG($cf_cv_screen)
3926 CF_NCURSES_CONFIG($cf_cv_screen)
3932 AC_MSG_ERROR(unexpected screen-value: $cf_cv_screen)
3936 CF_NCURSES_PTHREADS($cf_cv_screen)
3939 dnl ---------------------------------------------------------------------------
3940 dnl CF_WITH_SCREEN_PDCURSES version: 1 updated: 2020/08/28 16:56:27
3941 dnl -----------------------
3942 dnl Call this macro before CF_ENABLE_WARNINGS for configure scripts which use
3943 dnl the "--with-screen=pdcurses" selection. Doing that allows the configure
3944 dnl script to search for the X11/Xt header files to declare (or not) the
3945 dnl symbol needed to enable "const" in those header files. If that configure
3946 dnl option is not used, then those checks are unnecessary.
3947 AC_DEFUN([CF_WITH_SCREEN_PDCURSES],[
3948 AC_PROVIDE([AC_PATH_XTRA])
3949 AC_PROVIDE([AC_PATH_X])
3950 if test -n "$with_screen" && test "x$with_screen" = "xpdcurses"
3956 dnl ---------------------------------------------------------------------------
3957 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
3958 dnl ----------------
3959 AC_DEFUN([CF_WITH_VALGRIND],[
3960 CF_NO_LEAKS_OPTION(valgrind,
3961 [ --with-valgrind test: use valgrind],
3964 dnl ---------------------------------------------------------------------------
3965 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
3967 dnl Handle configure option "--with-x11-rgb", setting these shell
3970 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
3971 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
3973 dnl Most Linux's use this:
3974 dnl /usr/share/X11/rgb.txt
3975 dnl Debian uses this:
3976 dnl /etc/X11/rgb.txt
3977 dnl DragonFlyBSD ports uses this:
3978 dnl /usr/pkg/lib/X11/rgb.txt
3979 dnl FreeBSD ports use these:
3980 dnl /usr/local/lib/X11/rgb.txt
3981 dnl /usr/local/share/X11/rgb.txt
3982 dnl Mandriva has these:
3983 dnl /usr/lib/X11/rgb.txt
3984 dnl /usr/lib64/X11/rgb.txt
3985 dnl NetBSD has these
3986 dnl /usr/X11R7/lib/X11/rgb.txt
3987 dnl OpenSolaris uses
3989 dnl /usr/X11/etc/X11/rgb.txt
3990 dnl /usr/X11/share/X11/rgb.txt
3991 dnl /usr/X11/lib/X11/rgb.txt
3993 dnl /opt/local/share/X11/rgb.txt (MacPorts)
3994 dnl /opt/X11/share/X11/rgb.txt (non-ports)
3996 dnl /usr/X11/etc/X11/rgb.txt
3997 dnl /usr/X11/share/X11/rgb.txt (perhaps)
3998 dnl /usr/X11/lib/amd64/X11/rgb.txt
3999 dnl Solaris10 uses (in this order):
4000 dnl /usr/openwin/lib/X11/rgb.txt
4001 dnl /usr/X11/lib/X11/rgb.txt
4002 AC_DEFUN([CF_WITH_X11_RGB],[
4003 AC_MSG_CHECKING(for X11 rgb file)
4004 AC_ARG_WITH(x11-rgb,
4005 [ --with-x11-rgb=FILE file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
4006 [RGB_PATH=$withval],
4009 if test "x[$]RGB_PATH" = xauto
4011 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
4013 /opt/local/share/X11/rgb.txt \
4014 /opt/X11/share/X11/rgb.txt \
4015 /usr/share/X11/rgb.txt \
4016 /usr/X11/share/X11/rgb.txt \
4017 /usr/X11/lib/X11/rgb.txt \
4018 /usr/lib/X11/rgb.txt \
4020 /usr/pkg/lib/X11/rgb.txt \
4021 /usr/X11R7/lib/X11/rgb.txt \
4022 /usr/X11R6/lib/X11/rgb.txt \
4023 /usr/X11R5/lib/X11/rgb.txt \
4024 /usr/X11R4/lib/X11/rgb.txt \
4025 /usr/local/lib/X11/rgb.txt \
4026 /usr/local/share/X11/rgb.txt \
4027 /usr/lib64/X11/rgb.txt
4029 if test -f "$cf_path" ; then
4036 CF_PATH_SYNTAX(cf_path)
4039 AC_MSG_RESULT($RGB_PATH)
4041 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
4044 if test "$RGB_PATH" = no
4048 AC_SUBST(no_x11_rgb)
4050 dnl ---------------------------------------------------------------------------
4051 dnl CF_XOPEN_CURSES version: 15 updated: 2020/03/19 20:23:48
4053 dnl Test if we should define X/Open source for curses, needed on Digital Unix
4054 dnl 4.x, to see the extended functions, but breaks on IRIX 6.x.
4056 dnl The getbegyx() check is needed for HPUX, which omits legacy macros such
4057 dnl as getbegy(). The latter is better design, but the former is standard.
4058 AC_DEFUN([CF_XOPEN_CURSES],
4060 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
4061 AC_CACHE_CHECK(definition to turn on extended curses functions,cf_cv_need_xopen_extension,[
4062 cf_cv_need_xopen_extension=unknown
4065 #include <${cf_cv_ncurses_header:-curses.h}>],[
4066 #if defined(NCURSES_VERSION_PATCH)
4067 #if (NCURSES_VERSION_PATCH < 20100501) && (NCURSES_VERSION_PATCH >= 20100403)
4071 #ifdef NCURSES_VERSION
4073 int check2 = curs_set((int)sizeof(check));
4075 long x = winnstr(stdscr, "", 0);
4077 #ifdef NCURSES_VERSION
4080 getbegyx(stdscr, y1, x1);
4085 [cf_cv_need_xopen_extension=none],
4087 for cf_try_xopen_extension in _XOPEN_SOURCE_EXTENDED NCURSES_WIDECHAR
4090 #define $cf_try_xopen_extension 1
4092 #include <${cf_cv_ncurses_header:-curses.h}>],[
4093 #ifdef NCURSES_VERSION
4095 int check2 = curs_set((int)sizeof(check));
4097 long x = winnstr(stdscr, "", 0);
4099 getbegyx(stdscr, y1, x1);
4100 #ifdef NCURSES_VERSION
4107 [cf_cv_need_xopen_extension=$cf_try_xopen_extension; break])
4112 case $cf_cv_need_xopen_extension in
4114 CF_APPEND_TEXT(CPPFLAGS,-D$cf_cv_need_xopen_extension)
4119 dnl ---------------------------------------------------------------------------
4120 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
4122 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4123 dnl or adapt to the vendor's definitions to get equivalent functionality,
4124 dnl without losing the common non-POSIX features.
4127 dnl $1 is the nominal value for _XOPEN_SOURCE
4128 dnl $2 is the nominal value for _POSIX_C_SOURCE
4129 AC_DEFUN([CF_XOPEN_SOURCE],[
4130 AC_REQUIRE([AC_CANONICAL_HOST])
4131 AC_REQUIRE([CF_POSIX_VISIBLE])
4133 if test "$cf_cv_posix_visible" = no; then
4135 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4136 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4141 cf_xopen_source="-D_ALL_SOURCE"
4147 cf_xopen_source="-D_APPLE_C_SOURCE"
4150 cf_xopen_source="-D_DARWIN_C_SOURCE"
4153 (freebsd*|dragonfly*|midnightbsd*)
4154 # 5.x headers associate
4155 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4156 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4157 cf_POSIX_C_SOURCE=200112L
4159 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4162 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4165 cf_xopen_source="-D_HPUX_SOURCE"
4168 cf_xopen_source="-D_SGI_SOURCE"
4171 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4172 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4175 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4178 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4180 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4183 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4186 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4187 cf_xopen_source="-D_BSD_SOURCE"
4191 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4194 cf_xopen_source="-D_OSF_SOURCE"
4197 cf_xopen_source="-D_QNX_SOURCE"
4200 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4203 cf_xopen_source="-D__EXTENSIONS__"
4204 cf_cv_xopen_source=broken
4206 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4212 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4216 if test -n "$cf_xopen_source" ; then
4217 CF_ADD_CFLAGS($cf_xopen_source,true)
4220 dnl In anything but the default case, we may have system-specific setting
4221 dnl which is still not guaranteed to provide all of the entrypoints that
4222 dnl _XOPEN_SOURCE would yield.
4223 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4224 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4225 AC_TRY_COMPILE([#include <stdlib.h>],[
4226 #ifndef _XOPEN_SOURCE
4229 [cf_XOPEN_SOURCE_set=yes],
4230 [cf_XOPEN_SOURCE_set=no])
4231 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4232 if test $cf_XOPEN_SOURCE_set = yes
4234 AC_TRY_COMPILE([#include <stdlib.h>],[
4235 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4238 [cf_XOPEN_SOURCE_set_ok=yes],
4239 [cf_XOPEN_SOURCE_set_ok=no])
4240 if test $cf_XOPEN_SOURCE_set_ok = no
4242 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4248 fi # cf_cv_posix_visible
4250 dnl ---------------------------------------------------------------------------
4251 dnl CF_X_ATHENA version: 24 updated: 2020/03/10 18:53:47
4253 dnl Check for Xaw (Athena) libraries
4255 dnl Sets $cf_x_athena according to the flavor of Xaw which is used.
4256 AC_DEFUN([CF_X_ATHENA],
4258 cf_x_athena=${cf_x_athena:-Xaw}
4260 AC_MSG_CHECKING(if you want to link with Xaw 3d library)
4263 [ --with-Xaw3d link with Xaw 3d library])
4264 if test "$withval" = yes ; then
4271 AC_MSG_CHECKING(if you want to link with Xaw 3d xft library)
4273 AC_ARG_WITH(Xaw3dxft,
4274 [ --with-Xaw3dxft link with Xaw 3d xft library])
4275 if test "$withval" = yes ; then
4276 cf_x_athena=Xaw3dxft
4282 AC_MSG_CHECKING(if you want to link with neXT Athena library)
4285 [ --with-neXtaw link with neXT Athena library])
4286 if test "$withval" = yes ; then
4293 AC_MSG_CHECKING(if you want to link with Athena-Plus library)
4295 AC_ARG_WITH(XawPlus,
4296 [ --with-XawPlus link with Athena-Plus library])
4297 if test "$withval" = yes ; then
4306 if test "$PKG_CONFIG" != none ; then
4308 test "$cf_x_athena" = Xaw && cf_athena_list="xaw8 xaw7 xaw6"
4309 for cf_athena_pkg in \
4312 ${cf_x_athena}-devel \
4314 lib${cf_x_athena}-devel
4316 CF_TRY_PKG_CONFIG($cf_athena_pkg,[
4317 cf_x_athena_lib="$cf_pkgconfig_libs"
4318 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4319 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4323 AC_CACHE_CHECK(for usable $cf_x_athena/Xmu package,cf_cv_xaw_compat,[
4325 #include <X11/Xmu/CharSet.h>
4327 int check = XmuCompareISOLatin1("big", "small");
4329 ],[cf_cv_xaw_compat=yes],[cf_cv_xaw_compat=no])])
4331 if test "$cf_cv_xaw_compat" = no
4333 # workaround for broken ".pc" files...
4334 case "$cf_x_athena_lib" in
4338 CF_VERBOSE(work around broken package)
4340 cf_first_lib=`echo "$cf_save_xmu" | sed -e 's/^[ ][ ]*//' -e 's/ .*//'`
4341 CF_TRY_PKG_CONFIG(xmu,[
4343 CF_ADD_LIB_AFTER($cf_first_lib,$cf_pkgconfig_libs)
4345 CF_ADD_LIB_AFTER($cf_first_lib,-lXmu)
4356 if test -z "$cf_x_athena_lib" ; then
4359 CF_X_ATHENA_CPPFLAGS($cf_x_athena)
4360 CF_X_ATHENA_LIBS($cf_x_athena)
4363 dnl ---------------------------------------------------------------------------
4364 dnl CF_X_ATHENA_CPPFLAGS version: 8 updated: 2020/01/16 05:21:56
4365 dnl --------------------
4366 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4367 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4368 AC_DEFUN([CF_X_ATHENA_CPPFLAGS],
4370 AC_REQUIRE([AC_PATH_XTRA])
4371 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4374 for cf_path in default \
4375 /usr/contrib/X11R6 \
4376 /usr/contrib/X11R5 \
4380 if test -z "$cf_x_athena_inc" ; then
4381 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4382 cf_test=X11/$cf_x_athena_root/SimpleMenu.h
4383 if test $cf_path != default ; then
4384 CF_APPEND_TEXT(CPPFLAGS,-I$cf_path/include)
4385 AC_MSG_CHECKING(for $cf_test in $cf_path)
4387 AC_MSG_CHECKING(for $cf_test)
4390 #include <X11/Intrinsic.h>
4391 #include <$cf_test>],[],
4394 AC_MSG_RESULT($cf_result)
4395 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_CPPFLAGS])
4396 if test "$cf_result" = yes ; then
4397 test "$cf_path" = default && cf_x_athena_inc=default
4398 test "$cf_path" != default && cf_x_athena_inc=$cf_path/include
4404 if test -z "$cf_x_athena_inc" ; then
4405 AC_MSG_WARN([Unable to find Athena header files])
4406 elif test "$cf_x_athena_inc" != default ; then
4407 CF_APPEND_TEXT(CPPFLAGS,-I$cf_x_athena_inc)
4410 dnl ---------------------------------------------------------------------------
4411 dnl CF_X_ATHENA_LIBS version: 13 updated: 2020/01/11 18:16:10
4412 dnl ----------------
4413 dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of
4414 dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw.
4415 AC_DEFUN([CF_X_ATHENA_LIBS],
4416 [AC_REQUIRE([CF_X_TOOLKIT])
4417 cf_x_athena_root=ifelse([$1],,Xaw,[$1])
4420 for cf_path in default \
4421 /usr/contrib/X11R6 \
4422 /usr/contrib/X11R5 \
4427 ${cf_x_athena_root} \
4428 ${cf_x_athena_root}7 \
4429 ${cf_x_athena_root}6
4433 "-l$cf_lib -lXpm -lXmu" \
4434 "-l${cf_lib}_s -lXmu_s"
4436 test -n "$cf_x_athena_lib" && break
4438 CF_SAVE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4439 cf_test=XawSimpleMenuAddGlobalActions
4440 test "$cf_path" != default && cf_libs="-L$cf_path/lib $cf_libs"
4441 CF_ADD_LIBS($cf_libs)
4442 AC_MSG_CHECKING(for $cf_test in $cf_libs)
4444 #include <X11/Intrinsic.h>
4445 #include <X11/$cf_x_athena_root/SimpleMenu.h>
4447 $cf_test((XtAppContext) 0)],
4450 AC_MSG_RESULT($cf_result)
4451 CF_RESTORE_XTRA_FLAGS([CF_X_ATHENA_LIBS])
4453 if test "$cf_result" = yes ; then
4454 cf_x_athena_lib="$cf_libs"
4458 test -n "$cf_x_athena_lib" && break
4462 if test -z "$cf_x_athena_lib" ; then
4464 [Unable to successfully link Athena library (-l$cf_x_athena_root) with test program])
4467 CF_ADD_LIBS($cf_x_athena_lib)
4468 CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena)
4469 AC_DEFINE_UNQUOTED($cf_x_athena_LIBS)
4471 dnl ---------------------------------------------------------------------------
4472 dnl CF_X_EXT version: 3 updated: 2010/06/02 05:03:05
4474 AC_DEFUN([CF_X_EXT],[
4475 CF_TRY_PKG_CONFIG(Xext,,[
4476 AC_CHECK_LIB(Xext,XextCreateExtension,
4477 [CF_ADD_LIB(Xext)])])
4479 dnl ---------------------------------------------------------------------------
4480 dnl CF_X_TOOLKIT version: 25 updated: 2020/03/10 17:26:15
4482 dnl Check for X Toolkit libraries
4483 AC_DEFUN([CF_X_TOOLKIT],
4485 AC_REQUIRE([AC_PATH_XTRA])
4486 AC_REQUIRE([CF_CHECK_CACHE])
4488 # OSX is schizoid about who owns /usr/X11 (old) versus /opt/X11 (new) (and
4489 # in some cases has installed dummy files in the former, other cases replaced
4490 # it with a link to the new location). This complicates the configure script.
4491 # Check for that pitfall, and recover using pkg-config
4493 # If none of these are set, the configuration is almost certainly broken.
4494 if test -z "${X_CFLAGS}${X_PRE_LIBS}${X_LIBS}${X_EXTRA_LIBS}"
4496 CF_TRY_PKG_CONFIG(x11,,[AC_MSG_WARN(unable to find X11 library)])
4497 CF_TRY_PKG_CONFIG(ice,,[AC_MSG_WARN(unable to find ICE library)])
4498 CF_TRY_PKG_CONFIG(sm,,[AC_MSG_WARN(unable to find SM library)])
4499 CF_TRY_PKG_CONFIG(xt,,[AC_MSG_WARN(unable to find Xt library)])
4501 LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS"
4506 CF_TRY_PKG_CONFIG(xt,[
4512 # we have an "xt" package, but it may omit Xt's dependency on X11
4513 AC_CACHE_CHECK(for usable X dependency,cf_cv_xt_x11_compat,[
4515 #include <X11/Xlib.h>
4517 int rc1 = XDrawLine((Display*) 0, (Drawable) 0, (GC) 0, 0, 0, 0, 0);
4518 int rc2 = XClearWindow((Display*) 0, (Window) 0);
4519 int rc3 = XMoveWindow((Display*) 0, (Window) 0, 0, 0);
4520 int rc4 = XMoveResizeWindow((Display*)0, (Window)0, 0, 0, 0, 0);
4521 ],[cf_cv_xt_x11_compat=yes],[cf_cv_xt_x11_compat=no])])
4522 if test "$cf_cv_xt_x11_compat" = no
4524 CF_VERBOSE(work around broken X11 dependency)
4525 # 2010/11/19 - good enough until a working Xt on Xcb is delivered.
4526 CF_TRY_PKG_CONFIG(x11,,[CF_ADD_LIB_AFTER(-lXt,-lX11)])
4531 AC_CACHE_CHECK(for usable X Toolkit package,cf_cv_xt_ice_compat,[
4533 #include <X11/Shell.h>
4534 ],[int num = IceConnectionNumber(0); (void) num
4535 ],[cf_cv_xt_ice_compat=yes],[cf_cv_xt_ice_compat=no])])
4537 if test "$cf_cv_xt_ice_compat" = no
4539 # workaround for broken ".pc" files used for X Toolkit.
4540 case "x$X_PRE_LIBS" in
4546 CF_VERBOSE(work around broken ICE dependency)
4547 CF_TRY_PKG_CONFIG(ice,
4548 [CF_TRY_PKG_CONFIG(sm)],
4549 [CF_ADD_LIB_AFTER(-lXt,$X_PRE_LIBS)])
4559 LDFLAGS="$X_LIBS $LDFLAGS"
4560 CF_CHECK_CFLAGS($X_CFLAGS)
4562 AC_CHECK_FUNC(XOpenDisplay,,[
4563 AC_CHECK_LIB(X11,XOpenDisplay,
4564 [CF_ADD_LIB(X11)])])
4566 AC_CHECK_FUNC(XtAppInitialize,,[
4567 AC_CHECK_LIB(Xt, XtAppInitialize,
4568 [AC_DEFINE(HAVE_LIBXT,1,[Define to 1 if we can compile with the Xt library])
4570 LIBS="-lXt $LIBS"])])
4573 if test $cf_have_X_LIBS = no ; then
4575 [Unable to successfully link X Toolkit library (-lXt) with
4576 test program. You will have to check and add the proper libraries by hand
4580 dnl ---------------------------------------------------------------------------
4581 dnl CF__CURSES_DATA version: 2 updated: 2020/02/08 21:00:26
4583 dnl Attempt to make a copy of a curses data item. This is needed in the
4584 dnl check-data configure tests when using ncurses, because the symbol may be
4585 dnl actually a function return-value. That could happen if the linker is
4586 dnl broken (does not resolve data-only references), or if ncurses is configured
4587 dnl to support re-entrant code.
4590 define([CF__CURSES_DATA],[
4591 #if defined($2) && ((defined(NCURSES_WRAPPED_VAR) && (NCURSES_VERSION_PATCH < 20200208)) || defined(NCURSES_BROKEN_LINKER) || defined(NCURSES_REENTRANT))
4592 const void *$1 = (const void *)($2);
4594 const void *$1 = &($2);
4596 fprintf(stderr, "testing linkage of $2:%p\n", (const void *)$1);
4598 dnl ---------------------------------------------------------------------------
4599 dnl CF__CURSES_HEAD version: 2 updated: 2010/10/23 15:54:49
4601 dnl Define a reusable chunk which includes <curses.h> and <term.h> when they
4602 dnl are both available.
4603 define([CF__CURSES_HEAD],[
4605 #include <xcurses.h>
4606 char * XCursesProgramName = "test";
4608 #include <${cf_cv_ncurses_header:-curses.h}>
4609 #if defined(NCURSES_VERSION) && defined(HAVE_NCURSESW_TERM_H)
4610 #include <ncursesw/term.h>
4611 #elif defined(NCURSES_VERSION) && defined(HAVE_NCURSES_TERM_H)
4612 #include <ncurses/term.h>
4613 #elif defined(HAVE_TERM_H)