ncurses 6.2 - patch 20210323
[ncurses.git] / test / aclocal.m4
1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey                                *
3 dnl Copyright 2003-2017,2018 Free Software Foundation, Inc.                  *
4 dnl                                                                          *
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:                 *
12 dnl                                                                          *
13 dnl The above copyright notice and this permission notice shall be included  *
14 dnl in all copies or substantial portions of the Software.                   *
15 dnl                                                                          *
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.                               *
23 dnl                                                                          *
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       *
27 dnl authorization.                                                           *
28 dnl***************************************************************************
29 dnl
30 dnl $Id: aclocal.m4,v 1.192 2021/03/23 00:37:21 tom Exp $
31 dnl
32 dnl Author: Thomas E. Dickey
33 dnl
34 dnl Macros used in NCURSES test programs auto-configuration script.
35 dnl
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.
39 dnl
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
43 dnl
44 dnl ---------------------------------------------------------------------------
45 dnl ---------------------------------------------------------------------------
46 dnl AM_LANGINFO_CODESET version: 6 updated: 2021/01/01 16:53:59
47 dnl -------------------
48 dnl Inserted as requested by gettext 0.10.40
49 dnl File from /usr/share/aclocal
50 dnl codeset.m4
51 dnl ====================
52 dnl serial AM1
53 dnl
54 dnl From Bruno Haible.
55 AC_DEFUN([AM_LANGINFO_CODESET],
56 [
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)
62         ])
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).])
66         fi
67 ])dnl
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.
72 dnl
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],
77 [
78 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
79 ifdef([m4_version_compare],
80 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
81 [CF_ACVERSION_COMPARE(
82 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
83 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
84 dnl ---------------------------------------------------------------------------
85 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
86 dnl --------------------
87 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
88 dnl                      MAJOR2, MINOR2, TERNARY2,
89 dnl                      PRINTABLE2, not FOUND, FOUND)
90 define([CF_ACVERSION_COMPARE],
91 [ifelse(builtin([eval], [$2 < $5]), 1,
92 [ifelse([$8], , ,[$8])],
93 [ifelse([$9], , ,[$9])])])dnl
94 dnl ---------------------------------------------------------------------------
95 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
96 dnl -------------
97 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
98 dnl $1 = flags to add
99 dnl $2 = if given makes this macro verbose.
100 dnl
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],
105 [
106 cf_fix_cppflags=no
107 cf_new_cflags=
108 cf_new_cppflags=
109 cf_new_extra_cppflags=
110
111 for cf_add_cflags in $1
112 do
113 case "$cf_fix_cppflags" in
114 (no)
115         case "$cf_add_cflags" in
116         (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
117                 case "$cf_add_cflags" in
118                 (-D*)
119                         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
120
121                         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
122                                 && test -z "${cf_tst_cflags}" \
123                                 && cf_fix_cppflags=yes
124
125                         if test "$cf_fix_cppflags" = yes ; then
126                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
127                                 continue
128                         elif test "${cf_tst_cflags}" = "\"'" ; then
129                                 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
130                                 continue
131                         fi
132                         ;;
133                 esac
134                 case "$CPPFLAGS" in
135                 (*$cf_add_cflags)
136                         ;;
137                 (*)
138                         case "$cf_add_cflags" in
139                         (-D*)
140                                 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
141                                 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
142                                 ;;
143                         esac
144                         CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
145                         ;;
146                 esac
147                 ;;
148         (*)
149                 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
150                 ;;
151         esac
152         ;;
153 (yes)
154         CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
155
156         cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
157
158         test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
159                 && test -z "${cf_tst_cflags}" \
160                 && cf_fix_cppflags=no
161         ;;
162 esac
163 done
164
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)
168 fi
169
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)
173 fi
174
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)
178 fi
179
180 AC_SUBST(EXTRA_CPPFLAGS)
181
182 ])dnl
183 dnl ---------------------------------------------------------------------------
184 dnl CF_ADD_INCDIR version: 16 updated: 2020/12/31 20:19:42
185 dnl -------------
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],
192 [
193 if test -n "$1" ; then
194   for cf_add_incdir in $1
195   do
196         while test "$cf_add_incdir" != /usr/include
197         do
198           if test -d "$cf_add_incdir"
199           then
200                 cf_have_incdir=no
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
206                         fi
207                   done
208                 fi
209
210                 if test "$cf_have_incdir" = no ; then
211                   if test "$cf_add_incdir" = /usr/local/include ; then
212                         if test "$GCC" = yes
213                         then
214                           cf_save_CPPFLAGS=$CPPFLAGS
215                           CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
216                           AC_TRY_COMPILE([#include <stdio.h>],
217                                   [printf("Hello")],
218                                   [],
219                                   [cf_have_incdir=yes])
220                           CPPFLAGS=$cf_save_CPPFLAGS
221                         fi
222                   fi
223                 fi
224
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"
228
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"
232                 else
233                   break
234                 fi
235           else
236                 break
237           fi
238         done
239   done
240 fi
241 ])dnl
242 dnl ---------------------------------------------------------------------------
243 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
244 dnl ----------
245 dnl Add a library, used to enforce consistency.
246 dnl
247 dnl $1 = library to add, without the "-l"
248 dnl $2 = variable to update (default $LIBS)
249 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
250 dnl ---------------------------------------------------------------------------
251 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
252 dnl -------------
253 dnl     Adds to the library-path
254 dnl
255 dnl     Some machines have trouble with multiple -L options.
256 dnl
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)
259 dnl
260 AC_DEFUN([CF_ADD_LIBDIR],
261 [
262 if test -n "$1" ; then
263         for cf_add_libdir in $1
264         do
265                 if test "$cf_add_libdir" = /usr/lib ; then
266                         :
267                 elif test -d "$cf_add_libdir"
268                 then
269                         cf_have_libdir=no
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
275                                         fi
276                                 done
277                         fi
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])"
281                         fi
282                 fi
283         done
284 fi
285 ])dnl
286 dnl ---------------------------------------------------------------------------
287 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
288 dnl -----------
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.
292 dnl
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])"
297 # reverse order
298 cf_add_0lib=
299 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
300 # filter duplicates
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
304                         cf_add_1lib=
305                         break
306                 fi
307         done
308         test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
309 done
310 ifelse($2,,LIBS,[$2])="$cf_add_libs"
311 ])dnl
312 dnl ---------------------------------------------------------------------------
313 dnl CF_ADD_LIB_AFTER version: 3 updated: 2013/07/09 21:27:22
314 dnl ----------------
315 dnl Add a given library after another, e.g., following the one it satisfies a
316 dnl dependency for.
317 dnl
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)
324 ])dnl
325 dnl ---------------------------------------------------------------------------
326 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
327 dnl ------------------
328 dnl Append to a search-list for a nonstandard header/lib-file
329 dnl     $1 = the variable to return as result
330 dnl     $2 = the package name
331 dnl     $3 = the subdirectory, e.g., bin, include or lib
332 dnl $4 = the directory under which we will test for subdirectories
333 dnl $5 = a directory that we do not want $4 to match
334 AC_DEFUN([CF_ADD_SUBDIR_PATH],
335 [
336 test "x$4" != "x$5" && \
337 test -d "$4" && \
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"
345 }
346 ])dnl
347 dnl ---------------------------------------------------------------------------
348 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
349 dnl --------------
350 dnl use this macro for appending text without introducing an extra blank at
351 dnl the beginning
352 define([CF_APPEND_TEXT],
353 [
354         test -n "[$]$1" && $1="[$]$1 "
355         $1="[$]{$1}$2"
356 ])dnl
357 dnl ---------------------------------------------------------------------------
358 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
359 dnl --------------
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
365 dnl -------------
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
371 dnl -------------
372 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
373 dnl values.
374 dnl
375 dnl Parameters:
376 dnl $1 = option name
377 dnl $2 = help-string
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
384 ifelse([$3],,[    :]dnl
385 ,[    $3]) ifelse([$4],,,[
386         else
387                 $4])
388         fi],[enableval=$5 ifelse([$4],,,[
389         $4
390 ])dnl
391 ])])dnl
392 dnl ---------------------------------------------------------------------------
393 dnl CF_C11_NORETURN version: 2 updated: 2021/03/22 20:37:21
394 dnl ---------------
395 AC_DEFUN([CF_C11_NORETURN],
396 [
397 AC_MSG_CHECKING(if you want to use C11 _Noreturn feature)
398 CF_ARG_ENABLE(stdnoreturn,
399         [  --enable-stdnoreturn    enable C11 _Noreturn feature for diagnostics],
400         [enable_stdnoreturn=yes],
401         [enable_stdnoreturn=no])
402 AC_MSG_RESULT($enable_stdnoreturn)
403
404 if test $enable_stdnoreturn = yes; then
405 AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn,
406         [AC_TRY_COMPILE([
407 #include <stdio.h>
408 #include <stdlib.h>
409 #include <stdnoreturn.h>
410 static void giveup(void) { exit(0); }
411         ],
412         [if (feof(stdin)) giveup()],
413         cf_cv_c11_noreturn=yes,
414         cf_cv_c11_noreturn=no)
415         ])
416 else
417         cf_cv_c11_noreturn=no,
418 fi
419
420 if test "$cf_cv_c11_noreturn" = yes; then
421         AC_DEFINE(HAVE_STDNORETURN_H, 1)
422         AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported])
423         HAVE_STDNORETURN_H=1
424 else
425         HAVE_STDNORETURN_H=0
426 fi
427
428 AC_SUBST(HAVE_STDNORETURN_H)
429 ])dnl
430 dnl ---------------------------------------------------------------------------
431 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
432 dnl ---------------
433 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
434 dnl into CC.  This will not help with broken scripts that wrap the compiler
435 dnl with options, but eliminates a more common category of user confusion.
436 dnl
437 dnl In particular, it addresses the problem of being able to run the C
438 dnl preprocessor in a consistent manner.
439 dnl
440 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
441 dnl the nuisance of having inconsistent settings for compiler and preprocessor
442 dnl outweighs that limitation.
443 AC_DEFUN([CF_CC_ENV_FLAGS],
444 [
445 # This should have been defined by AC_PROG_CC
446 : "${CC:=cc}"
447
448 AC_MSG_CHECKING(\$CFLAGS variable)
449 case "x$CFLAGS" in
450 (*-[[IUD]]*)
451         AC_MSG_RESULT(broken)
452         AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
453         cf_flags="$CFLAGS"
454         CFLAGS=
455         for cf_arg in $cf_flags
456         do
457                 CF_ADD_CFLAGS($cf_arg)
458         done
459         ;;
460 (*)
461         AC_MSG_RESULT(ok)
462         ;;
463 esac
464
465 AC_MSG_CHECKING(\$CC variable)
466 case "$CC" in
467 (*[[\ \ ]]-*)
468         AC_MSG_RESULT(broken)
469         AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
470         # humor him...
471         cf_prog=`echo "$CC" | sed -e 's/        / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
472         cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
473         CC="$cf_prog"
474         for cf_arg in $cf_flags
475         do
476                 case "x$cf_arg" in
477                 (x-[[IUDfgOW]]*)
478                         CF_ADD_CFLAGS($cf_arg)
479                         ;;
480                 (*)
481                         CC="$CC $cf_arg"
482                         ;;
483                 esac
484         done
485         CF_VERBOSE(resulting CC: '$CC')
486         CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
487         CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
488         ;;
489 (*)
490         AC_MSG_RESULT(ok)
491         ;;
492 esac
493 ])dnl
494 dnl ---------------------------------------------------------------------------
495 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
496 dnl --------------
497 dnl Check if we're accidentally using a cache from a different machine.
498 dnl Derive the system name, as a check for reusing the autoconf cache.
499 dnl
500 dnl If we've packaged config.guess and config.sub, run that (since it does a
501 dnl better job than uname).  Normally we'll use AC_CANONICAL_HOST, but allow
502 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
503 dnl which is useful in cross-compiles.
504 dnl
505 dnl Note: we would use $ac_config_sub, but that is one of the places where
506 dnl autoconf 2.5x broke compatibility with autoconf 2.13
507 AC_DEFUN([CF_CHECK_CACHE],
508 [
509 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
510         ifelse([$1],,[AC_CANONICAL_HOST],[$1])
511         system_name="$host_os"
512 else
513         system_name="`(uname -s -r) 2>/dev/null`"
514         if test -z "$system_name" ; then
515                 system_name="`(hostname) 2>/dev/null`"
516         fi
517 fi
518 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
519 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
520
521 test -z "$system_name" && system_name="$cf_cv_system_name"
522 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
523
524 if test ".$system_name" != ".$cf_cv_system_name" ; then
525         AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
526         AC_MSG_ERROR("Please remove config.cache and try again.")
527 fi
528 ])dnl
529 dnl ---------------------------------------------------------------------------
530 dnl CF_CHECK_CFLAGS version: 4 updated: 2021/01/02 19:22:58
531 dnl ---------------
532 dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from
533 dnl a build-configuration such as imake.  These have the pitfall that they
534 dnl often contain compiler-specific options which we cannot use, mixed with
535 dnl preprocessor options that we usually can.
536 AC_DEFUN([CF_CHECK_CFLAGS],
537 [
538 CF_VERBOSE(checking additions to CFLAGS)
539 cf_check_cflags="$CFLAGS"
540 cf_check_cppflags="$CPPFLAGS"
541 CF_ADD_CFLAGS($1,yes)
542 if test "x$cf_check_cflags" != "x$CFLAGS" ; then
543 AC_TRY_LINK([#include <stdio.h>],[printf("Hello world");],,
544         [CF_VERBOSE(test-compile failed.  Undoing change to \$CFLAGS)
545          if test "x$cf_check_cppflags" != "x$CPPFLAGS" ; then
546                  CF_VERBOSE(but keeping change to \$CPPFLAGS)
547          fi
548          CFLAGS="$cf_check_cflags"])
549 fi
550 ])dnl
551 dnl ---------------------------------------------------------------------------
552 dnl CF_CHECK_CURSES_LIB version: 3 updated: 2021/01/04 19:45:09
553 dnl -------------------
554 dnl $1 = nominal library name, used also for header lookup
555 dnl $2 = suffix to append to library name
556 dnl $3 = function to check for using AC_CHECK_LIB
557 dnl $4 = optional parameter list for $3
558 AC_DEFUN([CF_CHECK_CURSES_LIB],
559 [
560 AC_REQUIRE([CF_PKG_CONFIG])
561
562 cf_have_curses_lib=no
563
564 : ${NCURSES_CONFIG_PKG:=none}
565 if test "x${NCURSES_CONFIG_PKG}" = xnone; then
566         :
567 elif test "x${PKG_CONFIG:=none}" != xnone; then
568         AC_MSG_CHECKING(pkg-config for $1$2)
569         if "$PKG_CONFIG" --exists "$1$2" ; then
570                 AC_MSG_RESULT(yes)
571
572                 AC_MSG_CHECKING(if the $1$2 package files work)
573
574                 cf_save_CPPFLAGS="$CPPFLAGS"
575                 cf_save_LIBS="$LIBS"
576
577                 CF_ADD_CFLAGS(`$PKG_CONFIG --cflags "$1$2"`)
578                 CF_ADD_LIBS(`$PKG_CONFIG --libs "$1$2"`)
579
580                 AC_TRY_LINK([#include <$1.h>],
581                         [(void) $3 ( ]ifelse([$4],,,[[$4]])[ );],
582                         [AC_TRY_RUN([#include <$1.h>
583                                 int main(void)
584                                 { (void) $3 ( ]ifelse([$4],,,[[$4]])[ ); return 0; }],
585                                 [cf_have_curses_lib=yes],
586                                 [cf_have_curses_lib=no],
587                                 [cf_have_curses_lib=maybe])],
588                         [cf_have_curses_lib=no])
589                 AC_MSG_RESULT($cf_have_curses_lib)
590                 test "$cf_have_curses_lib" = maybe && cf_have_curses_lib=yes
591                 if test "$cf_have_curses_lib" != "yes"
592                 then
593                         CPPFLAGS="$cf_save_CPPFLAGS"
594                         LIBS="$cf_save_LIBS"
595                 else
596                         CF_UPPER(cf_upper,have_lib$1)
597                         AC_DEFINE_UNQUOTED($cf_upper,1)
598                 fi
599         fi
600 fi
601 if test "$cf_have_curses_lib" = no; then
602         AC_CHECK_LIB($1$2,$3,[
603                 CF_UPPER(cf_upper,have_lib$1)
604                 CF_ADD_LIBS(-l$1$2)
605                 AC_DEFINE_UNQUOTED($cf_upper,1)])
606 fi
607 ])dnl
608 dnl ---------------------------------------------------------------------------
609 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
610 dnl -----------------
611 dnl Check if the given compiler is really clang.  clang's C driver defines
612 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
613 dnl not ignore some gcc options.
614 dnl
615 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
616 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
617 dnl the wrappers for gcc and g++ warnings.
618 dnl
619 dnl $1 = GCC (default) or GXX
620 dnl $2 = CLANG_COMPILER (default)
621 dnl $3 = CFLAGS (default) or CXXFLAGS
622 AC_DEFUN([CF_CLANG_COMPILER],[
623 ifelse([$2],,CLANG_COMPILER,[$2])=no
624
625 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
626         AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
627         cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
628         AC_TRY_COMPILE([],[
629 #ifdef __clang__
630 #else
631 make an error
632 #endif
633 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
634 ],[])
635         ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
636         AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
637 fi
638
639 CLANG_VERSION=none
640
641 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
642         case "$CC" in
643         (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
644                 AC_MSG_WARN(replacing broken compiler alias $CC)
645                 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
646                 CC=clang
647                 ;;
648         esac
649
650         AC_MSG_CHECKING(version of $CC)
651         CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
652         test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
653         AC_MSG_RESULT($CLANG_VERSION)
654
655         for cf_clang_opt in \
656                 -Qunused-arguments \
657                 -Wno-error=implicit-function-declaration
658         do
659                 AC_MSG_CHECKING(if option $cf_clang_opt works)
660                 cf_save_CFLAGS="$CFLAGS"
661                 CFLAGS="$CFLAGS $cf_clang_opt"
662                 AC_TRY_LINK([
663                         #include <stdio.h>],[
664                         printf("hello!\\n");],[
665                         cf_clang_optok=yes],[
666                         cf_clang_optok=no])
667                 AC_MSG_RESULT($cf_clang_optok)
668                 CFLAGS="$cf_save_CFLAGS"
669                 if test "$cf_clang_optok" = yes; then
670                         CF_VERBOSE(adding option $cf_clang_opt)
671                         CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
672                 fi
673         done
674 fi
675 ])
676 dnl ---------------------------------------------------------------------------
677 dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
678 dnl -----------------
679 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
680 dnl character-strings.
681 dnl
682 dnl It is ambiguous because the specification accommodated the pre-ANSI
683 dnl compilers bundled by more than one vendor in lieu of providing a standard C
684 dnl compiler other than by costly add-ons.  Because of this, the specification
685 dnl did not take into account the use of const for telling the compiler that
686 dnl string literals would be in readonly memory.
687 dnl
688 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
689 dnl let the compiler decide how to represent Xt's strings which were #define'd.
690 dnl That does not solve the problem of using the block of Xt's strings which
691 dnl are compiled into the library (and is less efficient than one might want).
692 dnl
693 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
694 dnl when compiling the library and compiling using the library, to tell the
695 dnl compiler that String is const.
696 AC_DEFUN([CF_CONST_X_STRING],
697 [
698 AC_REQUIRE([AC_PATH_XTRA])
699
700 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
701
702 AC_TRY_COMPILE(
703 [
704 #include <stdlib.h>
705 #include <X11/Intrinsic.h>
706 ],
707 [String foo = malloc(1); (void)foo],[
708
709 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
710         AC_TRY_COMPILE(
711                 [
712 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
713 #undef  XTSTRINGDEFINES /* X11R5 and later */
714 #include <stdlib.h>
715 #include <X11/Intrinsic.h>
716                 ],[String foo = malloc(1); *foo = 0],[
717                         cf_cv_const_x_string=no
718                 ],[
719                         cf_cv_const_x_string=yes
720                 ])
721 ])
722
723 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
724
725 case "$cf_cv_const_x_string" in
726 (no)
727         CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
728         ;;
729 (*)
730         CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
731         ;;
732 esac
733
734 ])
735 ])dnl
736 dnl ---------------------------------------------------------------------------
737 dnl CF_CURSES_ACS_MAP version: 8 updated: 2021/01/04 19:45:09
738 dnl -----------------
739 dnl Check for likely values of acs_map[]:
740 AC_DEFUN([CF_CURSES_ACS_MAP],
741 [
742 AC_REQUIRE([CF_NCURSES_WRAP_PREFIX])dnl
743 AC_CACHE_CHECK(for alternate character set array, cf_cv_curses_acs_map,[
744 cf_cv_curses_acs_map=unknown
745 for name in acs_map _acs_map __acs_map ${NCURSES_WRAP_PREFIX}acs_map
746 do
747 AC_TRY_LINK([
748 #include <${cf_cv_ncurses_header:-curses.h}>
749 ],[
750 ${name}['k'] = ACS_PLUS
751 ],[cf_cv_curses_acs_map=$name; break])
752 done
753 ])
754
755 test "$cf_cv_curses_acs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_ACS_ARRAY,$cf_cv_curses_acs_map,[Define as needed to override ncurses prefix _nc_])
756 ])
757 dnl ---------------------------------------------------------------------------
758 dnl CF_CURSES_CHECK_DATA version: 10 updated: 2021/01/04 19:45:09
759 dnl --------------------
760 dnl Check if curses.h defines the given data/variable.
761 dnl Use this after CF_NCURSES_CONFIG or CF_CURSES_CONFIG.
762 dnl
763 dnl $1 = data item(s) to check for
764 dnl $2 = action on success, e.g., "break" to quit checking a series of choices
765 AC_DEFUN([CF_CURSES_CHECK_DATA],
766 [
767 for cf_data in $1
768 do
769 AC_MSG_CHECKING(for data $cf_data declaration in ${cf_cv_ncurses_header:-curses.h})
770
771 AC_TRY_COMPILE(CF__CURSES_HEAD,
772 CF__CURSES_DATA(foo,$cf_data)
773 ,[cf_result=yes
774 ],[cf_result=no])
775 AC_MSG_RESULT($cf_result)
776
777 if test "$cf_result" = yes ; then
778         CF_UPPER(cf_result,have_curses_data_$cf_data)
779         AC_DEFINE_UNQUOTED($cf_result)
780         ifelse($2,,,[$2])
781 else
782         AC_MSG_CHECKING(for data $cf_data in library)
783         # BSD linkers insist on making weak linkage, but resolve at runtime.
784         AC_TRY_RUN(CF__CURSES_HEAD
785 [
786 extern char $cf_data;
787 int main(void)
788 {
789         ]CF__CURSES_DATA(foo,$cf_data)[
790         ${cf_cv_main_return:-return}(foo == 0);
791 }],[cf_result=yes
792 ],[cf_result=no],[
793         # cross-compiling
794         AC_TRY_LINK(CF__CURSES_HEAD
795 [extern char $cf_data;],[
796         do {
797                 ]CF__CURSES_DATA(foo,$cf_data)[
798                 ${cf_cv_main_return:-return}(foo == 0);
799         } while (0)
800 ],[cf_result=yes],[cf_result=no])
801 ])
802         AC_MSG_RESULT($cf_result)
803         if test "$cf_result" = yes ; then
804                 CF_UPPER(cf_result,decl_curses_data_$cf_data)
805                 AC_DEFINE_UNQUOTED($cf_result)
806                 # do not exit loop here, since we prefer system's declarations
807         fi
808 fi
809 done
810 ])dnl
811 dnl ---------------------------------------------------------------------------
812 dnl CF_CURSES_CHECK_TYPE version: 5 updated: 2021/01/04 19:45:09
813 dnl --------------------
814 dnl Check if curses.h defines the given type
815 AC_DEFUN([CF_CURSES_CHECK_TYPE],
816 [
817 AC_MSG_CHECKING(for type $1 in ${cf_cv_ncurses_header:-curses.h})
818 AC_TRY_COMPILE([
819 #ifndef _XOPEN_SOURCE_EXTENDED
820 #define _XOPEN_SOURCE_EXTENDED
821 #endif
822 #include <${cf_cv_ncurses_header:-curses.h}>],[
823 $1 foo
824 ],cf_result=yes,cf_result=no)
825 AC_MSG_RESULT($cf_result)
826 if test "$cf_result" = yes ; then
827         CF_UPPER(cf_result,have_type_$1)
828         AC_DEFINE_UNQUOTED($cf_result,1,[Define to 1 if we have type $1])
829 else
830         AC_DEFINE_UNQUOTED($1,$2,[Define to appropriate type if $1 is not declared])
831 fi
832 ])dnl
833 dnl ---------------------------------------------------------------------------
834 dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27
835 dnl ----------------
836 dnl Tie together the configure-script macros for curses.  It may be ncurses,
837 dnl but unless asked, we do not make a special search for ncurses.  However,
838 dnl still check for the ncurses version number, for use in other macros.
839 AC_DEFUN([CF_CURSES_CONFIG],
840 [
841 CF_CURSES_CPPFLAGS
842 CF_NCURSES_VERSION
843 CF_CURSES_LIBS
844 ])dnl
845 dnl ---------------------------------------------------------------------------
846 dnl CF_CURSES_CPPFLAGS version: 14 updated: 2021/01/02 09:31:20
847 dnl ------------------
848 dnl Look for the curses headers.
849 AC_DEFUN([CF_CURSES_CPPFLAGS],[
850
851 AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[
852 cf_cv_curses_incdir=no
853 case "$host_os" in
854 (hpux10.*)
855         if test "x$cf_cv_screen" = "xcurses_colr"
856         then
857                 test -d /usr/include/curses_colr && \
858                 cf_cv_curses_incdir="-I/usr/include/curses_colr"
859         fi
860         ;;
861 (sunos3*|sunos4*)
862         if test "x$cf_cv_screen" = "xcurses_5lib"
863         then
864                 test -d /usr/5lib && \
865                 test -d /usr/5include && \
866                 cf_cv_curses_incdir="-I/usr/5include"
867         fi
868         ;;
869 esac
870 ])
871 if test "$cf_cv_curses_incdir" != no
872 then
873         CF_APPEND_TEXT(CPPFLAGS,$cf_cv_curses_incdir)
874 fi
875
876 CF_CURSES_HEADER
877 CF_TERM_HEADER
878 ])dnl
879 dnl ---------------------------------------------------------------------------
880 dnl CF_CURSES_FUNCS version: 20 updated: 2020/12/31 20:19:42
881 dnl ---------------
882 dnl Curses-functions are a little complicated, since a lot of them are macros.
883 AC_DEFUN([CF_CURSES_FUNCS],
884 [
885 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
886 AC_REQUIRE([CF_XOPEN_CURSES])
887 AC_REQUIRE([CF_CURSES_TERM_H])
888 AC_REQUIRE([CF_CURSES_UNCTRL_H])
889 for cf_func in $1
890 do
891         CF_UPPER(cf_tr_func,$cf_func)
892         AC_MSG_CHECKING(for ${cf_func})
893         CF_MSG_LOG(${cf_func})
894         AC_CACHE_VAL(cf_cv_func_$cf_func,[
895                 eval cf_result='$ac_cv_func_'$cf_func
896                 if test ".$cf_result" != ".no"; then
897                         AC_TRY_LINK(CF__CURSES_HEAD,
898                         [
899 #ifndef ${cf_func}
900 long foo = (long)(&${cf_func});
901 fprintf(stderr, "testing linkage of $cf_func:%p\\n", (void *)foo);
902 if (foo + 1234L > 5678L)
903         ${cf_cv_main_return:-return}(foo != 0);
904 #endif
905                         ],
906                         [cf_result=yes],
907                         [cf_result=no])
908                 fi
909                 eval 'cf_cv_func_'$cf_func'="$cf_result"'
910         ])
911         # use the computed/retrieved cache-value:
912         eval 'cf_result=$cf_cv_func_'$cf_func
913         AC_MSG_RESULT($cf_result)
914         if test "$cf_result" != no; then
915                 AC_DEFINE_UNQUOTED(HAVE_${cf_tr_func})
916         fi
917 done
918 ])dnl
919 dnl ---------------------------------------------------------------------------
920 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
921 dnl ----------------
922 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
923 dnl variations of ncurses' installs.
924 dnl
925 dnl $1 = ncurses when looking for ncurses, or is empty
926 AC_DEFUN([CF_CURSES_HEADER],[
927 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
928 cf_cv_ncurses_header=none
929 for cf_header in \
930         ncurses.h ifelse($1,,,[$1/ncurses.h]) \
931         curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
932 do
933 AC_TRY_COMPILE([#include <${cf_header}>],
934         [initscr(); tgoto("?", 0,0)],
935         [cf_cv_ncurses_header=$cf_header; break],[])
936 done
937 ])
938
939 if test "$cf_cv_ncurses_header" = none ; then
940         AC_MSG_ERROR(No curses header-files found)
941 fi
942
943 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
944 AC_CHECK_HEADERS($cf_cv_ncurses_header)
945 ])dnl
946 dnl ---------------------------------------------------------------------------
947 dnl CF_CURSES_LIBS version: 44 updated: 2021/01/02 09:31:20
948 dnl --------------
949 dnl Look for the curses libraries.  Older curses implementations may require
950 dnl termcap/termlib to be linked as well.  Call CF_CURSES_CPPFLAGS first.
951 AC_DEFUN([CF_CURSES_LIBS],[
952
953 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
954 AC_MSG_CHECKING(if we have identified curses libraries)
955 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
956         [initscr(); tgoto("?", 0,0)],
957         cf_result=yes,
958         cf_result=no)
959 AC_MSG_RESULT($cf_result)
960
961 if test "$cf_result" = no ; then
962 case "$host_os" in
963 (freebsd*)
964         AC_CHECK_LIB(mytinfo,tgoto,[CF_ADD_LIBS(-lmytinfo)])
965         ;;
966 (hpux10.*)
967         # Looking at HPUX 10.20, the Hcurses library is the oldest (1997), cur_colr
968         # next (1998), and xcurses "newer" (2000).  There is no header file for
969         # Hcurses; the subdirectory curses_colr has the headers (curses.h and
970         # term.h) for cur_colr
971         if test "x$cf_cv_screen" = "xcurses_colr"
972         then
973                 AC_CHECK_LIB(cur_colr,initscr,[
974                         CF_ADD_LIBS(-lcur_colr)
975                         ac_cv_func_initscr=yes
976                         ],[
977                 AC_CHECK_LIB(Hcurses,initscr,[
978                         # HP's header uses __HP_CURSES, but user claims _HP_CURSES.
979                         CF_ADD_LIBS(-lHcurses)
980                         CF_APPEND_TEXT(CPPFLAGS,-D__HP_CURSES -D_HP_CURSES)
981                         ac_cv_func_initscr=yes
982                         ])])
983         fi
984         ;;
985 (linux*)
986         case `arch 2>/dev/null` in
987         (x86_64)
988                 if test -d /lib64
989                 then
990                         CF_ADD_LIBDIR(/lib64)
991                 else
992                         CF_ADD_LIBDIR(/lib)
993                 fi
994                 ;;
995         (*)
996                 CF_ADD_LIBDIR(/lib)
997                 ;;
998         esac
999         ;;
1000 (sunos3*|sunos4*)
1001         if test "x$cf_cv_screen" = "xcurses_5lib"
1002         then
1003                 if test -d /usr/5lib ; then
1004                         CF_ADD_LIBDIR(/usr/5lib)
1005                         CF_ADD_LIBS(-lcurses -ltermcap)
1006                 fi
1007         fi
1008         ac_cv_func_initscr=yes
1009         ;;
1010 esac
1011
1012 if test ".$ac_cv_func_initscr" != .yes ; then
1013         cf_save_LIBS="$LIBS"
1014
1015         if test ".${cf_cv_ncurses_version:-no}" != .no
1016         then
1017                 cf_check_list="ncurses curses cursesX"
1018         else
1019                 cf_check_list="cursesX curses ncurses"
1020         fi
1021
1022         # Check for library containing tgoto.  Do this before curses library
1023         # because it may be needed to link the test-case for initscr.
1024         if test "x$cf_term_lib" = x
1025         then
1026                 AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[
1027                         for cf_term_lib in $cf_check_list otermcap termcap tinfo termlib unknown
1028                         do
1029                                 AC_CHECK_LIB($cf_term_lib,tgoto,[
1030                                         : "${cf_nculib_root:=$cf_term_lib}"
1031                                         break
1032                                 ])
1033                         done
1034                 ])
1035         fi
1036
1037         # Check for library containing initscr
1038         test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS"
1039         if test "x$cf_curs_lib" = x
1040         then
1041                 for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown
1042                 do
1043                         LIBS="-l$cf_curs_lib $cf_save_LIBS"
1044                         if test "$cf_term_lib" = unknown || test "$cf_term_lib" = "$cf_curs_lib" ; then
1045                                 AC_MSG_CHECKING(if we can link with $cf_curs_lib library)
1046                                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1047                                         [initscr()],
1048                                         [cf_result=yes],
1049                                         [cf_result=no])
1050                                 AC_MSG_RESULT($cf_result)
1051                                 test "$cf_result" = yes && break
1052                         elif test "$cf_curs_lib" = "$cf_term_lib" ; then
1053                                 cf_result=no
1054                         elif test "$cf_term_lib" != predefined ; then
1055                                 AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries)
1056                                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1057                                         [initscr(); tgoto((char *)0, 0, 0);],
1058                                         [cf_result=no],
1059                                         [
1060                                         LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS"
1061                                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
1062                                                 [initscr()],
1063                                                 [cf_result=yes],
1064                                                 [cf_result=error])
1065                                         ])
1066                                 AC_MSG_RESULT($cf_result)
1067                                 test "$cf_result" != error && break
1068                         fi
1069                 done
1070         fi
1071         test "$cf_curs_lib" = unknown && AC_MSG_ERROR(no curses library found)
1072 fi
1073 fi
1074
1075 ])dnl
1076 dnl ---------------------------------------------------------------------------
1077 dnl CF_CURSES_TERM_H version: 15 updated: 2021/01/02 09:31:20
1078 dnl ----------------
1079 dnl SVr4 curses should have term.h as well (where it puts the definitions of
1080 dnl the low-level interface).  This may not be true in old/broken implementations,
1081 dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4
1082 dnl running with Solaris 2.5.1).
1083 AC_DEFUN([CF_CURSES_TERM_H],
1084 [
1085 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1086
1087 AC_CACHE_CHECK(for term.h, cf_cv_term_header,[
1088
1089 # If we found <ncurses/curses.h>, look for <ncurses/term.h>, but always look
1090 # for <term.h> if we do not find the variant.
1091
1092 cf_header_list="term.h ncurses/term.h ncursesw/term.h"
1093
1094 case "${cf_cv_ncurses_header:-curses.h}" in
1095 (*/*)
1096         cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`term.h
1097         cf_header_list="$cf_header_item $cf_header_list"
1098         ;;
1099 esac
1100
1101 for cf_header in $cf_header_list
1102 do
1103         AC_TRY_COMPILE([
1104 #include <${cf_cv_ncurses_header:-curses.h}>
1105 #include <${cf_header}>],
1106         [WINDOW *x; (void)x],
1107         [cf_cv_term_header=$cf_header
1108          break],
1109         [cf_cv_term_header=no])
1110 done
1111
1112 case "$cf_cv_term_header" in
1113 (no)
1114         # If curses is ncurses, some packagers still mess it up by trying to make
1115         # us use GNU termcap.  This handles the most common case.
1116         for cf_header in ncurses/term.h ncursesw/term.h
1117         do
1118                 AC_TRY_COMPILE([
1119 #include <${cf_cv_ncurses_header:-curses.h}>
1120 #ifdef NCURSES_VERSION
1121 #include <${cf_header}>
1122 #else
1123 make an error
1124 #endif],
1125                         [WINDOW *x; (void)x],
1126                         [cf_cv_term_header=$cf_header
1127                          break],
1128                         [cf_cv_term_header=no])
1129         done
1130         ;;
1131 esac
1132 ])
1133
1134 case "$cf_cv_term_header" in
1135 (term.h)
1136         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
1137         ;;
1138 (ncurses/term.h)
1139         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
1140         ;;
1141 (ncursesw/term.h)
1142         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
1143         ;;
1144 esac
1145 ])dnl
1146 dnl ---------------------------------------------------------------------------
1147 dnl CF_CURSES_UNCTRL_H version: 8 updated: 2021/01/02 09:31:20
1148 dnl ------------------
1149 dnl Any X/Open curses implementation must have unctrl.h, but ncurses packages
1150 dnl may put it in a subdirectory (along with ncurses' other headers, of
1151 dnl course).  Packages which put the headers in inconsistent locations are
1152 dnl broken).
1153 AC_DEFUN([CF_CURSES_UNCTRL_H],
1154 [
1155 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
1156
1157 AC_CACHE_CHECK(for unctrl.h, cf_cv_unctrl_header,[
1158
1159 # If we found <ncurses/curses.h>, look for <ncurses/unctrl.h>, but always look
1160 # for <unctrl.h> if we do not find the variant.
1161
1162 cf_header_list="unctrl.h ncurses/unctrl.h ncursesw/unctrl.h"
1163
1164 case "${cf_cv_ncurses_header:-curses.h}" in
1165 (*/*)
1166         cf_header_item=`echo "${cf_cv_ncurses_header:-curses.h}" | sed -e 's%\..*%%' -e 's%/.*%/%'`unctrl.h
1167         cf_header_list="$cf_header_item $cf_header_list"
1168         ;;
1169 esac
1170
1171 for cf_header in $cf_header_list
1172 do
1173         AC_TRY_COMPILE([
1174 #include <${cf_cv_ncurses_header:-curses.h}>
1175 #include <${cf_header}>],
1176         [WINDOW *x; (void)x],
1177         [cf_cv_unctrl_header=$cf_header
1178          break],
1179         [cf_cv_unctrl_header=no])
1180 done
1181 ])
1182
1183 case "$cf_cv_unctrl_header" in
1184 (no)
1185         AC_MSG_WARN(unctrl.h header not found)
1186         ;;
1187 esac
1188
1189 case "$cf_cv_unctrl_header" in
1190 (unctrl.h)
1191         AC_DEFINE(HAVE_UNCTRL_H,1,[Define to 1 if we have unctrl.h])
1192         ;;
1193 (ncurses/unctrl.h)
1194         AC_DEFINE(HAVE_NCURSES_UNCTRL_H,1,[Define to 1 if we have ncurses/unctrl.h])
1195         ;;
1196 (ncursesw/unctrl.h)
1197         AC_DEFINE(HAVE_NCURSESW_UNCTRL_H,1,[Define to 1 if we have ncursesw/unctrl.h])
1198         ;;
1199 esac
1200 ])dnl
1201 dnl ---------------------------------------------------------------------------
1202 dnl CF_CURSES_WACS_MAP version: 8 updated: 2021/01/04 19:45:09
1203 dnl ------------------
1204 dnl Check for likely values of wacs_map[].
1205 AC_DEFUN([CF_CURSES_WACS_MAP],
1206 [
1207 AC_CACHE_CHECK(for wide alternate character set array, cf_cv_curses_wacs_map,[
1208         cf_cv_curses_wacs_map=unknown
1209         for name in wacs_map _wacs_map __wacs_map _nc_wacs _wacs_char
1210         do
1211         AC_TRY_LINK([
1212 #ifndef _XOPEN_SOURCE_EXTENDED
1213 #define _XOPEN_SOURCE_EXTENDED
1214 #endif
1215 #include <${cf_cv_ncurses_header:-curses.h}>],
1216         [void *foo = &(${name}['k']); (void)foo],
1217         [cf_cv_curses_wacs_map=$name
1218          break])
1219         done])
1220
1221 test "$cf_cv_curses_wacs_map" != unknown && AC_DEFINE_UNQUOTED(CURSES_WACS_ARRAY,$cf_cv_curses_wacs_map,[Define to name of (n)curses wide-character array])
1222 ])dnl
1223 dnl ---------------------------------------------------------------------------
1224 dnl CF_CURSES_WACS_SYMBOLS version: 4 updated: 2021/01/04 19:45:09
1225 dnl ----------------------
1226 dnl Do a check to see if the WACS_xxx constants are defined compatibly with
1227 dnl X/Open Curses.  In particular, NetBSD's implementation of the WACS_xxx
1228 dnl constants is broken since those constants do not point to cchar_t's.
1229 AC_DEFUN([CF_CURSES_WACS_SYMBOLS],
1230 [
1231 AC_REQUIRE([CF_CURSES_WACS_MAP])
1232
1233 AC_CACHE_CHECK(for wide alternate character constants, cf_cv_curses_wacs_symbols,[
1234 cf_cv_curses_wacs_symbols=no
1235 if test "$cf_cv_curses_wacs_map" != unknown
1236 then
1237         AC_TRY_LINK([
1238 #ifndef _XOPEN_SOURCE_EXTENDED
1239 #define _XOPEN_SOURCE_EXTENDED
1240 #endif
1241 #include <${cf_cv_ncurses_header:-curses.h}>],
1242         [cchar_t *foo = WACS_PLUS;
1243          ${cf_cv_curses_wacs_map}['k'] = *WACS_PLUS; (void)foo],
1244         [cf_cv_curses_wacs_symbols=yes])
1245 else
1246         AC_TRY_LINK([
1247 #ifndef _XOPEN_SOURCE_EXTENDED
1248 #define _XOPEN_SOURCE_EXTENDED
1249 #endif
1250 #include <${cf_cv_ncurses_header:-curses.h}>],
1251         [cchar_t *foo = WACS_PLUS; (void)foo],
1252         [cf_cv_curses_wacs_symbols=yes])
1253 fi
1254 ])
1255
1256 test "$cf_cv_curses_wacs_symbols" != no && AC_DEFINE(CURSES_WACS_SYMBOLS,1,[Define to 1 if (n)curses supports wide-character WACS_ symbols])
1257 ])dnl
1258 dnl ---------------------------------------------------------------------------
1259 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
1260 dnl ----------
1261 dnl "dirname" is not portable, so we fake it with a shell script.
1262 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
1263 dnl ---------------------------------------------------------------------------
1264 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1265 dnl ---------------
1266 dnl You can always use "make -n" to see the actual options, but it's hard to
1267 dnl pick out/analyze warning messages when the compile-line is long.
1268 dnl
1269 dnl Sets:
1270 dnl     ECHO_LT - symbol to control if libtool is verbose
1271 dnl     ECHO_LD - symbol to prefix "cc -o" lines
1272 dnl     RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1273 dnl     SHOW_CC - symbol to put before explicit "cc -c" lines
1274 dnl     ECHO_CC - symbol to put before any "cc" line
1275 dnl
1276 AC_DEFUN([CF_DISABLE_ECHO],[
1277 AC_MSG_CHECKING(if you want to see long compiling messages)
1278 CF_ARG_DISABLE(echo,
1279         [  --disable-echo          do not display "compiling" commands],
1280         [
1281         ECHO_LT='--silent'
1282         ECHO_LD='@echo linking [$]@;'
1283         RULE_CC='@echo compiling [$]<'
1284         SHOW_CC='@echo compiling [$]@'
1285         ECHO_CC='@'
1286 ],[
1287         ECHO_LT=''
1288         ECHO_LD=''
1289         RULE_CC=''
1290         SHOW_CC=''
1291         ECHO_CC=''
1292 ])
1293 AC_MSG_RESULT($enableval)
1294 AC_SUBST(ECHO_LT)
1295 AC_SUBST(ECHO_LD)
1296 AC_SUBST(RULE_CC)
1297 AC_SUBST(SHOW_CC)
1298 AC_SUBST(ECHO_CC)
1299 ])dnl
1300 dnl ---------------------------------------------------------------------------
1301 dnl CF_DISABLE_LEAKS version: 8 updated: 2021/01/05 20:05:09
1302 dnl ----------------
1303 dnl Combine no-leak checks with the libraries or tools that are used for the
1304 dnl checks.
1305 AC_DEFUN([CF_DISABLE_LEAKS],[
1306
1307 AC_REQUIRE([CF_WITH_DMALLOC])
1308 AC_REQUIRE([CF_WITH_DBMALLOC])
1309 AC_REQUIRE([CF_WITH_VALGRIND])
1310
1311 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1312 AC_ARG_ENABLE(leaks,
1313         [  --disable-leaks         test: free permanent memory, analyze leaks],
1314         [enable_leaks=no],
1315         [enable_leaks=yes])
1316 dnl TODO - drop with_no_leaks
1317 if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi
1318 AC_MSG_RESULT($with_no_leaks)
1319
1320 if test "$enable_leaks" = no ; then
1321         AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1322         AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1323 fi
1324 ])dnl
1325 dnl ---------------------------------------------------------------------------
1326 dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44
1327 dnl ---------------------
1328 dnl The rpath-hack makes it simpler to build programs, particularly with the
1329 dnl *BSD ports which may have essential libraries in unusual places.  But it
1330 dnl can interfere with building an executable for the base system.  Use this
1331 dnl option in that case.
1332 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1333 [
1334 AC_MSG_CHECKING(if rpath-hack should be disabled)
1335 CF_ARG_DISABLE(rpath-hack,
1336         [  --disable-rpath-hack    don't add rpath options for additional libraries],
1337         [enable_rpath_hack=no],
1338         [enable_rpath_hack=yes])
1339 dnl TODO - drop cf_disable_rpath_hack
1340 if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi
1341 AC_MSG_RESULT($cf_disable_rpath_hack)
1342
1343 if test "$enable_rpath_hack" = yes ; then
1344         CF_RPATH_HACK
1345 fi
1346 ])
1347 dnl ---------------------------------------------------------------------------
1348 dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48
1349 dnl ----------------------
1350 dnl On a few platforms, the compiler and/or loader nags with untruthful
1351 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1352 dnl and implying that most uses of the recommended alternatives are correct.
1353 dnl
1354 dnl Factually speaking, no one has actually counted the number of uses of these
1355 dnl functions versus the total of incorrect uses.  Samples of a few thousand
1356 dnl instances are meaningless compared to the hundreds of millions of lines of
1357 dnl existing C code.
1358 dnl
1359 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1360 dnl platforms, in implementations of varying quality.  Likewise, snprintf is
1361 dnl standard - but evolved through phases, and older implementations are likely
1362 dnl to yield surprising results, as documented in manpages on various systems.
1363 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1364 [
1365 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1366 AC_ARG_ENABLE(string-hacks,
1367         [  --enable-string-hacks   work around bogus compiler/loader warnings],
1368         [enable_string_hacks=$enableval],
1369         [enable_string_hacks=no])
1370 AC_MSG_RESULT($enable_string_hacks)
1371
1372 if test "x$enable_string_hacks" = "xyes"; then
1373         AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1374         AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1375         AC_CHECK_FUNC(strlcat,[
1376                 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1377                 ],[
1378                 AC_CHECK_LIB(bsd,strlcat,[
1379                         CF_ADD_LIB(bsd)
1380                         AC_CHECK_HEADERS(bsd/string.h)
1381                         AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1382                         ])
1383                 ])
1384         AC_CHECK_FUNCS( strlcpy snprintf )
1385 fi
1386 ])dnl
1387 dnl ---------------------------------------------------------------------------
1388 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1389 dnl ------------------
1390 dnl Configure-option to enable gcc warnings
1391 dnl
1392 dnl $1 = extra options to add, if supported
1393 dnl $2 = option for checking attributes.  By default, this is done when
1394 dnl      warnings are enabled.  For other values:
1395 dnl      yes: always do this, e.g., to use in generated library-headers
1396 dnl      no: never do this
1397 AC_DEFUN([CF_ENABLE_WARNINGS],[
1398 if test "$GCC" = yes || test "$GXX" = yes
1399 then
1400 CF_FIX_WARNINGS(CFLAGS)
1401 CF_FIX_WARNINGS(CPPFLAGS)
1402 CF_FIX_WARNINGS(LDFLAGS)
1403 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1404 CF_ARG_ENABLE(warnings,
1405         [  --enable-warnings       test: turn on gcc compiler warnings],
1406         [enable_warnings=yes],
1407         [enable_warnings=no])
1408 AC_MSG_RESULT($enable_warnings)
1409 if test "$enable_warnings" = "yes"
1410 then
1411         ifelse($2,,[CF_GCC_ATTRIBUTES])
1412         CF_GCC_WARNINGS($1)
1413 fi
1414 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1415 fi
1416 ])dnl
1417 dnl ---------------------------------------------------------------------------
1418 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1419 dnl ---------------
1420 dnl Look for a non-standard library, given parameters for AC_TRY_LINK.  We
1421 dnl prefer a standard location, and use -L options only if we do not find the
1422 dnl library in the standard library location(s).
1423 dnl     $1 = library name
1424 dnl     $2 = library class, usually the same as library name
1425 dnl     $3 = includes
1426 dnl     $4 = code fragment to compile/link
1427 dnl     $5 = corresponding function-name
1428 dnl     $6 = flag, nonnull if failure should not cause an error-exit
1429 dnl
1430 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1431 dnl to use a -L option.
1432 AC_DEFUN([CF_FIND_LIBRARY],
1433 [
1434         eval 'cf_cv_have_lib_'"$1"'=no'
1435         cf_libdir=""
1436         AC_CHECK_FUNC($5,
1437                 eval 'cf_cv_have_lib_'"$1"'=yes',[
1438                 cf_save_LIBS="$LIBS"
1439                 AC_MSG_CHECKING(for $5 in -l$1)
1440                 LIBS="-l$1 $LIBS"
1441                 AC_TRY_LINK([$3],[$4],
1442                         [AC_MSG_RESULT(yes)
1443                          eval 'cf_cv_have_lib_'"$1"'=yes'
1444                         ],
1445                         [AC_MSG_RESULT(no)
1446                         CF_LIBRARY_PATH(cf_search,$2)
1447                         for cf_libdir in $cf_search
1448                         do
1449                                 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1450                                 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1451                                 AC_TRY_LINK([$3],[$4],
1452                                         [AC_MSG_RESULT(yes)
1453                                          eval 'cf_cv_have_lib_'"$1"'=yes'
1454                                          break],
1455                                         [AC_MSG_RESULT(no)
1456                                          LIBS="$cf_save_LIBS"])
1457                         done
1458                         ])
1459                 ])
1460 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1461 ifelse($6,,[
1462 if test "$cf_found_library" = no ; then
1463         AC_MSG_ERROR(Cannot link $1 library)
1464 fi
1465 ])
1466 ])dnl
1467 dnl ---------------------------------------------------------------------------
1468 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1469 dnl ---------------
1470 dnl Find a library (specifically the linkage used in the code fragment),
1471 dnl searching for it if it is not already in the library path.
1472 dnl See also CF_ADD_SEARCHPATH.
1473 dnl
1474 dnl Parameters (4-on are optional):
1475 dnl     $1 = headers for library entrypoint
1476 dnl     $2 = code fragment for library entrypoint
1477 dnl     $3 = the library name without the "-l" option or ".so" suffix.
1478 dnl     $4 = action to perform if successful (default: update CPPFLAGS, etc)
1479 dnl     $5 = action to perform if not successful
1480 dnl     $6 = module name, if not the same as the library name
1481 dnl     $7 = extra libraries
1482 dnl
1483 dnl Sets these variables:
1484 dnl     $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1485 dnl     $cf_cv_header_path_$3 - include-directory if needed
1486 dnl     $cf_cv_library_path_$3 - library-directory if needed
1487 dnl     $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1488 AC_DEFUN([CF_FIND_LINKAGE],[
1489
1490 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1491 # will be set on completion of the AC_TRY_LINK below.
1492 cf_cv_header_path_$3=
1493 cf_cv_library_path_$3=
1494
1495 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1496
1497 cf_save_LIBS="$LIBS"
1498
1499 AC_TRY_LINK([$1],[$2],[
1500         cf_cv_find_linkage_$3=yes
1501         cf_cv_header_path_$3=/usr/include
1502         cf_cv_library_path_$3=/usr/lib
1503 ],[
1504
1505 LIBS="-l$3 $7 $cf_save_LIBS"
1506
1507 AC_TRY_LINK([$1],[$2],[
1508         cf_cv_find_linkage_$3=yes
1509         cf_cv_header_path_$3=/usr/include
1510         cf_cv_library_path_$3=/usr/lib
1511         cf_cv_library_file_$3="-l$3"
1512 ],[
1513         cf_cv_find_linkage_$3=no
1514         LIBS="$cf_save_LIBS"
1515
1516         CF_VERBOSE(find linkage for $3 library)
1517         CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1518
1519         cf_save_CPPFLAGS="$CPPFLAGS"
1520         cf_test_CPPFLAGS="$CPPFLAGS"
1521
1522         CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1523         for cf_cv_header_path_$3 in $cf_search
1524         do
1525                 if test -d "$cf_cv_header_path_$3" ; then
1526                         CF_VERBOSE(... testing $cf_cv_header_path_$3)
1527                         CPPFLAGS="$cf_save_CPPFLAGS"
1528                         CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1529                         AC_TRY_COMPILE([$1],[$2],[
1530                                 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1531                                 cf_cv_find_linkage_$3=maybe
1532                                 cf_test_CPPFLAGS="$CPPFLAGS"
1533                                 break],[
1534                                 CPPFLAGS="$cf_save_CPPFLAGS"
1535                                 ])
1536                 fi
1537         done
1538
1539         if test "$cf_cv_find_linkage_$3" = maybe ; then
1540
1541                 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1542
1543                 cf_save_LIBS="$LIBS"
1544                 cf_save_LDFLAGS="$LDFLAGS"
1545
1546                 ifelse([$6],,,[
1547                 CPPFLAGS="$cf_test_CPPFLAGS"
1548                 LIBS="-l$3 $7 $cf_save_LIBS"
1549                 AC_TRY_LINK([$1],[$2],[
1550                         CF_VERBOSE(... found $3 library in system)
1551                         cf_cv_find_linkage_$3=yes])
1552                         CPPFLAGS="$cf_save_CPPFLAGS"
1553                         LIBS="$cf_save_LIBS"
1554                         ])
1555
1556                 if test "$cf_cv_find_linkage_$3" != yes ; then
1557                         CF_LIBRARY_PATH(cf_search,$3)
1558                         for cf_cv_library_path_$3 in $cf_search
1559                         do
1560                                 if test -d "$cf_cv_library_path_$3" ; then
1561                                         CF_VERBOSE(... testing $cf_cv_library_path_$3)
1562                                         CPPFLAGS="$cf_test_CPPFLAGS"
1563                                         LIBS="-l$3 $7 $cf_save_LIBS"
1564                                         LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1565                                         AC_TRY_LINK([$1],[$2],[
1566                                         CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1567                                         cf_cv_find_linkage_$3=yes
1568                                         cf_cv_library_file_$3="-l$3"
1569                                         break],[
1570                                         CPPFLAGS="$cf_save_CPPFLAGS"
1571                                         LIBS="$cf_save_LIBS"
1572                                         LDFLAGS="$cf_save_LDFLAGS"
1573                                         ])
1574                                 fi
1575                         done
1576                         CPPFLAGS="$cf_save_CPPFLAGS"
1577                         LDFLAGS="$cf_save_LDFLAGS"
1578                 fi
1579
1580         else
1581                 cf_cv_find_linkage_$3=no
1582         fi
1583         ],$7)
1584 ])
1585
1586 LIBS="$cf_save_LIBS"
1587
1588 if test "$cf_cv_find_linkage_$3" = yes ; then
1589 ifelse([$4],,[
1590         CF_ADD_INCDIR($cf_cv_header_path_$3)
1591         CF_ADD_LIBDIR($cf_cv_library_path_$3)
1592         CF_ADD_LIB($3)
1593 ],[$4])
1594 else
1595 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1596 fi
1597 ])dnl
1598 dnl ---------------------------------------------------------------------------
1599 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1600 dnl ---------------
1601 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc.  Any of gcc's
1602 dnl "-Werror" flags can interfere with configure-checks.  Those go into
1603 dnl EXTRA_CFLAGS.
1604 dnl
1605 dnl $1 = variable name to repair
1606 define([CF_FIX_WARNINGS],[
1607 if test "$GCC" = yes || test "$GXX" = yes
1608 then
1609         case [$]$1 in
1610         (*-Werror=*)
1611                 CF_VERBOSE(repairing $1: [$]$1)
1612                 cf_temp_flags=
1613                 for cf_temp_scan in [$]$1
1614                 do
1615                         case "x$cf_temp_scan" in
1616                         (x-Werror=*)
1617                                 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1618                                 ;;
1619                         (*)
1620                                 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1621                                 ;;
1622                         esac
1623                 done
1624                 $1="$cf_temp_flags"
1625                 CF_VERBOSE(... fixed [$]$1)
1626                 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1627                 ;;
1628         esac
1629 fi
1630 AC_SUBST(EXTRA_CFLAGS)
1631 ])dnl
1632 dnl ---------------------------------------------------------------------------
1633 dnl CF_FUNC_CURSES_VERSION version: 8 updated: 2021/01/02 09:31:20
1634 dnl ----------------------
1635 dnl Solaris has a data item 'curses_version', which confuses AC_CHECK_FUNCS.
1636 dnl It's a character string "SVR4", not documented.
1637 AC_DEFUN([CF_FUNC_CURSES_VERSION],
1638 [
1639 AC_CACHE_CHECK(for function curses_version, cf_cv_func_curses_version,[
1640 AC_TRY_RUN([
1641 #include <${cf_cv_ncurses_header:-curses.h}>
1642 int main(void)
1643 {
1644         char temp[1024];
1645         sprintf(temp, "%s\\n", curses_version());
1646         ${cf_cv_main_return:-return}(0);
1647 }]
1648 ,[cf_cv_func_curses_version=yes]
1649 ,[cf_cv_func_curses_version=no]
1650 ,[cf_cv_func_curses_version=unknown])
1651 rm -f core])
1652 test "$cf_cv_func_curses_version" = yes && AC_DEFINE(HAVE_CURSES_VERSION,1,[Define to 1 if we have curses_version function])
1653 ])
1654 dnl ---------------------------------------------------------------------------
1655 dnl CF_FUNC_OPENPTY version: 6 updated: 2021/01/01 13:31:04
1656 dnl ---------------
1657 dnl Check for openpty() function, along with <pty.h> header.  It may need the
1658 dnl "util" library as well.
1659 AC_DEFUN([CF_FUNC_OPENPTY],
1660 [
1661 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
1662 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
1663         cf_save_LIBS="$LIBS"
1664         test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) }
1665         for cf_header in pty.h libutil.h util.h
1666         do
1667         AC_TRY_LINK([
1668 #include <$cf_header>
1669 ],[
1670         int x = openpty((int *)0, (int *)0, (char *)0,
1671                                    (struct termios *)0, (struct winsize *)0);
1672 ],[
1673                 cf_cv_func_openpty=$cf_header
1674                 break
1675 ],[
1676                 cf_cv_func_openpty=no
1677 ])
1678         done
1679         LIBS="$cf_save_LIBS"
1680 ])
1681 ])dnl
1682 dnl ---------------------------------------------------------------------------
1683 dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25
1684 dnl -----------------
1685 dnl Test for availability of useful gcc __attribute__ directives to quiet
1686 dnl compiler warnings.  Though useful, not all are supported -- and contrary
1687 dnl to documentation, unrecognized directives cause older compilers to barf.
1688 AC_DEFUN([CF_GCC_ATTRIBUTES],
1689 [AC_REQUIRE([AC_PROG_FGREP])dnl
1690 AC_REQUIRE([CF_C11_NORETURN])dnl
1691
1692 if test "$GCC" = yes || test "$GXX" = yes
1693 then
1694 cat > conftest.i <<EOF
1695 #ifndef GCC_PRINTF
1696 #define GCC_PRINTF 0
1697 #endif
1698 #ifndef GCC_SCANF
1699 #define GCC_SCANF 0
1700 #endif
1701 #ifndef GCC_NORETURN
1702 #define GCC_NORETURN /* nothing */
1703 #endif
1704 #ifndef GCC_UNUSED
1705 #define GCC_UNUSED /* nothing */
1706 #endif
1707 EOF
1708 if test "$GCC" = yes
1709 then
1710         AC_CHECKING([for $CC __attribute__ directives])
1711 cat > "conftest.$ac_ext" <<EOF
1712 #line __oline__ "${as_me:-configure}"
1713 #include "confdefs.h"
1714 #include "conftest.h"
1715 #include "conftest.i"
1716 #if     GCC_PRINTF
1717 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1718 #else
1719 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1720 #endif
1721 #if     GCC_SCANF
1722 #define GCC_SCANFLIKE(fmt,var)  __attribute__((format(scanf,fmt,var)))
1723 #else
1724 #define GCC_SCANFLIKE(fmt,var)  /*nothing*/
1725 #endif
1726 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1727 extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2);
1728 extern GCC_NORETURN void foo(void);
1729 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1730 EOF
1731         cf_printf_attribute=no
1732         cf_scanf_attribute=no
1733         for cf_attribute in scanf printf unused noreturn
1734         do
1735                 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1736                 cf_directive="__attribute__(($cf_attribute))"
1737                 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1738
1739                 case "$cf_attribute" in
1740                 (printf)
1741                         cf_printf_attribute=yes
1742                         cat >conftest.h <<EOF
1743 #define GCC_$cf_ATTRIBUTE 1
1744 EOF
1745                         ;;
1746                 (scanf)
1747                         cf_scanf_attribute=yes
1748                         cat >conftest.h <<EOF
1749 #define GCC_$cf_ATTRIBUTE 1
1750 EOF
1751                         ;;
1752                 (*)
1753                         cat >conftest.h <<EOF
1754 #define GCC_$cf_ATTRIBUTE $cf_directive
1755 EOF
1756                         ;;
1757                 esac
1758
1759                 if AC_TRY_EVAL(ac_compile); then
1760                         test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1761                         cat conftest.h >>confdefs.h
1762                         case "$cf_attribute" in
1763                         (noreturn)
1764                                 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1765                                 ;;
1766                         (printf)
1767                                 cf_value='/* nothing */'
1768                                 if test "$cf_printf_attribute" != no ; then
1769                                         cf_value='__attribute__((format(printf,fmt,var)))'
1770                                         AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1771                                 fi
1772                                 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1773                                 ;;
1774                         (scanf)
1775                                 cf_value='/* nothing */'
1776                                 if test "$cf_scanf_attribute" != no ; then
1777                                         cf_value='__attribute__((format(scanf,fmt,var)))'
1778                                         AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1779                                 fi
1780                                 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1781                                 ;;
1782                         (unused)
1783                                 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1784                                 ;;
1785                         esac
1786                 fi
1787         done
1788 else
1789         ${FGREP-fgrep} define conftest.i >>confdefs.h
1790 fi
1791 rm -rf ./conftest*
1792 fi
1793 ])dnl
1794 dnl ---------------------------------------------------------------------------
1795 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1796 dnl --------------
1797 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1798 dnl compatible), attempt to determine if icc/clang is actually used.
1799 AC_DEFUN([CF_GCC_VERSION],[
1800 AC_REQUIRE([AC_PROG_CC])
1801 GCC_VERSION=none
1802 if test "$GCC" = yes ; then
1803         AC_MSG_CHECKING(version of $CC)
1804         GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
1805         test -z "$GCC_VERSION" && GCC_VERSION=unknown
1806         AC_MSG_RESULT($GCC_VERSION)
1807 fi
1808 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1809 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1810 ])dnl
1811 dnl ---------------------------------------------------------------------------
1812 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1813 dnl ---------------
1814 dnl Check if the compiler supports useful warning options.  There's a few that
1815 dnl we don't use, simply because they're too noisy:
1816 dnl
1817 dnl     -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1818 dnl     -Winline (usually not worthwhile)
1819 dnl     -Wredundant-decls (system headers make this too noisy)
1820 dnl     -Wtraditional (combines too many unrelated messages, only a few useful)
1821 dnl     -Wwrite-strings (too noisy, but should review occasionally).  This
1822 dnl             is enabled for ncurses using "--enable-const".
1823 dnl     -pedantic
1824 dnl
1825 dnl Parameter:
1826 dnl     $1 is an optional list of gcc warning flags that a particular
1827 dnl             application might want to use, e.g., "no-unused" for
1828 dnl             -Wno-unused
1829 dnl Special:
1830 dnl     If $with_ext_const is "yes", add a check for -Wwrite-strings
1831 dnl
1832 AC_DEFUN([CF_GCC_WARNINGS],
1833 [
1834 AC_REQUIRE([CF_GCC_VERSION])
1835 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1836 cat > "conftest.$ac_ext" <<EOF
1837 #line __oline__ "${as_me:-configure}"
1838 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1839 EOF
1840 if test "$INTEL_COMPILER" = yes
1841 then
1842 # The "-wdXXX" options suppress warnings:
1843 # remark #1419: external declaration in primary source file
1844 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1845 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1846 # remark #193: zero used for undefined preprocessing identifier
1847 # remark #593: variable "curs_sb_left_arrow" was set but never used
1848 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1849 # remark #869: parameter "tw" was never referenced
1850 # remark #981: operands are evaluated in unspecified order
1851 # warning #279: controlling expression is constant
1852
1853         AC_CHECKING([for $CC warning options])
1854         cf_save_CFLAGS="$CFLAGS"
1855         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1856         for cf_opt in \
1857                 wd1419 \
1858                 wd1683 \
1859                 wd1684 \
1860                 wd193 \
1861                 wd593 \
1862                 wd279 \
1863                 wd810 \
1864                 wd869 \
1865                 wd981
1866         do
1867                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1868                 if AC_TRY_EVAL(ac_compile); then
1869                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1870                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1871                 fi
1872         done
1873         CFLAGS="$cf_save_CFLAGS"
1874 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1875 then
1876         AC_CHECKING([for $CC warning options])
1877         cf_save_CFLAGS="$CFLAGS"
1878         cf_warn_CONST=""
1879         test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1880         cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1881         test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1882         for cf_opt in W Wall \
1883                 Wbad-function-cast \
1884                 Wcast-align \
1885                 Wcast-qual \
1886                 Wdeclaration-after-statement \
1887                 Wextra \
1888                 Winline \
1889                 Wmissing-declarations \
1890                 Wmissing-prototypes \
1891                 Wnested-externs \
1892                 Wpointer-arith \
1893                 Wshadow \
1894                 Wstrict-prototypes \
1895                 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1896         do
1897                 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1898                 if AC_TRY_EVAL(ac_compile); then
1899                         test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1900                         case "$cf_opt" in
1901                         (Winline)
1902                                 case "$GCC_VERSION" in
1903                                 ([[34]].*)
1904                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1905                                         continue;;
1906                                 esac
1907                                 ;;
1908                         (Wpointer-arith)
1909                                 case "$GCC_VERSION" in
1910                                 ([[12]].*)
1911                                         CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1912                                         continue;;
1913                                 esac
1914                                 ;;
1915                         esac
1916                         EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1917                 fi
1918         done
1919         CFLAGS="$cf_save_CFLAGS"
1920 fi
1921 rm -rf ./conftest*
1922
1923 AC_SUBST(EXTRA_CFLAGS)
1924 ])dnl
1925 dnl ---------------------------------------------------------------------------
1926 dnl CF_GETOPT_HEADER version: 7 updated: 2021/01/01 13:31:04
1927 dnl ----------------
1928 dnl Check for getopt's variables which are commonly defined in stdlib.h,
1929 dnl unistd.h or (nonstandard) in getopt.h
1930 AC_DEFUN([CF_GETOPT_HEADER],
1931 [
1932 AC_HAVE_HEADERS(unistd.h getopt.h)
1933 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
1934 cf_cv_getopt_header=none
1935 for cf_header in stdio.h stdlib.h unistd.h getopt.h
1936 do
1937 AC_TRY_COMPILE([
1938 #include <$cf_header>],
1939 [int x = optind; char *y = optarg],
1940 [cf_cv_getopt_header=$cf_header
1941  break])
1942 done
1943 ])
1944 if test "$cf_cv_getopt_header" != none ; then
1945         AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
1946 fi
1947 if test "$cf_cv_getopt_header" = getopt.h ; then
1948         AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
1949 fi
1950 ])dnl
1951 dnl ---------------------------------------------------------------------------
1952 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1953 dnl -------------
1954 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1955 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend.  This is a defect
1956 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1957 dnl since it is interwoven with GNU extensions.
1958 dnl
1959 dnl Well, yes we could work around it...
1960 dnl
1961 dnl Parameters:
1962 dnl     $1 is the nominal value for _XOPEN_SOURCE
1963 AC_DEFUN([CF_GNU_SOURCE],
1964 [
1965 cf_gnu_xopen_source=ifelse($1,,500,$1)
1966
1967 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1968 AC_TRY_COMPILE([#include <sys/types.h>],[
1969         #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1970                 return 0;
1971         #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1972                 return 0;
1973         #else
1974         #       error not GNU C library
1975         #endif],
1976         [cf_cv_gnu_library=yes],
1977         [cf_cv_gnu_library=no])
1978 ])
1979
1980 if test x$cf_cv_gnu_library = xyes; then
1981
1982         # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1983         # was changed to help a little.  newlib incorporated the change about 4
1984         # years later.
1985         AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1986                 cf_save="$CPPFLAGS"
1987                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1988                 AC_TRY_COMPILE([#include <sys/types.h>],[
1989                         #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1990                                 return 0;
1991                         #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1992                                 return 0;
1993                         #else
1994                         #       error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1995                         #endif],
1996                         [cf_cv_gnu_library_219=yes],
1997                         [cf_cv_gnu_library_219=no])
1998                 CPPFLAGS="$cf_save"
1999         ])
2000
2001         if test "x$cf_cv_gnu_library_219" = xyes; then
2002                 cf_save="$CPPFLAGS"
2003                 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
2004                         CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
2005                         AC_TRY_COMPILE([
2006                                 #include <limits.h>
2007                                 #include <sys/types.h>
2008                                 ],[
2009                                 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
2010                                         return 0;
2011                                 #else
2012                                 #       error GNU C library is too old
2013                                 #endif],
2014                                 [cf_cv_gnu_dftsrc_219=yes],
2015                                 [cf_cv_gnu_dftsrc_219=no])
2016                         ])
2017                 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
2018         else
2019                 cf_cv_gnu_dftsrc_219=maybe
2020         fi
2021
2022         if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
2023
2024                 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
2025                 AC_TRY_COMPILE([#include <sys/types.h>],[
2026                         #ifndef _XOPEN_SOURCE
2027                         #error  expected _XOPEN_SOURCE to be defined
2028                         #endif],
2029                         [cf_cv_gnu_source=no],
2030                         [cf_save="$CPPFLAGS"
2031                          CF_ADD_CFLAGS(-D_GNU_SOURCE)
2032                          AC_TRY_COMPILE([#include <sys/types.h>],[
2033                                 #ifdef _XOPEN_SOURCE
2034                                 #error  expected _XOPEN_SOURCE to be undefined
2035                                 #endif],
2036                                 [cf_cv_gnu_source=no],
2037                                 [cf_cv_gnu_source=yes])
2038                         CPPFLAGS="$cf_save"
2039                         ])
2040                 ])
2041
2042                 if test "$cf_cv_gnu_source" = yes
2043                 then
2044                 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
2045                         CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
2046                         AC_TRY_COMPILE([#include <sys/types.h>],[
2047                                 #ifdef _DEFAULT_SOURCE
2048                                 #error  expected _DEFAULT_SOURCE to be undefined
2049                                 #endif],
2050                                 [cf_cv_default_source=no],
2051                                 [cf_cv_default_source=yes])
2052                         ])
2053                         if test "$cf_cv_default_source" = yes
2054                         then
2055                                 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
2056                         fi
2057                 fi
2058         fi
2059
2060 fi
2061 ])dnl
2062 dnl ---------------------------------------------------------------------------
2063 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
2064 dnl --------------
2065 dnl Construct a search-list of directories for a nonstandard header-file
2066 dnl
2067 dnl Parameters
2068 dnl     $1 = the variable to return as result
2069 dnl     $2 = the package name
2070 AC_DEFUN([CF_HEADER_PATH],
2071 [
2072 $1=
2073
2074 # collect the current set of include-directories from compiler flags
2075 cf_header_path_list=""
2076 if test -n "${CFLAGS}${CPPFLAGS}" ; then
2077         for cf_header_path in $CPPFLAGS $CFLAGS
2078         do
2079                 case "$cf_header_path" in
2080                 (-I*)
2081                         cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
2082                         CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
2083                         cf_header_path_list="$cf_header_path_list [$]$1"
2084                         ;;
2085                 esac
2086         done
2087 fi
2088
2089 # add the variations for the package we are looking for
2090 CF_SUBDIR_PATH($1,$2,include)
2091
2092 test "$includedir" != NONE && \
2093 test "$includedir" != "/usr/include" && \
2094 test -d "$includedir" && {
2095         test -d "$includedir" &&    $1="[$]$1 $includedir"
2096         test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
2097 }
2098
2099 test "$oldincludedir" != NONE && \
2100 test "$oldincludedir" != "/usr/include" && \
2101 test -d "$oldincludedir" && {
2102         test -d "$oldincludedir"    && $1="[$]$1 $oldincludedir"
2103         test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
2104 }
2105
2106 $1="[$]$1 $cf_header_path_list"
2107 ])dnl
2108 dnl ---------------------------------------------------------------------------
2109 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
2110 dnl ---------------
2111 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
2112 AC_DEFUN([CF_HELP_MESSAGE],
2113 [CF_ACVERSION_CHECK(2.53,[],[
2114 AC_DIVERT_HELP($1)])dnl
2115 ])dnl
2116 dnl ---------------------------------------------------------------------------
2117 dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42
2118 dnl -----------------
2119 dnl If we do not have a given script, look for it in the parent directory.
2120 AC_DEFUN([CF_INHERIT_SCRIPT],
2121 [
2122 test -f $1 || ( test -f ../$1 && cp ../$1 ./ )
2123 ])dnl
2124 dnl ---------------------------------------------------------------------------
2125 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
2126 dnl ---------------
2127 dnl prompt for/fill-in useful install-program options
2128 AC_DEFUN([CF_INSTALL_OPTS],
2129 [
2130 CF_INSTALL_OPT_S
2131 CF_INSTALL_OPT_P
2132 CF_INSTALL_OPT_O
2133 ])dnl
2134 dnl ---------------------------------------------------------------------------
2135 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
2136 dnl ----------------
2137 dnl Almost all "install" programs default to the current user's ownership.
2138 dnl Almost - MINIX is an exception.
2139 AC_DEFUN([CF_INSTALL_OPT_O],
2140 [
2141 AC_MSG_CHECKING(if install needs to be told about ownership)
2142 case `$ac_config_guess` in
2143 (*minix)
2144         with_install_o=yes
2145         ;;
2146 (*)
2147         with_install_o=no
2148         ;;
2149 esac
2150
2151 AC_MSG_RESULT($with_install_o)
2152 if test "x$with_install_o" = xyes
2153 then
2154         INSTALL_OPT_O="`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`"
2155 else
2156         INSTALL_OPT_O=
2157 fi
2158
2159 AC_SUBST(INSTALL_OPT_O)
2160 ])dnl
2161 dnl ---------------------------------------------------------------------------
2162 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2163 dnl ----------------
2164 dnl Some install-programs accept a "-p" option to preserve file modification
2165 dnl timestamps.  That can be useful as an install option, as well as a way to
2166 dnl avoid the need for ranlib after copying a static archive.
2167 AC_DEFUN([CF_INSTALL_OPT_P],
2168 [
2169 : "${INSTALL:=install}"
2170 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2171         rm -rf ./conftest*
2172         date >conftest.in
2173         mkdir conftest.out
2174         sleep 3
2175         if $INSTALL -p conftest.in conftest.out 2>/dev/null
2176         then
2177                 if test -f conftest.out/conftest.in
2178                 then
2179                         test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2180                         test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2181                         if test -s conftest.err
2182                         then
2183                                 cf_cv_install_p=no
2184                         else
2185                                 cf_cv_install_p=yes
2186                         fi
2187                 else
2188                         cf_cv_install_p=no
2189                 fi
2190         else
2191                 cf_cv_install_p=no
2192         fi
2193         rm -rf ./conftest*
2194 ])
2195 ])dnl
2196 dnl ---------------------------------------------------------------------------
2197 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2198 dnl ----------------
2199 dnl By default, we should strip executables which are installed, but leave the
2200 dnl ability to suppress that for unit-testing.
2201 AC_DEFUN([CF_INSTALL_OPT_S],
2202 [
2203 AC_MSG_CHECKING(if you want to install stripped executables)
2204 CF_ARG_DISABLE(stripping,
2205         [  --disable-stripping     do not strip (debug info) installed executables],
2206         [enable_stripping=no],
2207         [enable_stripping=yes])
2208 AC_MSG_RESULT($enable_stripping)
2209
2210 if test "$enable_stripping" = yes
2211 then
2212         INSTALL_OPT_S="-s"
2213 else
2214         INSTALL_OPT_S=
2215 fi
2216 AC_SUBST(INSTALL_OPT_S)
2217 ])dnl
2218 dnl ---------------------------------------------------------------------------
2219 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2220 dnl -----------------
2221 dnl Check if the given compiler is really the Intel compiler for Linux.  It
2222 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2223 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2224 dnl
2225 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2226 dnl ensure that it is not mistaken for gcc/g++.  It is normally invoked from
2227 dnl the wrappers for gcc and g++ warnings.
2228 dnl
2229 dnl $1 = GCC (default) or GXX
2230 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2231 dnl $3 = CFLAGS (default) or CXXFLAGS
2232 AC_DEFUN([CF_INTEL_COMPILER],[
2233 AC_REQUIRE([AC_CANONICAL_HOST])
2234 ifelse([$2],,INTEL_COMPILER,[$2])=no
2235
2236 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2237         case "$host_os" in
2238         (linux*|gnu*)
2239                 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2240                 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2241                 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2242                 AC_TRY_COMPILE([],[
2243 #ifdef __INTEL_COMPILER
2244 #else
2245 make an error
2246 #endif
2247 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2248 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2249 ],[])
2250                 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2251                 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2252                 ;;
2253         esac
2254 fi
2255 ])dnl
2256 dnl ---------------------------------------------------------------------------
2257 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2258 dnl ---------------
2259 dnl For the given system and compiler, find the compiler flags to pass to the
2260 dnl loader to use the "rpath" feature.
2261 AC_DEFUN([CF_LD_RPATH_OPT],
2262 [
2263 AC_REQUIRE([CF_CHECK_CACHE])
2264
2265 LD_RPATH_OPT=
2266 if test "x$cf_cv_enable_rpath" != xno
2267 then
2268         AC_MSG_CHECKING(for an rpath option)
2269         case "$cf_cv_system_name" in
2270         (irix*)
2271                 if test "$GCC" = yes; then
2272                         LD_RPATH_OPT="-Wl,-rpath,"
2273                 else
2274                         LD_RPATH_OPT="-rpath "
2275                 fi
2276                 ;;
2277         (linux*|gnu*|k*bsd*-gnu|freebsd*)
2278                 LD_RPATH_OPT="-Wl,-rpath,"
2279                 ;;
2280         (openbsd[[2-9]].*|mirbsd*)
2281                 LD_RPATH_OPT="-Wl,-rpath,"
2282                 ;;
2283         (dragonfly*)
2284                 LD_RPATH_OPT="-rpath "
2285                 ;;
2286         (netbsd*)
2287                 LD_RPATH_OPT="-Wl,-rpath,"
2288                 ;;
2289         (osf*|mls+*)
2290                 LD_RPATH_OPT="-rpath "
2291                 ;;
2292         (solaris2*)
2293                 LD_RPATH_OPT="-R"
2294                 ;;
2295         (*)
2296                 ;;
2297         esac
2298         AC_MSG_RESULT($LD_RPATH_OPT)
2299
2300         case "x$LD_RPATH_OPT" in
2301         (x-R*)
2302                 AC_MSG_CHECKING(if we need a space after rpath option)
2303                 cf_save_LIBS="$LIBS"
2304                 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2305                 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2306                 LIBS="$cf_save_LIBS"
2307                 AC_MSG_RESULT($cf_rpath_space)
2308                 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2309                 ;;
2310         esac
2311 fi
2312 ])dnl
2313 dnl ---------------------------------------------------------------------------
2314 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2315 dnl ---------------
2316 dnl Construct a search-list of directories for a nonstandard library-file
2317 dnl
2318 dnl Parameters
2319 dnl     $1 = the variable to return as result
2320 dnl     $2 = the package name
2321 AC_DEFUN([CF_LIBRARY_PATH],
2322 [
2323 $1=
2324 cf_library_path_list=""
2325 if test -n "${LDFLAGS}${LIBS}" ; then
2326         for cf_library_path in $LDFLAGS $LIBS
2327         do
2328                 case "$cf_library_path" in
2329                 (-L*)
2330                         cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2331                         CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2332                         cf_library_path_list="$cf_library_path_list [$]$1"
2333                         ;;
2334                 esac
2335         done
2336 fi
2337
2338 CF_SUBDIR_PATH($1,$2,lib)
2339
2340 $1="$cf_library_path_list [$]$1"
2341 ])dnl
2342 dnl ---------------------------------------------------------------------------
2343 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2344 dnl ------------
2345 dnl Generate tags/TAGS targets for makefiles.  Do not generate TAGS if we have
2346 dnl a monocase filesystem.
2347 AC_DEFUN([CF_MAKE_TAGS],[
2348 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2349
2350 AC_CHECK_PROGS(CTAGS, exctags ctags)
2351 AC_CHECK_PROGS(ETAGS, exetags etags)
2352
2353 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2354
2355 if test "$cf_cv_mixedcase" = yes ; then
2356         AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2357 else
2358         MAKE_UPPER_TAGS=no
2359 fi
2360
2361 if test "$MAKE_UPPER_TAGS" = yes ; then
2362         MAKE_UPPER_TAGS=
2363 else
2364         MAKE_UPPER_TAGS="#"
2365 fi
2366
2367 if test "$MAKE_LOWER_TAGS" = yes ; then
2368         MAKE_LOWER_TAGS=
2369 else
2370         MAKE_LOWER_TAGS="#"
2371 fi
2372
2373 AC_SUBST(CTAGS)
2374 AC_SUBST(ETAGS)
2375
2376 AC_SUBST(MAKE_UPPER_TAGS)
2377 AC_SUBST(MAKE_LOWER_TAGS)
2378 ])dnl
2379 dnl ---------------------------------------------------------------------------
2380 dnl CF_MATH_LIB version: 10 updated: 2020/12/31 18:40:20
2381 dnl -----------
2382 dnl Checks for libraries.  At least one UNIX system, Apple Macintosh
2383 dnl Rhapsody 5.5, does not have -lm.  We cannot use the simpler
2384 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
2385 AC_DEFUN([CF_MATH_LIB],
2386 [
2387 AC_CACHE_CHECK(if -lm needed for math functions,
2388         cf_cv_need_libm,[
2389         AC_TRY_LINK([
2390         #include <stdio.h>
2391         #include <stdlib.h>
2392         #include <math.h>
2393         ],
2394         [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)],
2395         [cf_cv_need_libm=no],
2396         [cf_cv_need_libm=yes])])
2397 if test "$cf_cv_need_libm" = yes
2398 then
2399 ifelse($1,,[
2400         CF_ADD_LIB(m)
2401 ],[$1=-lm])
2402 fi
2403 ])
2404 dnl ---------------------------------------------------------------------------
2405 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2406 dnl ----------------------
2407 dnl Check if the file-system supports mixed-case filenames.  If we're able to
2408 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2409 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2410 [
2411 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2412 if test "$cross_compiling" = yes ; then
2413         case "$target_alias" in
2414         (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2415                 cf_cv_mixedcase=no
2416                 ;;
2417         (*)
2418                 cf_cv_mixedcase=yes
2419                 ;;
2420         esac
2421 else
2422         rm -f conftest CONFTEST
2423         echo test >conftest
2424         if test -f CONFTEST ; then
2425                 cf_cv_mixedcase=no
2426         else
2427                 cf_cv_mixedcase=yes
2428         fi
2429         rm -f conftest CONFTEST
2430 fi
2431 ])
2432 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2433 ])dnl
2434 dnl ---------------------------------------------------------------------------
2435 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2436 dnl ----------
2437 dnl Write a debug message to config.log, along with the line number in the
2438 dnl configure script.
2439 AC_DEFUN([CF_MSG_LOG],[
2440 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2441 ])dnl
2442 dnl ---------------------------------------------------------------------------
2443 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2444 dnl -------------------
2445 dnl Check if we can compile with ncurses' header file
2446 dnl $1 is the cache variable to set
2447 dnl $2 is the header-file to include
2448 dnl $3 is the root name (ncurses or ncursesw)
2449 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2450         AC_TRY_COMPILE([
2451 ]ifelse($3,ncursesw,[
2452 #define _XOPEN_SOURCE_EXTENDED
2453 #undef  HAVE_LIBUTF8_H  /* in case we used CF_UTF8_LIB */
2454 #define HAVE_LIBUTF8_H  /* to force ncurses' header file to use cchar_t */
2455 ])[
2456 #include <$2>],[
2457 #ifdef NCURSES_VERSION
2458 ]ifelse($3,ncursesw,[
2459 #ifndef WACS_BSSB
2460         make an error
2461 #endif
2462 ])[
2463 printf("%s\\n", NCURSES_VERSION);
2464 #else
2465 #ifdef __NCURSES_H
2466 printf("old\\n");
2467 #else
2468         make an error
2469 #endif
2470 #endif
2471         ]
2472         ,[$1=$2]
2473         ,[$1=no])
2474 ])dnl
2475 dnl ---------------------------------------------------------------------------
2476 dnl CF_NCURSES_CONFIG version: 26 updated: 2021/01/03 08:05:37
2477 dnl -----------------
2478 dnl Tie together the configure-script macros for ncurses, preferring these in
2479 dnl order:
2480 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2481 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2482 dnl c) just plain libraries
2483 dnl
2484 dnl $1 is the root library name (default: "ncurses")
2485 AC_DEFUN([CF_NCURSES_CONFIG],[
2486 AC_REQUIRE([CF_PKG_CONFIG])
2487 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2488 cf_have_ncuconfig=no
2489
2490 if test "x${PKG_CONFIG:=none}" != xnone; then
2491         AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2492         if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2493                 AC_MSG_RESULT(yes)
2494
2495                 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2496                 cf_have_ncuconfig=unknown
2497
2498                 cf_save_CFLAGS="$CFLAGS"
2499                 cf_save_CPPFLAGS="$CPPFLAGS"
2500                 cf_save_LIBS="$LIBS"
2501
2502                 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2503                 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2504
2505                 # while -W for passing linker flags is prevalent, it is not "standard".
2506                 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2507                 # incompatible _and_ non-standard -W option which gives an error.  Work
2508                 # around that pitfall.
2509                 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2510                 (x*c[[89]]9@@*-W*)
2511                         CF_ADD_CFLAGS($cf_pkg_cflags)
2512                         CF_ADD_LIBS($cf_pkg_libs)
2513
2514                         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2515                                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2516                                 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2517                                         int main(void)
2518                                         { char *xx = curses_version(); return (xx == 0); }],
2519                                         [cf_test_ncuconfig=yes],
2520                                         [cf_test_ncuconfig=no],
2521                                         [cf_test_ncuconfig=maybe])],
2522                                 [cf_test_ncuconfig=no])
2523
2524                         CFLAGS="$cf_save_CFLAGS"
2525                         CPPFLAGS="$cf_save_CPPFLAGS"
2526                         LIBS="$cf_save_LIBS"
2527
2528                         if test "x$cf_test_ncuconfig" != xyes; then
2529                                 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^     ]]*//g'`
2530                                 cf_pkg_cflags="$cf_temp"
2531                                 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^       ]]*//g'`
2532                                 cf_pkg_libs="$cf_temp"
2533                         fi
2534                         ;;
2535                 esac
2536
2537                 CF_ADD_CFLAGS($cf_pkg_cflags)
2538                 CF_ADD_LIBS($cf_pkg_libs)
2539
2540                 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2541                         [initscr(); mousemask(0,0); tigetstr((char *)0);],
2542                         [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2543                                 int main(void)
2544                                 { char *xx = curses_version(); return (xx == 0); }],
2545                                 [cf_have_ncuconfig=yes],
2546                                 [cf_have_ncuconfig=no],
2547                                 [cf_have_ncuconfig=maybe])],
2548                         [cf_have_ncuconfig=no])
2549                 AC_MSG_RESULT($cf_have_ncuconfig)
2550                 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2551                 if test "$cf_have_ncuconfig" != "yes"
2552                 then
2553                         CPPFLAGS="$cf_save_CPPFLAGS"
2554                         LIBS="$cf_save_LIBS"
2555                         NCURSES_CONFIG_PKG=none
2556                 else
2557                         AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2558                         NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2559                         CF_TERM_HEADER
2560                 fi
2561
2562         else
2563                 AC_MSG_RESULT(no)
2564                 NCURSES_CONFIG_PKG=none
2565         fi
2566 else
2567         NCURSES_CONFIG_PKG=none
2568 fi
2569
2570 if test "x$cf_have_ncuconfig" = "xno"; then
2571         cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2572
2573         CF_ACVERSION_CHECK(2.52,
2574                 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2575                 [AC_PATH_PROGS(NCURSES_CONFIG,  ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2576
2577         if test "$NCURSES_CONFIG" != none ; then
2578
2579                 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2580                 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2581
2582                 # even with config script, some packages use no-override for curses.h
2583                 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2584
2585                 dnl like CF_NCURSES_CPPFLAGS
2586                 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2587
2588                 dnl like CF_NCURSES_LIBS
2589                 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2590                 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2591
2592                 dnl like CF_NCURSES_VERSION
2593                 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
2594
2595         else
2596
2597                 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2598                 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2599
2600         fi
2601 else
2602         NCURSES_CONFIG=none
2603 fi
2604 ])dnl
2605 dnl ---------------------------------------------------------------------------
2606 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
2607 dnl -------------------
2608 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2609 dnl the CPPFLAGS variable so we can include its header.
2610 dnl
2611 dnl The header files may be installed as either curses.h, or ncurses.h (would
2612 dnl be obsolete, except that some packagers prefer this name to distinguish it
2613 dnl from a "native" curses implementation).  If not installed for overwrite,
2614 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2615 dnl /usr/include/ncurses), but someone may have installed overwriting the
2616 dnl vendor's curses.  Only very old versions (pre-1.9.2d, the first autoconf'd
2617 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2618 dnl the header.
2619 dnl
2620 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2621 dnl is already in the include-path, don't even bother with this, since we cannot
2622 dnl easily determine which file it is.  In this case, it has to be <curses.h>.
2623 dnl
2624 dnl The optional parameter gives the root name of the library, in case it is
2625 dnl not installed as the default curses library.  That is how the
2626 dnl wide-character version of ncurses is installed.
2627 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2628 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2629
2630 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2631 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2632
2633 test -n "$cf_cv_curses_dir" && \
2634 test "$cf_cv_curses_dir" != "no" && { \
2635   CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2636 }
2637
2638 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2639         cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2640         { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
2641         for cf_header in $cf_header_list
2642         do
2643                 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2644                 test "$cf_cv_ncurses_h" != no && break
2645         done
2646 ])
2647
2648 CF_NCURSES_HEADER
2649 CF_TERM_HEADER
2650
2651 # some applications need this, but should check for NCURSES_VERSION
2652 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2653
2654 CF_NCURSES_VERSION
2655 ])dnl
2656 dnl ---------------------------------------------------------------------------
2657 dnl CF_NCURSES_EXT_FUNCS version: 4 updated: 2012/10/06 16:39:58
2658 dnl --------------------
2659 dnl Since 2007/11/17, ncurses has defined NCURSES_EXT_FUNCS; earlier versions
2660 dnl may provide these functions.  Define the symbol if it is not defined, and
2661 dnl if it is valid.
2662 AC_DEFUN([CF_NCURSES_EXT_FUNCS],
2663 [
2664 AC_CACHE_CHECK(for ncurses extended functions,cf_cv_ncurses_ext_funcs,[
2665 AC_TRY_COMPILE([
2666 #include <${cf_cv_ncurses_header:-curses.h}>],
2667 [
2668 int x = NCURSES_EXT_FUNCS
2669 ],[cf_cv_ncurses_ext_funcs=defined],[
2670 AC_TRY_LINK([
2671 #include <${cf_cv_ncurses_header:-curses.h}>],
2672 [
2673         (void) assume_default_colors (0, 0);
2674         (void) curses_version ();
2675         (void) define_key (0, 0);
2676         (void) is_term_resized (0, 0);
2677         (void) key_defined (0);
2678         (void) keybound (0, 0);
2679         (void) keyok (0, 0);
2680         (void) resize_term (0, 0);
2681         (void) resizeterm (0, 0);
2682         (void) use_default_colors ();
2683         (void) use_extended_names (0);
2684         (void) wresize (0, 0, 0);],
2685         [cf_cv_ncurses_ext_funcs=yes],
2686         [cf_cv_ncurses_ext_funcs=no])
2687 ])
2688 ])
2689 test "$cf_cv_ncurses_ext_funcs" = yes && AC_DEFINE(NCURSES_EXT_FUNCS,1,[Define to 1 if we have ncurses extensions])
2690 ])dnl
2691 dnl ---------------------------------------------------------------------------
2692 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
2693 dnl -----------------
2694 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2695 dnl variations of ncurses' installs.
2696 dnl
2697 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2698 AC_DEFUN([CF_NCURSES_HEADER],[
2699
2700 if test "$cf_cv_ncurses_h" != no ; then
2701         cf_cv_ncurses_header=$cf_cv_ncurses_h
2702 else
2703
2704 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2705         test -n "$verbose" && echo
2706         CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2707         test -n "$verbose" && echo "search path $cf_search"
2708         cf_save2_CPPFLAGS="$CPPFLAGS"
2709         for cf_incdir in $cf_search
2710         do
2711                 CF_ADD_INCDIR($cf_incdir)
2712                 for cf_header in \
2713                         ncurses.h \
2714                         curses.h
2715                 do
2716                         CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2717                         if test "$cf_cv_ncurses_h2" != no ; then
2718                                 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2719                                 test -n "$verbose" && echo $ECHO_N "    ... found $ECHO_C" 1>&AC_FD_MSG
2720                                 break
2721                         fi
2722                         test -n "$verbose" && echo "    ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2723                 done
2724                 CPPFLAGS="$cf_save2_CPPFLAGS"
2725                 test "$cf_cv_ncurses_h2" != no && break
2726         done
2727         test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2728         ])
2729
2730         CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2731         cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
2732         if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
2733                 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
2734         fi
2735         CF_ADD_INCDIR($cf_1st_incdir)
2736
2737 fi
2738
2739 # Set definitions to allow ifdef'ing for ncurses.h
2740
2741 case "$cf_cv_ncurses_header" in
2742 (*ncurses.h)
2743         AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2744         ;;
2745 esac
2746
2747 case "$cf_cv_ncurses_header" in
2748 (ncurses/curses.h|ncurses/ncurses.h)
2749         AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2750         ;;
2751 (ncursesw/curses.h|ncursesw/ncurses.h)
2752         AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2753         ;;
2754 esac
2755
2756 ])dnl
2757 dnl ---------------------------------------------------------------------------
2758 dnl CF_NCURSES_LIBS version: 20 updated: 2021/01/03 08:05:37
2759 dnl ---------------
2760 dnl Look for the ncurses library.  This is a little complicated on Linux,
2761 dnl because it may be linked with the gpm (general purpose mouse) library.
2762 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2763 dnl unusable with ncurses.  However, we don't want to link with gpm unless
2764 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2765 dnl and the linker will record a dependency.
2766 dnl
2767 dnl The optional parameter gives the root name of the library, in case it is
2768 dnl not installed as the default curses library.  That is how the
2769 dnl wide-character version of ncurses is installed.
2770 AC_DEFUN([CF_NCURSES_LIBS],
2771 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2772
2773 cf_nculib_root=ifelse($1,,ncurses,$1)
2774         # This works, except for the special case where we find gpm, but
2775         # ncurses is in a nonstandard location via $LIBS, and we really want
2776         # to link gpm.
2777 cf_ncurses_LIBS=""
2778 cf_ncurses_SAVE="$LIBS"
2779 AC_CHECK_LIB(gpm,Gpm_Open,
2780         [AC_CHECK_LIB(gpm,initscr,
2781                 [LIBS="$cf_ncurses_SAVE"],
2782                 [cf_ncurses_LIBS="-lgpm"])])
2783
2784 case "$host_os" in
2785 (freebsd*)
2786         # This is only necessary if you are linking against an obsolete
2787         # version of ncurses (but it should do no harm, since it's static).
2788         if test "$cf_nculib_root" = ncurses ; then
2789                 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2790         fi
2791         ;;
2792 esac
2793
2794 CF_ADD_LIBS($cf_ncurses_LIBS)
2795
2796 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
2797 then
2798         CF_ADD_LIBS(-l$cf_nculib_root)
2799 else
2800         CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2801                 [#include <${cf_cv_ncurses_header:-curses.h}>],
2802                 [initscr()],
2803                 initscr)
2804 fi
2805
2806 if test -n "$cf_ncurses_LIBS" ; then
2807         AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2808         cf_ncurses_SAVE="$LIBS"
2809         for p in $cf_ncurses_LIBS ; do
2810                 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
2811                 if test "$q" != "$LIBS" ; then
2812                         LIBS="$q"
2813                 fi
2814         done
2815         AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2816                 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2817                 [AC_MSG_RESULT(yes)],
2818                 [AC_MSG_RESULT(no)
2819                  LIBS="$cf_ncurses_SAVE"])
2820 fi
2821
2822 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2823 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2824 ])dnl
2825 dnl ---------------------------------------------------------------------------
2826 dnl CF_NCURSES_PTHREADS version: 2 updated: 2016/04/22 05:07:41
2827 dnl -------------------
2828 dnl Use this followup check to ensure that we link with pthreads if ncurses
2829 dnl uses it.
2830 AC_DEFUN([CF_NCURSES_PTHREADS],[
2831 : ${cf_nculib_root:=ifelse($1,,ncurses,$1)}
2832 AC_CHECK_LIB($cf_nculib_root,_nc_init_pthreads,
2833         cf_cv_ncurses_pthreads=yes,
2834         cf_cv_ncurses_pthreads=no)
2835 if test "$cf_cv_ncurses_pthreads" = yes
2836 then
2837         CF_ADD_LIBS(-lpthread)
2838 fi
2839 ])dnl
2840 dnl ---------------------------------------------------------------------------
2841 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
2842 dnl ------------------
2843 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2844 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS.  We don't use
2845 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2846 AC_DEFUN([CF_NCURSES_VERSION],
2847 [
2848 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2849 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2850         cf_cv_ncurses_version=no
2851         cf_tempfile=out$$
2852         rm -f "$cf_tempfile"
2853         AC_TRY_RUN([
2854 #include <${cf_cv_ncurses_header:-curses.h}>
2855 #include <stdio.h>
2856 int main(void)
2857 {
2858         FILE *fp = fopen("$cf_tempfile", "w");
2859 #ifdef NCURSES_VERSION
2860 # ifdef NCURSES_VERSION_PATCH
2861         fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2862 # else
2863         fprintf(fp, "%s\\n", NCURSES_VERSION);
2864 # endif
2865 #else
2866 # ifdef __NCURSES_H
2867         fprintf(fp, "old\\n");
2868 # else
2869         make an error
2870 # endif
2871 #endif
2872         ${cf_cv_main_return:-return}(0);
2873 }],[
2874         cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2875
2876         # This will not work if the preprocessor splits the line after the
2877         # Autoconf token.  The 'unproto' program does that.
2878         cat > "conftest.$ac_ext" <<EOF
2879 #include <${cf_cv_ncurses_header:-curses.h}>
2880 #undef Autoconf
2881 #ifdef NCURSES_VERSION
2882 Autoconf NCURSES_VERSION
2883 #else
2884 #ifdef __NCURSES_H
2885 Autoconf "old"
2886 #endif
2887 ;
2888 #endif
2889 EOF
2890         cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2891         AC_TRY_EVAL(cf_try)
2892         if test -f conftest.out ; then
2893                 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
2894                 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2895                 rm -f conftest.out
2896         fi
2897 ])
2898         rm -f "$cf_tempfile"
2899 ])
2900 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2901 ])dnl
2902 dnl ---------------------------------------------------------------------------
2903 dnl CF_NCURSES_WRAP_PREFIX version: 1 updated: 2009/03/28 16:08:10
2904 dnl ----------------------
2905 dnl Check for ncurses "wrap-prefix" used for public variables which have been
2906 dnl wrapped with a function to help with concurrency control.
2907 AC_DEFUN([CF_NCURSES_WRAP_PREFIX],
2908 [
2909 AC_MSG_CHECKING(for ncurses wrap-prefix)
2910 AC_ARG_WITH(ncurses-wrap-prefix,
2911         [  --with-ncurses-wrap-prefix naming-prefix for ncurses wrapped-variables],
2912         [NCURSES_WRAP_PREFIX=$withval],
2913         [NCURSES_WRAP_PREFIX=_nc_])
2914 AC_MSG_RESULT($NCURSES_WRAP_PREFIX)
2915
2916 AC_SUBST(NCURSES_WRAP_PREFIX)
2917 ])
2918 dnl ---------------------------------------------------------------------------
2919 dnl CF_NETBSD_FORM_H version: 2 updated: 2012/10/06 16:39:58
2920 dnl ----------------
2921 dnl Check for NetBSD's form.h, which is incompatible with SVr4 and ncurses.
2922 dnl Some workarounds are needed in client programs to allow them to compile.
2923 AC_DEFUN([CF_NETBSD_FORM_H],[
2924 AC_CACHE_CHECK(for NetBSD form.h,cf_cv_netbsd_form_h,[
2925 AC_TRY_COMPILE([
2926 #include <${cf_cv_ncurses_header:-curses.h}>
2927 #include <form.h>
2928 ],[
2929         FORM *form;
2930         int y = current_field(form)->cursor_ypos;
2931         int x = current_field(form)->cursor_xpos;
2932 ],[cf_cv_netbsd_form_h=yes
2933 ],[cf_cv_netbsd_form_h=no])
2934 ])
2935
2936 test "$cf_cv_netbsd_form_h" = yes && AC_DEFINE(HAVE_NETBSD_FORM_H,1,[Define to 1 if we appear to be using NetBSD form.h])
2937 ])dnl
2938 dnl ---------------------------------------------------------------------------
2939 dnl CF_NETBSD_MENU_H version: 2 updated: 2012/10/06 16:39:58
2940 dnl ----------------
2941 dnl Check for NetBSD's menu.h, which is incompatible with SVr4 and ncurses.
2942 dnl Some workarounds are needed in client programs to allow them to compile.
2943 AC_DEFUN([CF_NETBSD_MENU_H],[
2944 AC_CACHE_CHECK(for NetBSD menu.h,cf_cv_netbsd_menu_h,[
2945 AC_TRY_COMPILE([
2946 #include <${cf_cv_ncurses_header:-curses.h}>
2947 #include <menu.h>
2948 ],[
2949         MENU *menu;
2950         int y = menu->max_item_width;
2951 ],[cf_cv_netbsd_menu_h=yes
2952 ],[cf_cv_netbsd_menu_h=no])
2953 ])
2954
2955 test "$cf_cv_netbsd_menu_h" = yes && AC_DEFINE(HAVE_NETBSD_MENU_H,1,[Define to 1 if we appear to be using NetBSD menu.h])
2956 ])dnl
2957 dnl ---------------------------------------------------------------------------
2958 dnl CF_NO_LEAKS_OPTION version: 8 updated: 2021/01/05 20:05:09
2959 dnl ------------------
2960 dnl see CF_WITH_NO_LEAKS
2961 AC_DEFUN([CF_NO_LEAKS_OPTION],[
2962 AC_MSG_CHECKING(if you want to use $1 for testing)
2963 AC_ARG_WITH($1,
2964         [$2],
2965         [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
2966          $4
2967 ])
2968         : "${with_cflags:=-g}"
2969         : "${enable_leaks:=no}"
2970          with_$1=yes],
2971         [with_$1=])
2972 AC_MSG_RESULT(${with_$1:-no})
2973
2974 case ".$with_cflags" in
2975 (.*-g*)
2976         case .$CFLAGS in
2977         (.*-g*)
2978                 ;;
2979         (*)
2980                 CF_ADD_CFLAGS([-g])
2981                 ;;
2982         esac
2983         ;;
2984 esac
2985 ])dnl
2986 dnl ---------------------------------------------------------------------------
2987 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
2988 dnl --------------
2989 dnl Check the argument to see that it looks like a pathname.  Rewrite it if it
2990 dnl begins with one of the prefix/exec_prefix variables, and then again if the
2991 dnl result begins with 'NONE'.  This is necessary to work around autoconf's
2992 dnl delayed evaluation of those symbols.
2993 AC_DEFUN([CF_PATH_SYNTAX],[
2994 if test "x$prefix" != xNONE; then
2995         cf_path_syntax="$prefix"
2996 else
2997         cf_path_syntax="$ac_default_prefix"
2998 fi
2999
3000 case ".[$]$1" in
3001 (.\[$]\(*\)*|.\'*\'*)
3002         ;;
3003 (..|./*|.\\*)
3004         ;;
3005 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3006         ;;
3007 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3008         eval $1="[$]$1"
3009         case ".[$]$1" in
3010         (.NONE/*)
3011                 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3012                 ;;
3013         esac
3014         ;;
3015 (.no|.NONE/*)
3016         $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3017         ;;
3018 (*)
3019         ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3020         ;;
3021 esac
3022 ])dnl
3023 dnl ---------------------------------------------------------------------------
3024 dnl CF_PDCURSES_X11 version: 15 updated: 2021/01/02 09:31:20
3025 dnl ---------------
3026 dnl Configure for PDCurses' X11 library
3027 AC_DEFUN([CF_PDCURSES_X11],[
3028 AC_REQUIRE([CF_X_ATHENA])
3029
3030 CF_ACVERSION_CHECK(2.52,
3031         [AC_CHECK_TOOLS(XCURSES_CONFIG, xcurses-config, none)],
3032         [AC_PATH_PROGS(XCURSES_CONFIG, xcurses-config, none)])
3033
3034 if test "$XCURSES_CONFIG" != none ; then
3035
3036 CF_ADD_CFLAGS(`$XCURSES_CONFIG --cflags`)
3037 CF_ADD_LIBS(`$XCURSES_CONFIG --libs`)
3038
3039 cf_cv_lib_XCurses=yes
3040
3041 else
3042
3043 LDFLAGS="$LDFLAGS $X_LIBS"
3044 CF_CHECK_CFLAGS($X_CFLAGS)
3045 AC_CHECK_LIB(X11,XOpenDisplay,
3046         [CF_ADD_LIBS(-lX11)],,
3047         [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS])
3048 AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[
3049 CF_ADD_LIBS(-lXCurses)
3050 AC_TRY_LINK([
3051 #include <xcurses.h>
3052 char *XCursesProgramName = "test";
3053 ],[XCursesExit();],
3054 [cf_cv_lib_XCurses=yes],
3055 [cf_cv_lib_XCurses=no])
3056 ])
3057
3058 fi
3059
3060 if test "$cf_cv_lib_XCurses" = yes ; then
3061         AC_DEFINE(UNIX,1,[Define to 1 if using PDCurses on Unix])
3062         AC_DEFINE(XCURSES,1,[Define to 1 if using PDCurses on Unix])
3063         AC_CHECK_HEADER(xcurses.h, AC_DEFINE(HAVE_XCURSES,1,[Define to 1 if using PDCurses on Unix]))
3064 else
3065         AC_MSG_ERROR(Cannot link with XCurses)
3066 fi
3067 ])dnl
3068 dnl ---------------------------------------------------------------------------
3069 dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
3070 dnl -------------
3071 dnl Check for the package-config program, unless disabled by command-line.
3072 AC_DEFUN([CF_PKG_CONFIG],
3073 [
3074 AC_MSG_CHECKING(if you want to use pkg-config)
3075 AC_ARG_WITH(pkg-config,
3076         [  --with-pkg-config{=path} enable/disable use of pkg-config],
3077         [cf_pkg_config=$withval],
3078         [cf_pkg_config=yes])
3079 AC_MSG_RESULT($cf_pkg_config)
3080
3081 case "$cf_pkg_config" in
3082 (no)
3083         PKG_CONFIG=none
3084         ;;
3085 (yes)
3086         CF_ACVERSION_CHECK(2.52,
3087                 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3088                 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3089         ;;
3090 (*)
3091         PKG_CONFIG=$withval
3092         ;;
3093 esac
3094
3095 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3096 if test "$PKG_CONFIG" != none ; then
3097         CF_PATH_SYNTAX(PKG_CONFIG)
3098 elif test "x$cf_pkg_config" != xno ; then
3099         AC_MSG_WARN(pkg-config is not installed)
3100 fi
3101
3102 AC_SUBST(PKG_CONFIG)
3103 ])dnl
3104 dnl ---------------------------------------------------------------------------
3105 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3106 dnl -----------------
3107 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3108 dnl
3109 dnl     POSIX.1-1990                            _POSIX_SOURCE
3110 dnl     POSIX.1-1990 and                        _POSIX_SOURCE and
3111 dnl             POSIX.2-1992 C-Language                 _POSIX_C_SOURCE=2
3112 dnl             Bindings Option
3113 dnl     POSIX.1b-1993                           _POSIX_C_SOURCE=199309L
3114 dnl     POSIX.1c-1996                           _POSIX_C_SOURCE=199506L
3115 dnl     X/Open 2000                             _POSIX_C_SOURCE=200112L
3116 dnl
3117 dnl Parameters:
3118 dnl     $1 is the nominal value for _POSIX_C_SOURCE
3119 AC_DEFUN([CF_POSIX_C_SOURCE],
3120 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3121
3122 if test "$cf_cv_posix_visible" = no; then
3123
3124 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3125
3126 cf_save_CFLAGS="$CFLAGS"
3127 cf_save_CPPFLAGS="$CPPFLAGS"
3128
3129 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3130 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3131
3132 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3133         CF_MSG_LOG(if the symbol is already defined go no further)
3134         AC_TRY_COMPILE([#include <sys/types.h>],[
3135 #ifndef _POSIX_C_SOURCE
3136 make an error
3137 #endif],
3138         [cf_cv_posix_c_source=no],
3139         [cf_want_posix_source=no
3140          case .$cf_POSIX_C_SOURCE in
3141          (.[[12]]??*)
3142                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3143                 ;;
3144          (.2)
3145                 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3146                 cf_want_posix_source=yes
3147                 ;;
3148          (.*)
3149                 cf_want_posix_source=yes
3150                 ;;
3151          esac
3152          if test "$cf_want_posix_source" = yes ; then
3153                 AC_TRY_COMPILE([#include <sys/types.h>],[
3154 #ifdef _POSIX_SOURCE
3155 make an error
3156 #endif],[],
3157                 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3158          fi
3159          CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3160          CFLAGS="$cf_trim_CFLAGS"
3161          CPPFLAGS="$cf_trim_CPPFLAGS"
3162          CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3163          CF_MSG_LOG(if the second compile does not leave our definition intact error)
3164          AC_TRY_COMPILE([#include <sys/types.h>],[
3165 #ifndef _POSIX_C_SOURCE
3166 make an error
3167 #endif],,
3168          [cf_cv_posix_c_source=no])
3169          CFLAGS="$cf_save_CFLAGS"
3170          CPPFLAGS="$cf_save_CPPFLAGS"
3171         ])
3172 ])
3173
3174 if test "$cf_cv_posix_c_source" != no ; then
3175         CFLAGS="$cf_trim_CFLAGS"
3176         CPPFLAGS="$cf_trim_CPPFLAGS"
3177         CF_ADD_CFLAGS($cf_cv_posix_c_source)
3178 fi
3179
3180 fi # cf_cv_posix_visible
3181
3182 ])dnl
3183 dnl ---------------------------------------------------------------------------
3184 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3185 dnl ----------------
3186 dnl POSIX documents test-macros which an application may set before any system
3187 dnl headers are included to make features available.
3188 dnl
3189 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3190 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3191 dnl recent features visible in the system header files unless the application
3192 dnl overrides the corresponding test-macros.  Doing that introduces portability
3193 dnl problems.
3194 dnl
3195 dnl This macro makes a special check for the symbols used for this, to avoid a
3196 dnl conflicting definition.
3197 AC_DEFUN([CF_POSIX_VISIBLE],
3198 [
3199 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3200 AC_TRY_COMPILE([#include <stdio.h>],[
3201 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3202         && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3203         && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3204         && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3205 #error conflicting symbols found
3206 #endif
3207 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3208 ])
3209 ])dnl
3210 dnl ---------------------------------------------------------------------------
3211 dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04
3212 dnl ------------
3213 dnl Append definitions and rules for the given programs to the subdirectory
3214 dnl Makefiles, and the recursion rule for the top-level Makefile.
3215 dnl
3216 dnl parameters
3217 dnl     $1 = script to run
3218 dnl     $2 = list of subdirectories
3219 dnl
3220 dnl variables
3221 dnl     $AWK
3222 AC_DEFUN([CF_PRG_RULES],
3223 [
3224 for cf_dir in $2
3225 do
3226         if test ! -d "$srcdir/$cf_dir" ; then
3227                 continue
3228         elif test -f "$srcdir/$cf_dir/programs" ; then
3229                 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile
3230         fi
3231 done
3232
3233 ])dnl
3234 dnl ---------------------------------------------------------------------------
3235 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3236 dnl ----------
3237 dnl standard check for CC, plus followup sanity checks
3238 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3239 AC_DEFUN([CF_PROG_CC],[
3240 CF_ACVERSION_CHECK(2.53,
3241         [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3242          AC_REQUIRE([AC_PROG_CC])],
3243         [])
3244 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3245 CF_GCC_VERSION
3246 CF_ACVERSION_CHECK(2.52,
3247         [AC_PROG_CC_STDC],
3248         [CF_ANSI_CC_REQD])
3249 CF_CC_ENV_FLAGS
3250 ])dnl
3251 dnl ---------------------------------------------------------------------------
3252 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3253 dnl ---------------
3254 dnl Force $INSTALL to be an absolute-path.  Otherwise, edit_man.sh and the
3255 dnl misc/tabset install won't work properly.  Usually this happens only when
3256 dnl using the fallback mkinstalldirs script
3257 AC_DEFUN([CF_PROG_INSTALL],
3258 [AC_PROG_INSTALL
3259 case $INSTALL in
3260 (/*)
3261         ;;
3262 (*)
3263         CF_DIRNAME(cf_dir,$INSTALL)
3264         test -z "$cf_dir" && cf_dir=.
3265         INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3266         ;;
3267 esac
3268 ])dnl
3269 dnl ---------------------------------------------------------------------------
3270 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
3271 dnl ------------
3272 AC_DEFUN([CF_PROG_LINT],
3273 [
3274 AC_CHECK_PROGS(LINT, lint cppcheck splint)
3275 case "x$LINT" in
3276 (xcppcheck|x*/cppcheck)
3277         test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
3278         ;;
3279 esac
3280 AC_SUBST(LINT_OPTS)
3281 ])dnl
3282 dnl ---------------------------------------------------------------------------
3283 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3284 dnl ----------------
3285 dnl Remove all -U and -D options that refer to the given symbol from a list
3286 dnl of C compiler options.  This works around the problem that not all
3287 dnl compilers process -U and -D options from left-to-right, so a -U option
3288 dnl cannot be used to cancel the effect of a preceding -D option.
3289 dnl
3290 dnl $1 = target (which could be the same as the source variable)
3291 dnl $2 = source (including '$')
3292 dnl $3 = symbol to remove
3293 define([CF_REMOVE_DEFINE],
3294 [
3295 $1=`echo "$2" | \
3296         sed     -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[[       ]]/ /g' \
3297                 -e 's/-[[UD]]'"$3"'\(=[[^       ]]*\)\?[$]//g'`
3298 ])dnl
3299 dnl ---------------------------------------------------------------------------
3300 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3301 dnl ---------------------
3302 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3303 dnl $1 = name of current macro
3304 define([CF_RESTORE_XTRA_FLAGS],
3305 [
3306 LIBS="$cf_save_LIBS_$1"
3307 CFLAGS="$cf_save_CFLAGS_$1"
3308 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3309 ])dnl
3310 dnl ---------------------------------------------------------------------------
3311 dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50
3312 dnl -------------
3313 AC_DEFUN([CF_RPATH_HACK],
3314 [AC_REQUIRE([AC_PROG_FGREP])dnl
3315 AC_REQUIRE([CF_LD_RPATH_OPT])dnl
3316
3317 AC_MSG_CHECKING(for updated LDFLAGS)
3318 if test -n "$LD_RPATH_OPT" ; then
3319         AC_MSG_RESULT(maybe)
3320
3321         AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
3322         cf_rpath_list="/usr/lib /lib"
3323         if test "$cf_ldd_prog" != no
3324         then
3325                 cf_rpath_oops=
3326
3327 AC_TRY_LINK([#include <stdio.h>],
3328                 [printf("Hello");],
3329                 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
3330                  cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[        ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
3331
3332                 # If we passed the link-test, but get a "not found" on a given library,
3333                 # this could be due to inept reconfiguration of gcc to make it only
3334                 # partly honor /usr/local/lib (or whatever).  Sometimes this behavior
3335                 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
3336                 # /usr/local libraries.
3337                 if test -n "$cf_rpath_oops"
3338                 then
3339                         for cf_rpath_src in $cf_rpath_oops
3340                         do
3341                                 for cf_rpath_dir in \
3342                                         /usr/local \
3343                                         /usr/pkg \
3344                                         /opt/sfw
3345                                 do
3346                                         if test -f "$cf_rpath_dir/lib/$cf_rpath_src"
3347                                         then
3348                                                 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
3349                                                 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
3350                                                 break
3351                                         fi
3352                                 done
3353                         done
3354                 fi
3355         fi
3356
3357         CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3358
3359         CF_RPATH_HACK_2(LDFLAGS)
3360         CF_RPATH_HACK_2(LIBS)
3361
3362         CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
3363 else
3364         AC_MSG_RESULT(no)
3365 fi
3366 AC_SUBST(EXTRA_LDFLAGS)
3367 ])dnl
3368 dnl ---------------------------------------------------------------------------
3369 dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04
3370 dnl ---------------
3371 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
3372 dnl EXTRA_LDFLAGS for each -L option found.
3373 dnl
3374 dnl $cf_rpath_list contains a list of directories to ignore.
3375 dnl
3376 dnl $1 = variable name to update.  The LDFLAGS variable should be the only one,
3377 dnl      but LIBS often has misplaced -L options.
3378 AC_DEFUN([CF_RPATH_HACK_2],
3379 [
3380 CF_VERBOSE(...checking $1 [$]$1)
3381
3382 cf_rpath_dst=
3383 for cf_rpath_src in [$]$1
3384 do
3385         case "$cf_rpath_src" in
3386         (-L*)
3387
3388                 # check if this refers to a directory which we will ignore
3389                 cf_rpath_skip=no
3390                 if test -n "$cf_rpath_list"
3391                 then
3392                         for cf_rpath_item in $cf_rpath_list
3393                         do
3394                                 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
3395                                 then
3396                                         cf_rpath_skip=yes
3397                                         break
3398                                 fi
3399                         done
3400                 fi
3401
3402                 if test "$cf_rpath_skip" = no
3403                 then
3404                         # transform the option
3405                         if test "$LD_RPATH_OPT" = "-R " ; then
3406                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
3407                         else
3408                                 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
3409                         fi
3410
3411                         # if we have not already added this, add it now
3412                         cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
3413                         if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
3414                         then
3415                                 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
3416                                 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
3417                         fi
3418                 fi
3419                 ;;
3420         esac
3421         cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
3422 done
3423 $1=$cf_rpath_dst
3424
3425 CF_VERBOSE(...checked $1 [$]$1)
3426 AC_SUBST(EXTRA_LDFLAGS)
3427 ])dnl
3428 dnl ---------------------------------------------------------------------------
3429 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3430 dnl ------------------
3431 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3432 dnl and libraries which do not update those variables.
3433 dnl
3434 dnl $1 = name of current macro
3435 define([CF_SAVE_XTRA_FLAGS],
3436 [
3437 cf_save_LIBS_$1="$LIBS"
3438 cf_save_CFLAGS_$1="$CFLAGS"
3439 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3440 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3441 for cf_X_CFLAGS in $X_CFLAGS
3442 do
3443         case "x$cf_X_CFLAGS" in
3444         x-[[IUD]]*)
3445                 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3446                 ;;
3447         *)
3448                 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3449                 ;;
3450         esac
3451 done
3452 ])dnl
3453 dnl ---------------------------------------------------------------------------
3454 dnl CF_SIGWINCH version: 6 updated: 2021/01/01 13:31:04
3455 dnl -----------
3456 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
3457 dnl programs need this test).
3458 dnl
3459 dnl This is really a Mac OS X 10.4.3 workaround.  Defining _POSIX_C_SOURCE
3460 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses).  Oddly, the struct
3461 dnl winsize declaration is left alone - we may revisit this if Apple choose to
3462 dnl break that part of the interface as well.
3463 AC_DEFUN([CF_SIGWINCH],
3464 [
3465 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
3466         AC_TRY_COMPILE([
3467 #include <sys/types.h>
3468 #include <sys/signal.h>
3469 ],[int x = SIGWINCH; (void)x],
3470         [cf_cv_define_sigwinch=yes],
3471         [AC_TRY_COMPILE([
3472 #undef _XOPEN_SOURCE
3473 #undef _POSIX_SOURCE
3474 #undef _POSIX_C_SOURCE
3475 #include <sys/types.h>
3476 #include <sys/signal.h>
3477 ],[int x = SIGWINCH; (void)x],
3478         [cf_cv_define_sigwinch=maybe],
3479         [cf_cv_define_sigwinch=no])
3480 ])
3481 ])
3482
3483 if test "$cf_cv_define_sigwinch" = maybe ; then
3484 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
3485 cf_cv_fixup_sigwinch=unknown
3486 cf_sigwinch=32
3487 while test "$cf_sigwinch" != 1
3488 do
3489         AC_TRY_COMPILE([
3490 #undef _XOPEN_SOURCE
3491 #undef _POSIX_SOURCE
3492 #undef _POSIX_C_SOURCE
3493 #include <sys/types.h>
3494 #include <sys/signal.h>
3495 ],[
3496 #if SIGWINCH != $cf_sigwinch
3497 make an error
3498 #endif
3499 int x = SIGWINCH; (void)x],
3500         [cf_cv_fixup_sigwinch=$cf_sigwinch
3501          break])
3502
3503 cf_sigwinch="`expr "$cf_sigwinch" - 1`"
3504 done
3505 ])
3506
3507         if test "$cf_cv_fixup_sigwinch" != unknown ; then
3508                 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
3509         fi
3510 fi
3511 ])dnl
3512 dnl ---------------------------------------------------------------------------
3513 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
3514 dnl ---------------
3515 dnl signal handler, but there are some gcc dependencies in that recommendation.
3516 dnl Try anyway.
3517 AC_DEFUN([CF_SIG_ATOMIC_T],
3518 [
3519 AC_MSG_CHECKING(for signal global datatype)
3520 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
3521         for cf_type in \
3522                 "volatile sig_atomic_t" \
3523                 "sig_atomic_t" \
3524                 "int"
3525         do
3526         AC_TRY_COMPILE([
3527 #include <sys/types.h>
3528 #include <signal.h>
3529 #include <stdio.h>
3530
3531 extern $cf_type x;
3532 $cf_type x;
3533 static void handler(int sig)
3534 {
3535         (void)sig;
3536         x = 5;
3537 }],
3538                 [signal(SIGINT, handler);
3539                  x = 1],
3540                 [cf_cv_sig_atomic_t=$cf_type],
3541                 [cf_cv_sig_atomic_t=no])
3542                 test "$cf_cv_sig_atomic_t" != no && break
3543         done
3544         ])
3545 AC_MSG_RESULT($cf_cv_sig_atomic_t)
3546 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
3547 ])dnl
3548 dnl ---------------------------------------------------------------------------
3549 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
3550 dnl --------------
3551 dnl Construct a search-list for a nonstandard header/lib-file
3552 dnl     $1 = the variable to return as result
3553 dnl     $2 = the package name
3554 dnl     $3 = the subdirectory, e.g., bin, include or lib
3555 AC_DEFUN([CF_SUBDIR_PATH],
3556 [
3557 $1=
3558
3559 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
3560
3561 for cf_subdir_prefix in \
3562         /usr \
3563         /usr/local \
3564         /usr/pkg \
3565         /opt \
3566         /opt/local \
3567         [$]HOME
3568 do
3569         CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
3570 done
3571 ])dnl
3572 dnl ---------------------------------------------------------------------------
3573 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
3574 dnl ------------------
3575 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
3576 dnl older SCO configurations.
3577 AC_DEFUN([CF_SYS_TIME_SELECT],
3578 [
3579 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
3580 AC_CACHE_VAL(cf_cv_sys_time_select,[
3581 AC_TRY_COMPILE([
3582 #include <sys/types.h>
3583 #ifdef HAVE_SYS_TIME_H
3584 #include <sys/time.h>
3585 #endif
3586 #ifdef HAVE_SYS_SELECT_H
3587 #include <sys/select.h>
3588 #endif
3589 ],[],[cf_cv_sys_time_select=yes],
3590          [cf_cv_sys_time_select=no])
3591          ])
3592 AC_MSG_RESULT($cf_cv_sys_time_select)
3593 test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>])
3594 ])dnl
3595 dnl ---------------------------------------------------------------------------
3596 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
3597 dnl --------------
3598 dnl Look for term.h, which is part of X/Open curses.  It defines the interface
3599 dnl to terminfo database.  Usually it is in the same include-path as curses.h,
3600 dnl but some packagers change this, breaking various applications.
3601 AC_DEFUN([CF_TERM_HEADER],[
3602 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
3603 case "${cf_cv_ncurses_header}" in
3604 (*/ncurses.h|*/ncursesw.h)
3605         cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
3606         ;;
3607 (*)
3608         cf_term_header=term.h
3609         ;;
3610 esac
3611
3612 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
3613 do
3614 AC_TRY_COMPILE([#include <stdio.h>
3615 #include <${cf_cv_ncurses_header:-curses.h}>
3616 #include <$cf_test>
3617 ],[int x = auto_left_margin; (void)x],[
3618         cf_cv_term_header="$cf_test"],[
3619         cf_cv_term_header=unknown
3620         ])
3621         test "$cf_cv_term_header" != unknown && break
3622 done
3623 ])
3624
3625 # Set definitions to allow ifdef'ing to accommodate subdirectories
3626
3627 case "$cf_cv_term_header" in
3628 (*term.h)
3629         AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
3630         ;;
3631 esac
3632
3633 case "$cf_cv_term_header" in
3634 (ncurses/term.h)
3635         AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
3636         ;;
3637 (ncursesw/term.h)
3638         AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
3639         ;;
3640 esac
3641 ])dnl
3642 dnl ---------------------------------------------------------------------------
3643 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
3644 dnl ---------------
3645 dnl Define a top_builddir symbol, for applications that need an absolute path.
3646 AC_DEFUN([CF_TOP_BUILDDIR],
3647 [
3648 top_builddir=ifelse($1,,`pwd`,$1)
3649 AC_SUBST(top_builddir)
3650 ])dnl
3651 dnl ---------------------------------------------------------------------------
3652 dnl CF_TPUTS_PROTO version: 4 updated: 2021/01/04 19:45:09
3653 dnl --------------
3654 dnl Check for type of function-pointer passed to tputs.  Some old
3655 dnl implementations used functions that had different prototypes, making it