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