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