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