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