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