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