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