1 dnl***************************************************************************
2 dnl Copyright 2018-2019,2020 Thomas E. Dickey *
3 dnl Copyright 1998-2017,2018 Free Software Foundation, Inc. *
5 dnl Permission is hereby granted, free of charge, to any person obtaining a *
6 dnl copy of this software and associated documentation files (the *
7 dnl "Software"), to deal in the Software without restriction, including *
8 dnl without limitation the rights to use, copy, modify, merge, publish, *
9 dnl distribute, distribute with modifications, sublicense, and/or sell *
10 dnl copies of the Software, and to permit persons to whom the Software is *
11 dnl furnished to do so, subject to the following conditions: *
13 dnl The above copyright notice and this permission notice shall be included *
14 dnl in all copies or substantial portions of the Software. *
16 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
17 dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
18 dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
19 dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
20 dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
21 dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
22 dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
24 dnl Except as contained in this notice, the name(s) of the above copyright *
25 dnl holders shall not be used in advertising or otherwise to promote the *
26 dnl sale, use or other dealings in this Software without prior written *
28 dnl***************************************************************************
30 dnl Author: Thomas E. Dickey 1995-on
32 dnl $Id: aclocal.m4,v 1.940 2020/11/20 23:52:27 tom Exp $
33 dnl Macros used in NCURSES auto-configuration script.
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.
39 dnl See these pages for additional information:
40 dnl https://invisible-island.net/autoconf/
41 dnl https://invisible-island.net/autoconf/my-autoconf.html
43 dnl ---------------------------------------------------------------------------
44 dnl ---------------------------------------------------------------------------
45 dnl AM_LANGINFO_CODESET version: 5 updated: 2020/03/10 18:53:47
46 dnl -------------------
47 dnl Inserted as requested by gettext 0.10.40
48 dnl File from /usr/share/aclocal
50 dnl ====================
53 dnl From Bruno Haible.
54 AC_DEFUN([AM_LANGINFO_CODESET],
56 AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
57 [AC_TRY_LINK([#include <langinfo.h>],
58 [char* cs = nl_langinfo(CODESET); (void)cs],
59 am_cv_langinfo_codeset=yes,
60 am_cv_langinfo_codeset=no)
62 if test $am_cv_langinfo_codeset = yes; then
63 AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
64 [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
67 dnl ---------------------------------------------------------------------------
68 dnl CF_ABI_DEFAULTS version: 2 updated: 2015/06/06 13:49:58
70 dnl Provide configure-script defaults for different ncurses ABIs.
71 AC_DEFUN([CF_ABI_DEFAULTS],[
72 AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION])
73 case x$cf_cv_abi_version in
79 cf_dft_ext_spfuncs=yes
80 cf_dft_filter_syms=yes
81 cf_dft_chtype=uint32_t
82 cf_dft_mmask_t=uint32_t
84 cf_dft_tparm_arg=intptr_t
102 dnl ---------------------------------------------------------------------------
103 dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
104 dnl ------------------
105 dnl Conditionally generate script according to whether we're using a given autoconf.
107 dnl $1 = version to compare against
108 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
109 dnl $3 = code to use if AC_ACVERSION is older than $1.
110 define([CF_ACVERSION_CHECK],
112 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
113 ifdef([m4_version_compare],
114 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
115 [CF_ACVERSION_COMPARE(
116 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
117 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
118 dnl ---------------------------------------------------------------------------
119 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
120 dnl --------------------
121 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
122 dnl MAJOR2, MINOR2, TERNARY2,
123 dnl PRINTABLE2, not FOUND, FOUND)
124 define([CF_ACVERSION_COMPARE],
125 [ifelse(builtin([eval], [$2 < $5]), 1,
126 [ifelse([$8], , ,[$8])],
127 [ifelse([$9], , ,[$9])])])dnl
128 dnl ---------------------------------------------------------------------------
129 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
130 dnl -------------------
131 dnl Construct the list of include-options for the C programs in the Ada95
133 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
135 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
136 if test "$srcdir" != "."; then
137 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
139 if test "$GCC" != yes; then
140 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
141 elif test "$includedir" != "/usr/include"; then
142 if test "$includedir" = '${prefix}/include' ; then
143 if test x$prefix != x/usr ; then
144 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
147 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
152 dnl ---------------------------------------------------------------------------
153 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
155 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
156 AC_DEFUN([CF_ADD_ADAFLAGS],[
157 ADAFLAGS="$ADAFLAGS $1"
160 dnl ---------------------------------------------------------------------------
161 dnl CF_ADD_CFLAGS version: 14 updated: 2020/04/04 16:16:13
163 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
164 dnl $1 = flags to add
165 dnl $2 = if given makes this macro verbose.
167 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
168 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
169 dnl confused by the quotes (which require backslashes to keep them usable).
170 AC_DEFUN([CF_ADD_CFLAGS],
175 cf_new_extra_cppflags=
177 for cf_add_cflags in $1
179 case $cf_fix_cppflags in
181 case $cf_add_cflags in
182 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
183 case $cf_add_cflags in
185 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
187 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
188 && test -z "${cf_tst_cflags}" \
189 && cf_fix_cppflags=yes
191 if test $cf_fix_cppflags = yes ; then
192 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
194 elif test "${cf_tst_cflags}" = "\"'" ; then
195 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
204 case $cf_add_cflags in
206 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
207 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
210 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
215 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
220 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
222 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'`
224 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
225 && test -z "${cf_tst_cflags}" \
226 && cf_fix_cppflags=no
231 if test -n "$cf_new_cflags" ; then
232 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
233 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
236 if test -n "$cf_new_cppflags" ; then
237 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
238 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
241 if test -n "$cf_new_extra_cppflags" ; then
242 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
243 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
246 AC_SUBST(EXTRA_CPPFLAGS)
249 dnl ---------------------------------------------------------------------------
250 dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13
252 dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS
253 dnl The second parameter if given makes this macro verbose.
255 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
256 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
257 dnl confused by the quotes (which require backslashes to keep them usable).
258 AC_DEFUN([CF_ADD_CXXFLAGS],
260 cf_save_CXXFLAGS="$CFLAGS"
262 CF_ADD_CFLAGS($1 ifelse($2,,,[,$2]))
264 CFLAGS="$cf_save_CXXFLAGS"
266 dnl ---------------------------------------------------------------------------
267 dnl CF_ADD_INCDIR version: 15 updated: 2018/06/20 20:23:13
269 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
270 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
271 dnl but old versions (and some misinstalled ones) need that. To make things
272 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
273 dnl the include-path).
274 AC_DEFUN([CF_ADD_INCDIR],
276 if test -n "$1" ; then
277 for cf_add_incdir in $1
279 while test $cf_add_incdir != /usr/include
281 if test -d $cf_add_incdir
284 if test -n "$CFLAGS$CPPFLAGS" ; then
285 # a loop is needed to ensure we can add subdirs of existing dirs
286 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
287 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
288 cf_have_incdir=yes; break
293 if test "$cf_have_incdir" = no ; then
294 if test "$cf_add_incdir" = /usr/local/include ; then
297 cf_save_CPPFLAGS=$CPPFLAGS
298 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
299 AC_TRY_COMPILE([#include <stdio.h>],
302 [cf_have_incdir=yes])
303 CPPFLAGS=$cf_save_CPPFLAGS
308 if test "$cf_have_incdir" = no ; then
309 CF_VERBOSE(adding $cf_add_incdir to include-path)
310 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
312 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'`
313 test "$cf_top_incdir" = "$cf_add_incdir" && break
314 cf_add_incdir="$cf_top_incdir"
325 dnl ---------------------------------------------------------------------------
326 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
328 dnl Add a library, used to enforce consistency.
330 dnl $1 = library to add, without the "-l"
331 dnl $2 = variable to update (default $LIBS)
332 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
333 dnl ---------------------------------------------------------------------------
334 dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57
336 dnl Adds to the library-path
338 dnl Some machines have trouble with multiple -L options.
340 dnl $1 is the (list of) directory(s) to add
341 dnl $2 is the optional name of the variable to update (default LDFLAGS)
343 AC_DEFUN([CF_ADD_LIBDIR],
345 if test -n "$1" ; then
346 for cf_add_libdir in $1
348 if test $cf_add_libdir = /usr/lib ; then
350 elif test -d $cf_add_libdir
353 if test -n "$LDFLAGS$LIBS" ; then
354 # a loop is needed to ensure we can add subdirs of existing dirs
355 for cf_test_libdir in $LDFLAGS $LIBS ; do
356 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
357 cf_have_libdir=yes; break
361 if test "$cf_have_libdir" = no ; then
362 CF_VERBOSE(adding $cf_add_libdir to library-path)
363 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
369 dnl ---------------------------------------------------------------------------
370 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
372 dnl Add one or more libraries, used to enforce consistency. Libraries are
373 dnl prepended to an existing list, since their dependencies are assumed to
374 dnl already exist in the list.
376 dnl $1 = libraries to add, with the "-l", etc.
377 dnl $2 = variable to update (default $LIBS)
378 AC_DEFUN([CF_ADD_LIBS],[
379 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
382 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
384 for cf_add_1lib in $cf_add_0lib; do
385 for cf_add_2lib in $cf_add_libs; do
386 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
391 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
393 ifelse($2,,LIBS,[$2])="$cf_add_libs"
395 dnl ---------------------------------------------------------------------------
396 dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05
397 dnl ------------------
398 dnl Append to a search-list for a nonstandard header/lib-file
399 dnl $1 = the variable to return as result
400 dnl $2 = the package name
401 dnl $3 = the subdirectory, e.g., bin, include or lib
402 dnl $4 = the directory under which we will test for subdirectories
403 dnl $5 = a directory that we do not want $4 to match
404 AC_DEFUN([CF_ADD_SUBDIR_PATH],
406 test "x$4" != "x$5" && \
408 ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) {
409 test -n "$verbose" && echo " ... testing for $3-directories under $4"
410 test -d $4/$3 && $1="[$]$1 $4/$3"
411 test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2"
412 test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3"
413 test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3"
414 test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2"
417 dnl ---------------------------------------------------------------------------
418 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
420 dnl use this macro for appending text without introducing an extra blank at
422 define([CF_APPEND_TEXT],
424 test -n "[$]$1" && $1="[$]$1 "
427 dnl ---------------------------------------------------------------------------
428 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
430 dnl Allow user to disable a normally-on option.
431 AC_DEFUN([CF_ARG_DISABLE],
432 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
433 dnl ---------------------------------------------------------------------------
434 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
436 dnl Allow user to enable a normally-off option.
437 AC_DEFUN([CF_ARG_ENABLE],
438 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
439 dnl ---------------------------------------------------------------------------
440 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
442 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
448 dnl $3 = action to perform if option is not default
449 dnl $4 = action if perform if option is default
450 dnl $5 = default option value (either 'yes' or 'no')
451 AC_DEFUN([CF_ARG_OPTION],
452 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
453 if test "$enableval" != "$5" ; then
455 ,[ $3]) ifelse([$4],,,[
458 fi],[enableval=$5 ifelse([$4],,,[
462 dnl ---------------------------------------------------------------------------
463 dnl CF_AR_FLAGS version: 7 updated: 2020/04/04 11:37:29
465 dnl Check for suitable "ar" (archiver) options for updating an archive.
467 dnl In particular, handle some obsolete cases where the "-" might be omitted,
468 dnl as well as a workaround for breakage of make's archive rules by the GNU
469 dnl binutils "ar" program.
470 AC_DEFUN([CF_AR_FLAGS],[
471 AC_REQUIRE([CF_PROG_AR])
473 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
474 case $cf_cv_system_name in
477 cat >mk_static_lib.sh <<-EOF
482 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
484 chmod +x mk_static_lib.sh
485 AR=`pwd`/mk_static_lib.sh
488 cf_cv_ar_flags=unknown
489 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
492 # check if $ARFLAGS already contains this choice
493 if test "x$ARFLAGS" != "x" ; then
494 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
495 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
501 rm -f conftest.$ac_cv_objext
504 cat >conftest.$ac_ext <<EOF
505 #line __oline__ "configure"
506 int testdata[[3]] = { 123, 456, 789 };
508 if AC_TRY_EVAL(ac_compile) ; then
509 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
510 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
511 if test -f conftest.a ; then
512 cf_cv_ar_flags=$cf_ar_flags
516 CF_VERBOSE(cannot compile test-program)
520 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
525 if test -n "$ARFLAGS" ; then
526 if test -n "$cf_cv_ar_flags" ; then
527 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
530 ARFLAGS=$cf_cv_ar_flags
535 dnl ---------------------------------------------------------------------------
536 dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04
537 dnl -----------------
538 dnl Check if awk can handle big strings using printf. Some older versions of
539 dnl awk choke on large strings passed via "%s".
541 dnl $1 = desired string size
542 dnl $2 = variable to set with result
543 AC_DEFUN([CF_AWK_BIG_PRINTF],
550 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \
551 | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then
559 dnl ---------------------------------------------------------------------------
560 dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18
562 dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some
563 dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc
564 dnl 2.6.3 does, in anticipation of the ANSI C++ standard.
566 dnl Treat the configuration-variable specially here, since we're directly
567 dnl substituting its value (i.e., 1/0).
569 dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool
570 AC_DEFUN([CF_BOOL_DECL],
572 AC_MSG_CHECKING(if we should include stdbool.h)
574 AC_CACHE_VAL(cf_cv_header_stdbool_h,[
575 AC_TRY_COMPILE([],[bool foo = false],
576 [cf_cv_header_stdbool_h=0],
581 ],[bool foo = false],
582 [cf_cv_header_stdbool_h=1],
583 [cf_cv_header_stdbool_h=0])])])
585 if test "$cf_cv_header_stdbool_h" = 1
586 then AC_MSG_RESULT(yes)
587 else AC_MSG_RESULT(no)
590 AC_MSG_CHECKING([for builtin bool type])
592 AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[
595 #include <sys/types.h>
597 [ifelse($1,,cf_cv_builtin_bool,[$1])=1],
598 [ifelse($1,,cf_cv_builtin_bool,[$1])=0])
601 if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1
602 then AC_MSG_RESULT(yes)
603 else AC_MSG_RESULT(no)
606 dnl ---------------------------------------------------------------------------
607 dnl CF_BOOL_SIZE version: 17 updated: 2020/10/24 19:48:55
609 dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type).
610 dnl Don't bother looking for bool.h, since it's been deprecated.
612 dnl If the current compiler is C rather than C++, we get the bool definition
613 dnl from <stdbool.h>.
614 AC_DEFUN([CF_BOOL_SIZE],
616 AC_CHECK_SIZEOF(bool,,[
620 #if defined(__cplusplus)
622 #ifdef HAVE_GXX_BUILTIN_H
623 #include <g++/builtin.h>
624 #elif HAVE_GPP_BUILTIN_H
625 #include <gpp/builtin.h>
632 #if $cf_cv_header_stdbool_h
639 AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[
645 #if defined(__cplusplus)
647 #ifdef HAVE_GXX_BUILTIN_H
648 #include <g++/builtin.h>
649 #elif HAVE_GPP_BUILTIN_H
650 #include <gpp/builtin.h>
657 #if $cf_cv_header_stdbool_h
665 FILE *fp = fopen("cf_test.out", "w");
669 fputs("unsigned ", fp);
670 if (sizeof(x) == sizeof(int)) fputs("int", fp);
671 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
672 else if (sizeof(x) == sizeof(short))fputs("short",fp);
673 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
676 ${cf_cv_main_return:-return}(0);
679 [cf_cv_type_of_bool=`cat cf_test.out`
680 if test -z "$cf_cv_type_of_bool"; then
681 cf_cv_type_of_bool=unknown
683 [cf_cv_type_of_bool=unknown],
685 case x$ac_cv_sizeof_bool in
686 (x1) cf_cv_type_of_bool="unsigned char";;
687 (x2) cf_cv_type_of_bool="unsigned short";;
688 (x4) cf_cv_type_of_bool="unsigned int";;
689 (x8) cf_cv_type_of_bool="unsigned long";;
690 (*) cf_cv_type_of_bool=unknown;;
696 if test "$cf_cv_type_of_bool" = unknown ; then
697 case .$NCURSES_BOOL in
698 (.auto|.) NCURSES_BOOL=unsigned;;
700 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
701 cf_cv_type_of_bool=$NCURSES_BOOL
704 dnl ---------------------------------------------------------------------------
705 dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04
707 dnl If we're cross-compiling, allow the user to override the tools and their
708 dnl options. The configure script is oriented toward identifying the host
709 dnl compiler, etc., but we need a build compiler to generate parts of the
712 dnl $1 = default for $CPPFLAGS
713 dnl $2 = default for $LIBS
714 AC_DEFUN([CF_BUILD_CC],[
715 CF_ACVERSION_CHECK(2.52,,
716 [AC_REQUIRE([CF_PROG_EXT])])
717 if test "$cross_compiling" = yes ; then
719 # defaults that we might want to override
720 : ${BUILD_CFLAGS:=''}
721 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
722 : ${BUILD_LDFLAGS:=''}
723 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
724 : ${BUILD_EXEEXT:='$x'}
725 : ${BUILD_OBJEXT:='o'}
727 AC_ARG_WITH(build-cc,
728 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
729 [BUILD_CC="$withval"],
730 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
731 AC_MSG_CHECKING(for native build C compiler)
732 AC_MSG_RESULT($BUILD_CC)
734 AC_MSG_CHECKING(for native build C preprocessor)
735 AC_ARG_WITH(build-cpp,
736 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
737 [BUILD_CPP="$withval"],
738 [BUILD_CPP='${BUILD_CC} -E'])
739 AC_MSG_RESULT($BUILD_CPP)
741 AC_MSG_CHECKING(for native build C flags)
742 AC_ARG_WITH(build-cflags,
743 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
744 [BUILD_CFLAGS="$withval"])
745 AC_MSG_RESULT($BUILD_CFLAGS)
747 AC_MSG_CHECKING(for native build C preprocessor-flags)
748 AC_ARG_WITH(build-cppflags,
749 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
750 [BUILD_CPPFLAGS="$withval"])
751 AC_MSG_RESULT($BUILD_CPPFLAGS)
753 AC_MSG_CHECKING(for native build linker-flags)
754 AC_ARG_WITH(build-ldflags,
755 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
756 [BUILD_LDFLAGS="$withval"])
757 AC_MSG_RESULT($BUILD_LDFLAGS)
759 AC_MSG_CHECKING(for native build linker-libraries)
760 AC_ARG_WITH(build-libs,
761 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
762 [BUILD_LIBS="$withval"])
763 AC_MSG_RESULT($BUILD_LIBS)
765 # this assumes we're on Unix.
769 : ${BUILD_CC:='${CC}'}
771 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
772 AC_MSG_ERROR([Cross-build requires two compilers.
773 Use --with-build-cc to specify the native compiler.])
777 : ${BUILD_CC:='${CC}'}
778 : ${BUILD_CPP:='${CPP}'}
779 : ${BUILD_CFLAGS:='${CFLAGS}'}
780 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
781 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
782 : ${BUILD_LIBS:='${LIBS}'}
783 : ${BUILD_EXEEXT:='$x'}
784 : ${BUILD_OBJEXT:='o'}
789 AC_SUBST(BUILD_CFLAGS)
790 AC_SUBST(BUILD_CPPFLAGS)
791 AC_SUBST(BUILD_LDFLAGS)
793 AC_SUBST(BUILD_EXEEXT)
794 AC_SUBST(BUILD_OBJEXT)
796 dnl ---------------------------------------------------------------------------
797 dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
799 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
800 dnl into CC. This will not help with broken scripts that wrap the compiler
801 dnl with options, but eliminates a more common category of user confusion.
803 dnl In particular, it addresses the problem of being able to run the C
804 dnl preprocessor in a consistent manner.
806 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
807 dnl the nuisance of having inconsistent settings for compiler and preprocessor
808 dnl outweighs that limitation.
809 AC_DEFUN([CF_CC_ENV_FLAGS],
811 # This should have been defined by AC_PROG_CC
814 AC_MSG_CHECKING(\$CFLAGS variable)
817 AC_MSG_RESULT(broken)
818 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
821 for cf_arg in $cf_flags
823 CF_ADD_CFLAGS($cf_arg)
831 AC_MSG_CHECKING(\$CC variable)
834 AC_MSG_RESULT(broken)
835 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
837 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
838 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
840 for cf_arg in $cf_flags
844 CF_ADD_CFLAGS($cf_arg)
851 CF_VERBOSE(resulting CC: '$CC')
852 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
853 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
860 dnl ---------------------------------------------------------------------------
861 dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
863 dnl Determine the default configuration into which we'll install ncurses. This
864 dnl can be overridden by the user's command-line options. There's two items to
866 dnl 1. the prefix (e.g., /usr)
867 dnl 2. the header files (e.g., /usr/include/ncurses)
868 dnl We'll look for a previous installation of ncurses and use the same defaults.
870 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
871 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
872 dnl programs from a vendor's.
873 AC_DEFUN([CF_CFG_DEFAULTS],
875 AC_MSG_CHECKING(for prefix)
876 if test "x$prefix" = "xNONE" ; then
877 case "$cf_cv_system_name" in
878 # non-vendor systems don't have a conflict
879 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
882 (*) prefix=$ac_default_prefix
886 AC_MSG_RESULT($prefix)
888 if test "x$prefix" = "xNONE" ; then
889 AC_MSG_CHECKING(for default include-directory)
890 test -n "$verbose" && echo 1>&AC_FD_MSG
893 $includedir/ncurses \
895 $prefix/include/ncurses \
897 /usr/local/include/ncurses \
901 cf_dir=`eval echo $cf_symbol`
902 if test -f $cf_dir/curses.h ; then
903 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
904 includedir="$cf_symbol"
905 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
909 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
911 AC_MSG_RESULT($includedir)
914 dnl ---------------------------------------------------------------------------
915 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
917 dnl Check if the terminal-capability database functions are available. If not,
918 dnl ncurses has a much-reduced version.
919 AC_DEFUN([CF_CGETENT],[
920 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
922 #include <stdlib.h>],[
925 char *db_array = temp;
926 cgetent(&buf, &db_array, "vt100");
927 cgetcap(buf, "tc", '=');
928 cgetmatch(buf, "tc");
934 if test "$cf_cv_cgetent" = yes
936 AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
937 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
939 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
940 #include <stdlib.h>],[
943 #ifndef _NETBSD_SOURCE /* given, since April 2004 in stdlib.h */
944 const char *db_array = temp;
945 cgetent(&buf, &db_array, "vt100");
947 cgetcap(buf, "tc", '=');
948 cgetmatch(buf, "tc");
950 [cf_cv_cgetent_const=yes],
951 [cf_cv_cgetent_const=no])
953 if test "$cf_cv_cgetent_const" = yes
955 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
959 dnl ---------------------------------------------------------------------------
960 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
962 dnl Check if we're accidentally using a cache from a different machine.
963 dnl Derive the system name, as a check for reusing the autoconf cache.
965 dnl If we've packaged config.guess and config.sub, run that (since it does a
966 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
967 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
968 dnl which is useful in cross-compiles.
970 dnl Note: we would use $ac_config_sub, but that is one of the places where
971 dnl autoconf 2.5x broke compatibility with autoconf 2.13
972 AC_DEFUN([CF_CHECK_CACHE],
974 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
975 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
976 system_name="$host_os"
978 system_name="`(uname -s -r) 2>/dev/null`"
979 if test -z "$system_name" ; then
980 system_name="`(hostname) 2>/dev/null`"
983 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
984 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
986 test -z "$system_name" && system_name="$cf_cv_system_name"
987 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
989 if test ".$system_name" != ".$cf_cv_system_name" ; then
990 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
991 AC_MSG_ERROR("Please remove config.cache and try again.")
994 dnl ---------------------------------------------------------------------------
995 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
997 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
998 dnl variable. Define a DECL_xxx symbol if we must declare it ourselves.
1000 dnl $1 = the name to check
1001 dnl $2 = the assumed type
1002 AC_DEFUN([CF_CHECK_ENVIRON],
1004 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1006 #ifdef HAVE_STDLIB_H
1009 #include <unistd.h> ],
1010 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
1015 if test "$cf_cv_dcl_$1" = no ; then
1016 CF_UPPER(cf_result,decl_$1)
1017 AC_DEFINE_UNQUOTED($cf_result)
1020 # It's possible (for near-UNIX clones) that the data doesn't exist
1021 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1023 dnl ---------------------------------------------------------------------------
1024 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
1026 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
1027 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
1030 dnl $1 = the name to check
1031 dnl $2 = the assumed type
1032 AC_DEFUN([CF_CHECK_ERRNO],
1034 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1036 #ifdef HAVE_STDLIB_H
1040 #include <sys/types.h>
1041 #include <errno.h> ],
1042 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1047 if test "$cf_cv_dcl_$1" = no ; then
1048 CF_UPPER(cf_result,decl_$1)
1049 AC_DEFINE_UNQUOTED($cf_result)
1052 # It's possible (for near-UNIX clones) that the data doesn't exist
1053 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1055 dnl ---------------------------------------------------------------------------
1056 dnl CF_CHECK_EXTERN_DATA version: 4 updated: 2015/04/18 08:56:57
1057 dnl --------------------
1058 dnl Check for existence of external data in the current set of libraries. If
1059 dnl we can modify it, it's real enough.
1060 dnl $1 = the name to check
1062 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1064 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1070 [cf_cv_have_$1=yes],
1074 if test "$cf_cv_have_$1" = yes ; then
1075 CF_UPPER(cf_result,have_$1)
1076 AC_DEFINE_UNQUOTED($cf_result)
1080 dnl ---------------------------------------------------------------------------
1081 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1082 dnl --------------------
1083 dnl Check whether the compiler understands -fvisibility=hidden
1086 dnl $2 = compiler-flags variable name
1087 dnl $3 = cache variable to set
1088 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1089 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1090 cf_save_cflags="[$]$2"
1091 $2="[$]$2 -fvisibility=hidden"
1093 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1095 if (somefunc()) return 1;
1102 dnl ---------------------------------------------------------------------------
1103 dnl CF_CHECK_GETENV version: 1 updated: 2019/06/23 15:28:15
1105 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1106 dnl discard the previous pointer when returning a new one.
1107 AC_DEFUN([CF_CHECK_GETENV],
1109 AC_REQUIRE([CF_CHECK_ENVIRON])
1110 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1111 AC_CHECK_FUNCS( putenv setenv strdup )
1112 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1118 #include <sys/types.h>
1120 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1121 extern char **environ; /* POSIX, but some systems are not... */
1124 #if defined(HAVE_STRDUP)
1125 #define str_alloc(s) strdup(s)
1127 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1130 static void set_value(const char *name, const char *value)
1132 #if defined(HAVE_SETENV)
1133 setenv(name, value, 1);
1134 #elif defined(HAVE_PUTENV)
1136 sprintf(buffer, "%s=%s", name, value);
1137 putenv(str_alloc(buffer));
1139 #error neither putenv/setenv found
1145 size_t numenv, limit, j;
1150 for (numenv = 0; environ[numenv]; ++numenv) ;
1151 limit = numenv + 10;
1152 mynames = (char **) calloc(limit + 1, sizeof(char *));
1153 myvalues = (char **) calloc(limit + 1, sizeof(char *));
1154 mypointer = (char **) calloc(limit + 1, sizeof(char *));
1155 #if defined(HAVE_ENVIRON)
1156 for (j = 0; environ[j]; ++j) {
1157 mynames[j] = str_alloc(environ[j]);
1158 equals = strchr(mynames[j], '=');
1161 myvalues[j] = str_alloc(equals);
1163 myvalues[j] = str_alloc("");
1167 for (j = numenv; j < limit; ++j) {
1175 sprintf(name, "TERM%lu", (unsigned long) k);
1176 for (jk = 0; jk < j; ++jk) {
1177 if (!strcmp(name, mynames[jk])) {
1184 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1185 set_value(name, value);
1186 mynames[j] = str_alloc(name);
1187 myvalues[j] = str_alloc(value);
1189 for (pass = 0; pass < 3; ++pass) {
1190 for (j = 0; j < limit; ++j) {
1191 char *value = getenv(mynames[j]);
1194 fprintf(stderr, "getenv returned null for %s\n", mynames[j]);
1195 ${cf_cv_main_return:-return}(1);
1196 } else if (value != mypointer[j]) {
1197 fprintf(stderr, "getenv returned different pointer for %s\n", mynames[j]);
1198 ${cf_cv_main_return:-return}(1);
1199 } else if (strcmp(value, myvalues[j])) {
1200 fprintf(stderr, "getenv returned different value for %s\n", mynames[j]);
1201 ${cf_cv_main_return:-return}(1);
1205 mypointer[j] = value;
1206 for (k = 0; k < j; ++k) {
1207 if (mypointer[j] == mypointer[k]) {
1208 fprintf(stderr, "getenv returned same pointer for %s and %s\n", mynames[j], mynames[k]);
1209 ${cf_cv_main_return:-return}(1);
1215 ${cf_cv_main_return:-return}(0);
1218 [cf_cv_consistent_getenv=yes],
1219 [cf_cv_consistent_getenv=no],
1220 [cf_cv_consistent_getenv=unknown])
1223 if test "x$cf_cv_consistent_getenv" = xno
1225 AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1228 dnl ---------------------------------------------------------------------------
1229 dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
1230 dnl ---------------------
1231 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1233 AC_REQUIRE([CF_GNAT_VERSION])
1234 case $cf_cv_gnat_version in
1235 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1236 cf_cv_prog_gnat_correct=yes
1239 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1240 cf_cv_prog_gnat_correct=no
1244 dnl ---------------------------------------------------------------------------
1245 dnl CF_CHECK_GPM_WGETCH version: 3 updated: 2017/01/21 11:06:25
1246 dnl -------------------
1247 dnl Check if GPM is already linked with curses. If so - and if the linkage
1248 dnl is not "weak" - warn about this because it can create problems linking
1249 dnl applications with ncurses.
1250 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1251 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1253 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1254 cf_cv_check_gpm_wgetch=unknown
1255 if test "$cross_compiling" != yes ; then
1257 cat >conftest.$ac_ext <<CF_EOF
1262 ${cf_cv_main_return:-return}(0);
1266 cf_save_LIBS="$LIBS"
1267 # This only works if we can look at the symbol table. If a shared
1268 # library is stripped for install, we cannot use that. So we're forced
1269 # to rely on the static library, noting that some packagers may not
1271 LIBS="-static -lgpm -dynamic $LIBS"
1272 if AC_TRY_EVAL(ac_compile) ; then
1273 if AC_TRY_EVAL(ac_link) ; then
1274 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
1275 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1276 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1280 LIBS="$cf_save_LIBS"
1284 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1285 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1288 dnl ---------------------------------------------------------------------------
1289 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
1290 dnl ------------------------
1291 dnl Show the version of libtool
1293 dnl Save the version in a cache variable - this is not entirely a good thing,
1294 dnl but the version string from libtool is very ugly, and for bug reports it
1295 dnl might be useful to have the original string.
1296 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1297 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1299 AC_MSG_CHECKING(version of $LIBTOOL)
1301 AC_MSG_RESULT($cf_cv_libtool_version)
1302 if test -z "$cf_cv_libtool_version" ; then
1303 AC_MSG_ERROR(This is not GNU libtool)
1306 AC_MSG_ERROR(GNU libtool has not been found)
1309 dnl ---------------------------------------------------------------------------
1310 dnl CF_CHECK_WCHAR_H version: 2 updated: 2017/01/21 11:06:25
1311 dnl ----------------
1312 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1313 AC_DEFUN([CF_CHECK_WCHAR_H],[
1318 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1325 #ifdef HAVE_WCTYPE_H
1330 int bar = iswpunct(foo)],
1331 [cf_cv_wchar_h_okay=yes],
1332 [cf_cv_wchar_h_okay=no])])
1334 if test $cf_cv_wchar_h_okay = no
1336 CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1339 dnl ---------------------------------------------------------------------------
1340 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 1 updated: 2015/12/19 17:47:56
1341 dnl -------------------------
1342 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1343 dnl should support line-drawing. Even with Unicode. There is a problem.
1345 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1346 dnl all of those were combined into a page of useful graphics characters.
1348 dnl So far, so good.
1350 dnl However, while they are useful, there are other considerations. CJK
1351 dnl is (because of poor device resolution) often rendered as double-width
1352 dnl characters. So... for these generally-useful characters, what should
1353 dnl be the width (to make them consistent with adjacent characters)?
1355 dnl The obvious choice would have been to make this locale-dependent, and use
1356 dnl wcwidth() to tell applications what the actual width is. That was too
1357 dnl obvious. Instead, we have a slew of "ambiguous-width" characters.
1359 dnl http://www.unicode.org/reports/tr11/tr11-29.html
1360 dnl http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1362 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1363 dnl more than 22,000 characters, with 1281 of those as ambiguous-width. For
1364 dnl instance, it lists half (44/96) of the Latin-1 characters as
1365 dnl ambiguous-width. Also, all of the box-characters at 0x2500 are ambiguous.
1367 dnl What this means for the implementor is that on some systems wcwidth() can
1368 dnl give bad advice. On Solaris, some of the ambiguous widths are returned as
1369 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1370 dnl characters). These do not necessarily match the behavior of the terminal
1371 dnl emulator. xterm, for instance, does an optional startup check to find if
1372 dnl this problem (or similar) exists with the system's locale tables, rejecting
1373 dnl them if they are too unreliable.
1374 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1375 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1376 cat >conftest.in <<CF_EOF
1378 0x250c upper left corner
1379 0x2514 lower left corner
1380 0x2510 upper right corner
1381 0x2518 lower right corner
1382 0x251c tee pointing left
1383 0x2524 tee pointing right
1384 0x2534 tee pointing up
1385 0x252c tee pointing down
1386 0x2500 horizontal line
1387 0x2502 vertical line
1388 0x253c large plus or crossover
1392 0x2592 checker board (stipple)
1393 0x00b0 degree symbol
1396 - Teletype 5410v1 symbols
1397 0x2190 arrow pointing left
1398 0x2192 arrow pointing right
1399 0x2193 arrow pointing down
1400 0x2191 arrow pointing up
1401 0x2592 board of squares
1402 0x2603 lantern symbol
1403 0x25ae solid square block
1404 - these defaults were invented for ncurses
1407 0x2264 less-than-or-equal-to
1408 0x2265 greater-than-or-equal-to
1411 0x00a3 pound-sterling symbol
1412 - thick-line-drawing
1413 0x250f upper left corner
1414 0x2517 lower left corner
1415 0x2513 upper right corner
1416 0x251b lower right corner
1417 0x2523 tee pointing left
1418 0x252b tee pointing right
1419 0x253b tee pointing up
1420 0x2533 tee pointing down
1421 0x2501 horizontal line
1422 0x2503 vertical line
1423 0x254b large plus or crossover
1424 - double-line-drawing
1425 0x2554 upper left corner
1426 0x255a lower left corner
1427 0x2557 upper right corner
1428 0x255d lower right corner
1429 0x2563 tee pointing left
1430 0x2560 tee pointing right
1431 0x2569 tee pointing up
1432 0x2566 tee pointing down
1433 0x2550 horizontal line
1434 0x2551 vertical line
1435 0x256c large plus or crossover
1449 char buffer[MY_LEN + 1];
1450 char notes[MY_LEN + 1];
1454 if (setlocale(LC_ALL, "en_US.UTF8") ||
1455 setlocale(LC_ALL, "en_US.UTF-8") ||
1456 setlocale(LC_ALL, "en_US.utf8") ||
1457 setlocale(LC_ALL, "en_US.utf-8")) {
1458 if ((fp = fopen("conftest.in", "r")) != 0) {
1459 while (fgets(buffer, MY_LEN, fp) != 0) {
1460 if (*buffer == '-') {
1461 fprintf(stderr, "\t%s", buffer);
1462 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1464 if (wcwidth(value) == 1)
1466 fprintf(stderr, "%d\t%s", wcwidth(value), buffer);
1468 fprintf(stderr, "?\t%s", buffer);
1473 fprintf(stderr, "%d/%d passed wcwidth/graphics check\n", passed, totals);
1474 return (totals == passed) ? 0 : 1;
1477 [cf_cv_wcwidth_graphics=yes],
1478 [cf_cv_wcwidth_graphics=no],
1479 [cf_cv_wcwidth_graphics=unknown])
1482 dnl ---------------------------------------------------------------------------
1483 dnl CF_CLANG_COMPILER version: 5 updated: 2020/11/20 18:52:27
1484 dnl -----------------
1485 dnl Check if the given compiler is really clang. clang's C driver defines
1486 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1487 dnl not ignore some gcc options.
1489 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1490 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1491 dnl the wrappers for gcc and g++ warnings.
1493 dnl $1 = GCC (default) or GXX
1494 dnl $2 = CLANG_COMPILER (default)
1495 dnl $3 = CFLAGS (default) or CXXFLAGS
1496 AC_DEFUN([CF_CLANG_COMPILER],[
1497 ifelse([$2],,CLANG_COMPILER,[$2])=no
1499 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1500 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1501 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1507 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1509 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1510 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1513 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
1514 for cf_clang_opt in \
1515 -Qunused-arguments \
1516 -Wno-error=implicit-function-declaration
1518 AC_MSG_CHECKING(if option $cf_clang_opt works)
1519 cf_save_CFLAGS="$CFLAGS"
1520 CFLAGS="$CFLAGS $cf_clang_opt"
1522 #include <stdio.h>],[
1523 printf("hello!\n");],[
1524 cf_clang_optok=yes],[
1526 AC_MSG_RESULT($cf_clang_optok)
1527 CFLAGS="$cf_save_CFLAGS"
1528 if test $cf_clang_optok = yes; then
1529 CF_VERBOSE(adding option $cf_clang_opt)
1530 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
1535 dnl ---------------------------------------------------------------------------
1536 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
1537 dnl -----------------
1538 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1539 dnl character-strings.
1541 dnl It is ambiguous because the specification accommodated the pre-ANSI
1542 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1543 dnl compiler other than by costly add-ons. Because of this, the specification
1544 dnl did not take into account the use of const for telling the compiler that
1545 dnl string literals would be in readonly memory.
1547 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1548 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1549 dnl That does not solve the problem of using the block of Xt's strings which
1550 dnl are compiled into the library (and is less efficient than one might want).
1552 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1553 dnl when compiling the library and compiling using the library, to tell the
1554 dnl compiler that String is const.
1555 AC_DEFUN([CF_CONST_X_STRING],
1557 AC_REQUIRE([AC_PATH_XTRA])
1559 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1564 #include <X11/Intrinsic.h>
1566 [String foo = malloc(1); (void)foo],[
1568 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1571 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1572 #undef XTSTRINGDEFINES /* X11R5 and later */
1574 #include <X11/Intrinsic.h>
1575 ],[String foo = malloc(1); *foo = 0],[
1576 cf_cv_const_x_string=no
1578 cf_cv_const_x_string=yes
1582 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1584 case $cf_cv_const_x_string in
1586 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1589 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1595 dnl ---------------------------------------------------------------------------
1596 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1597 dnl -----------------
1598 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
1599 dnl is a late feature for the standard and is not in some recent compilers
1601 AC_DEFUN([CF_CPP_PARAM_INIT],
1603 if test -n "$CXX"; then
1604 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1616 TEST::TEST(int x = 1) // some compilers do not like second initializer
1622 [cf_cv_cpp_param_init=yes],
1623 [cf_cv_cpp_param_init=no],
1624 [cf_cv_cpp_param_init=unknown])
1628 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1630 dnl ---------------------------------------------------------------------------
1631 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1632 dnl ------------------
1633 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
1634 dnl not be supported in g++ before 3.0
1635 AC_DEFUN([CF_CPP_STATIC_CAST],
1637 if test -n "$CXX"; then
1639 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1647 NCursesPanel(int nlines,
1657 template<class T> class NCursesUserPanel : public NCursesPanel
1660 NCursesUserPanel (int nlines,
1664 const T* p_UserData = static_cast<T*>(0))
1665 : NCursesPanel (nlines, ncols, begin_y, begin_x)
1668 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1672 virtual ~NCursesUserPanel() {};
1675 const char* p_UserData = static_cast<char*>(0)],
1676 [cf_cv_cpp_static_cast=yes],
1677 [cf_cv_cpp_static_cast=no])
1684 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1686 dnl ---------------------------------------------------------------------------
1687 dnl CF_CXX_AR_FLAGS version: 2 updated: 2015/04/17 21:13:04
1689 dnl Setup special archiver flags for given compilers.
1690 AC_DEFUN([CF_CXX_AR_FLAGS],[
1692 CXX_ARFLAGS='$(ARFLAGS)'
1693 case $cf_cv_system_name in
1695 if test "$GXX" != yes ; then
1697 CXX_ARFLAGS='-ar -o'
1701 CXXLDFLAGS="-u main"
1704 if test "$GXX" != yes ; then
1706 CXX_ARFLAGS='-xar -o'
1710 AC_SUBST(CXXLDFLAGS)
1712 AC_SUBST(CXX_ARFLAGS)
1714 dnl ---------------------------------------------------------------------------
1715 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1716 dnl -------------------------
1717 dnl For c++, check if iostream uses "std::" namespace.
1718 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1719 AC_CHECK_HEADERS(iostream)
1720 if test x"$ac_cv_header_iostream" = xyes ; then
1721 AC_MSG_CHECKING(if iostream uses std-namespace)
1726 cerr << "testing" << endl;
1727 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1728 AC_MSG_RESULT($cf_iostream_namespace)
1729 if test "$cf_iostream_namespace" = yes ; then
1730 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1734 dnl ---------------------------------------------------------------------------
1735 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1737 dnl Check if the C compiler supports "inline".
1738 dnl $1 is the name of a shell variable to set if inline is supported
1739 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1740 AC_DEFUN([CF_C_INLINE],[
1741 AC_REQUIRE([CF_GCC_VERSION])
1744 if test "$ac_cv_c_inline" != no ; then
1746 if test "$INTEL_COMPILER" = yes
1749 elif test "$CLANG_COMPILER" = yes
1752 elif test "$GCC" = yes
1754 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1755 cf_save_CFLAGS=$CFLAGS
1756 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1757 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1758 [${cf_cv_main_return:-return} foo()],
1759 [cf_cv_gcc_inline=yes],
1760 [cf_cv_gcc_inline=no])
1761 CFLAGS=$cf_save_CFLAGS
1763 if test "$cf_cv_gcc_inline" = yes ; then
1764 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1770 dnl ---------------------------------------------------------------------------
1771 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1773 dnl "dirname" is not portable, so we fake it with a shell script.
1774 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1775 dnl ---------------------------------------------------------------------------
1776 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1778 AC_DEFUN([CF_DIRS_TO_MAKE],
1781 for cf_item in $cf_list_models
1783 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1784 for cf_item2 in $DIRS_TO_MAKE
1786 test $cf_item2 = $cf_subdir && break
1788 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1790 for cf_dir in $DIRS_TO_MAKE
1792 test ! -d $cf_dir && mkdir $cf_dir
1794 AC_SUBST(DIRS_TO_MAKE)
1796 dnl ---------------------------------------------------------------------------
1797 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1799 dnl You can always use "make -n" to see the actual options, but it's hard to
1800 dnl pick out/analyze warning messages when the compile-line is long.
1803 dnl ECHO_LT - symbol to control if libtool is verbose
1804 dnl ECHO_LD - symbol to prefix "cc -o" lines
1805 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1806 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1807 dnl ECHO_CC - symbol to put before any "cc" line
1809 AC_DEFUN([CF_DISABLE_ECHO],[
1810 AC_MSG_CHECKING(if you want to see long compiling messages)
1811 CF_ARG_DISABLE(echo,
1812 [ --disable-echo do not display "compiling" commands],
1815 ECHO_LD='@echo linking [$]@;'
1816 RULE_CC='@echo compiling [$]<'
1817 SHOW_CC='@echo compiling [$]@'
1826 AC_MSG_RESULT($enableval)
1833 dnl ---------------------------------------------------------------------------
1834 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1835 dnl ------------------------
1836 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1837 AC_MSG_CHECKING(if we want to use GNAT projects)
1838 CF_ARG_DISABLE(gnat-projects,
1839 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1840 [enable_gnat_projects=no],
1841 [enable_gnat_projects=yes])
1842 AC_MSG_RESULT($enable_gnat_projects)
1844 dnl ---------------------------------------------------------------------------
1845 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1846 dnl ----------------
1847 dnl Combine no-leak checks with the libraries or tools that are used for the
1849 AC_DEFUN([CF_DISABLE_LEAKS],[
1851 AC_REQUIRE([CF_WITH_DMALLOC])
1852 AC_REQUIRE([CF_WITH_DBMALLOC])
1853 AC_REQUIRE([CF_WITH_VALGRIND])
1855 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1856 AC_ARG_ENABLE(leaks,
1857 [ --disable-leaks test: free permanent memory, analyze leaks],
1858 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1859 : ${with_no_leaks:=no})
1860 AC_MSG_RESULT($with_no_leaks)
1862 if test "$with_no_leaks" = yes ; then
1863 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1864 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1867 dnl ---------------------------------------------------------------------------
1868 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1869 dnl --------------------------
1870 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1871 dnl the older "-version-info" feature. The newer feature allows us to use
1872 dnl version numbering on shared libraries which make them compatible with
1873 dnl various systems.
1874 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1876 AC_MSG_CHECKING(if libtool -version-number should be used)
1877 CF_ARG_DISABLE(libtool-version,
1878 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1879 [cf_libtool_version=no],
1880 [cf_libtool_version=yes])
1881 AC_MSG_RESULT($cf_libtool_version)
1883 if test "$cf_libtool_version" = yes ; then
1884 LIBTOOL_VERSION="-version-number"
1886 LIBTOOL_VERSION="-version-info"
1889 AC_MSG_WARN(VERSION was not set)
1892 ABI_VERSION="$VERSION"
1893 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1896 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1897 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1900 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1905 AC_SUBST(ABI_VERSION)
1906 AC_SUBST(LIBTOOL_VERSION)
1908 dnl ---------------------------------------------------------------------------
1909 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1910 dnl ---------------------
1911 dnl The rpath-hack makes it simpler to build programs, particularly with the
1912 dnl *BSD ports which may have essential libraries in unusual places. But it
1913 dnl can interfere with building an executable for the base system. Use this
1914 dnl option in that case.
1915 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1917 AC_MSG_CHECKING(if rpath-hack should be disabled)
1918 CF_ARG_DISABLE(rpath-hack,
1919 [ --disable-rpath-hack don't add rpath options for additional libraries],
1920 [cf_disable_rpath_hack=yes],
1921 [cf_disable_rpath_hack=no])
1922 AC_MSG_RESULT($cf_disable_rpath_hack)
1923 if test "$cf_disable_rpath_hack" = no ; then
1927 dnl ---------------------------------------------------------------------------
1928 dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
1929 dnl -----------------------
1930 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
1931 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1932 dnl an unconditional feature.
1933 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1935 AC_MSG_CHECKING(if you want broken-linker support code)
1936 AC_ARG_ENABLE(broken_linker,
1937 [ --enable-broken_linker compile with broken-linker support code],
1938 [with_broken_linker=$enableval],
1939 [with_broken_linker=no])
1940 AC_MSG_RESULT($with_broken_linker)
1942 : ${BROKEN_LINKER:=0}
1943 if test "x$with_broken_linker" = xyes ; then
1944 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1947 AC_SUBST(BROKEN_LINKER)
1949 dnl ---------------------------------------------------------------------------
1950 dnl CF_ENABLE_PC_FILES version: 13 updated: 2015/11/01 05:27:39
1951 dnl ------------------
1952 dnl This is the "--enable-pc-files" option, which is available if there is a
1953 dnl pkg-config configuration on the local machine.
1954 AC_DEFUN([CF_ENABLE_PC_FILES],[
1955 AC_REQUIRE([CF_PKG_CONFIG])
1956 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1958 if test "x$PKG_CONFIG" != xnone
1960 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1962 AC_MSG_CHECKING(if we should install .pc files)
1965 AC_ARG_ENABLE(pc-files,
1966 [ --enable-pc-files generate and install .pc files for pkg-config],
1967 [enable_pc_files=$enableval],
1968 [enable_pc_files=no])
1969 AC_MSG_RESULT($enable_pc_files)
1971 if test "x$enable_pc_files" != xno
1974 case "x$PKG_CONFIG_LIBDIR" in
1976 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
1979 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1985 AC_SUBST(MAKE_PC_FILES)
1987 dnl ---------------------------------------------------------------------------
1988 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1990 dnl Check if the rpath option should be used, setting cache variable
1991 dnl cf_cv_enable_rpath if so.
1992 AC_DEFUN([CF_ENABLE_RPATH],
1994 AC_MSG_CHECKING(if rpath option should be used)
1995 AC_ARG_ENABLE(rpath,
1996 [ --enable-rpath use rpath option when generating shared libraries],
1997 [cf_cv_enable_rpath=$enableval],
1998 [cf_cv_enable_rpath=no])
1999 AC_MSG_RESULT($cf_cv_enable_rpath)
2001 dnl ---------------------------------------------------------------------------
2002 dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11
2003 dnl ----------------------
2004 dnl On a few platforms, the compiler and/or loader nags with untruthful
2005 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
2006 dnl and implying that most uses of the recommended alternatives are correct.
2008 dnl Factually speaking, no one has actually counted the number of uses of these
2009 dnl functions versus the total of incorrect uses. Samples of a few thousand
2010 dnl instances are meaningless compared to the hundreds of millions of lines of
2011 dnl existing C code.
2013 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
2014 dnl platforms, in implementations of varying quality. Likewise, snprintf is
2015 dnl standard - but evolved through phases, and older implementations are likely
2016 dnl to yield surprising results, as documented in manpages on various systems.
2017 AC_DEFUN([CF_ENABLE_STRING_HACKS],
2019 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
2020 AC_ARG_ENABLE(string-hacks,
2021 [ --enable-string-hacks work around bogus compiler/loader warnings],
2022 [with_string_hacks=$enableval],
2023 [with_string_hacks=no])
2024 AC_MSG_RESULT($with_string_hacks)
2026 if test "x$with_string_hacks" = "xyes"; then
2027 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
2028 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
2029 AC_CHECK_FUNC(strlcat,[
2030 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2032 AC_CHECK_LIB(bsd,strlcat,[
2034 AC_CHECK_HEADERS(bsd/string.h)
2035 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
2038 AC_CHECK_FUNCS( strlcpy snprintf )
2041 dnl ---------------------------------------------------------------------------
2042 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
2043 dnl ------------------
2044 dnl Configure-option to enable gcc warnings
2046 dnl $1 = extra options to add, if supported
2047 dnl $2 = option for checking attributes. By default, this is done when
2048 dnl warnings are enabled. For other values:
2049 dnl yes: always do this, e.g., to use in generated library-headers
2050 dnl no: never do this
2051 AC_DEFUN([CF_ENABLE_WARNINGS],[
2052 if ( test "$GCC" = yes || test "$GXX" = yes )
2054 CF_FIX_WARNINGS(CFLAGS)
2055 CF_FIX_WARNINGS(CPPFLAGS)
2056 CF_FIX_WARNINGS(LDFLAGS)
2057 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2058 CF_ARG_ENABLE(warnings,
2059 [ --enable-warnings test: turn on gcc compiler warnings],
2060 [with_warnings=yes],
2062 AC_MSG_RESULT($with_warnings)
2063 if test "$with_warnings" = "yes"
2065 ifelse($2,,[CF_GCC_ATTRIBUTES])
2068 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2071 dnl ---------------------------------------------------------------------------
2072 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2074 dnl Check if 'errno' is declared in <errno.h>
2075 AC_DEFUN([CF_ERRNO],
2077 CF_CHECK_ERRNO(errno)
2079 dnl ---------------------------------------------------------------------------
2080 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
2082 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2083 dnl math.h and builtin.h, only for ncurses
2084 AC_DEFUN([CF_ETIP_DEFINES],
2086 AC_MSG_CHECKING(for special defines needed for etip.h)
2087 cf_save_CXXFLAGS="$CXXFLAGS"
2090 # etip.h includes ncurses.h which includes ncurses_dll.h
2091 # But ncurses_dll.h is generated - fix here.
2092 test -d include || mkdir include
2093 test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' ${srcdir}/include/ncurses_dll.h.in >include/ncurses_dll.h
2095 for cf_math in "" MATH_H
2097 for cf_excp in "" MATH_EXCEPTION
2099 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2100 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2101 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2103 #include <etip.h.in>
2105 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2106 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2107 cf_result="$cf_math $cf_excp"
2112 AC_MSG_RESULT($cf_result)
2113 CXXFLAGS="$cf_save_CXXFLAGS"
2115 dnl ---------------------------------------------------------------------------
2116 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
2118 dnl Find a library (specifically the linkage used in the code fragment),
2119 dnl searching for it if it is not already in the library path.
2120 dnl See also CF_ADD_SEARCHPATH.
2122 dnl Parameters (4-on are optional):
2123 dnl $1 = headers for library entrypoint
2124 dnl $2 = code fragment for library entrypoint
2125 dnl $3 = the library name without the "-l" option or ".so" suffix.
2126 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
2127 dnl $5 = action to perform if not successful
2128 dnl $6 = module name, if not the same as the library name
2129 dnl $7 = extra libraries
2131 dnl Sets these variables:
2132 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2133 dnl $cf_cv_header_path_$3 - include-directory if needed
2134 dnl $cf_cv_library_path_$3 - library-directory if needed
2135 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2136 AC_DEFUN([CF_FIND_LINKAGE],[
2138 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2139 # will be set on completion of the AC_TRY_LINK below.
2140 cf_cv_header_path_$3=
2141 cf_cv_library_path_$3=
2143 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2145 cf_save_LIBS="$LIBS"
2147 AC_TRY_LINK([$1],[$2],[
2148 cf_cv_find_linkage_$3=yes
2149 cf_cv_header_path_$3=/usr/include
2150 cf_cv_library_path_$3=/usr/lib
2153 LIBS="-l$3 $7 $cf_save_LIBS"
2155 AC_TRY_LINK([$1],[$2],[
2156 cf_cv_find_linkage_$3=yes
2157 cf_cv_header_path_$3=/usr/include
2158 cf_cv_library_path_$3=/usr/lib
2159 cf_cv_library_file_$3="-l$3"
2161 cf_cv_find_linkage_$3=no
2162 LIBS="$cf_save_LIBS"
2164 CF_VERBOSE(find linkage for $3 library)
2165 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2167 cf_save_CPPFLAGS="$CPPFLAGS"
2168 cf_test_CPPFLAGS="$CPPFLAGS"
2170 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2171 for cf_cv_header_path_$3 in $cf_search
2173 if test -d $cf_cv_header_path_$3 ; then
2174 CF_VERBOSE(... testing $cf_cv_header_path_$3)
2175 CPPFLAGS="$cf_save_CPPFLAGS"
2176 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2177 AC_TRY_COMPILE([$1],[$2],[
2178 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2179 cf_cv_find_linkage_$3=maybe
2180 cf_test_CPPFLAGS="$CPPFLAGS"
2182 CPPFLAGS="$cf_save_CPPFLAGS"
2187 if test "$cf_cv_find_linkage_$3" = maybe ; then
2189 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2191 cf_save_LIBS="$LIBS"
2192 cf_save_LDFLAGS="$LDFLAGS"
2195 CPPFLAGS="$cf_test_CPPFLAGS"
2196 LIBS="-l$3 $7 $cf_save_LIBS"
2197 AC_TRY_LINK([$1],[$2],[
2198 CF_VERBOSE(... found $3 library in system)
2199 cf_cv_find_linkage_$3=yes])
2200 CPPFLAGS="$cf_save_CPPFLAGS"
2201 LIBS="$cf_save_LIBS"
2204 if test "$cf_cv_find_linkage_$3" != yes ; then
2205 CF_LIBRARY_PATH(cf_search,$3)
2206 for cf_cv_library_path_$3 in $cf_search
2208 if test -d $cf_cv_library_path_$3 ; then
2209 CF_VERBOSE(... testing $cf_cv_library_path_$3)
2210 CPPFLAGS="$cf_test_CPPFLAGS"
2211 LIBS="-l$3 $7 $cf_save_LIBS"
2212 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2213 AC_TRY_LINK([$1],[$2],[
2214 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2215 cf_cv_find_linkage_$3=yes
2216 cf_cv_library_file_$3="-l$3"
2218 CPPFLAGS="$cf_save_CPPFLAGS"
2219 LIBS="$cf_save_LIBS"
2220 LDFLAGS="$cf_save_LDFLAGS"
2224 CPPFLAGS="$cf_save_CPPFLAGS"
2225 LDFLAGS="$cf_save_LDFLAGS"
2229 cf_cv_find_linkage_$3=no
2234 LIBS="$cf_save_LIBS"
2236 if test "$cf_cv_find_linkage_$3" = yes ; then
2238 CF_ADD_INCDIR($cf_cv_header_path_$3)
2239 CF_ADD_LIBDIR($cf_cv_library_path_$3)
2243 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2246 dnl ---------------------------------------------------------------------------
2247 dnl CF_FIND_SUB_INCDIR version: 2 updated: 2015/04/17 21:13:04
2248 dnl ------------------
2249 dnl Find an include-directory with the given leaf-name. This is useful for
2250 dnl example with FreeBSD ports, which use this convention to distinguish
2251 dnl different versions of the same port.
2252 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2253 CF_SUBDIR_PATH(cf_search,$1,include)
2254 for cf_item in $cf_search
2258 CF_ADD_INCDIR($cf_item)
2263 dnl ---------------------------------------------------------------------------
2264 dnl CF_FIND_SUB_LIBDIR version: 2 updated: 2015/04/17 21:13:04
2265 dnl ------------------
2266 dnl Find a library-directory with the given leaf-name. This is useful for
2267 dnl example with FreeBSD ports, which use this convention to distinguish
2268 dnl different versions of the same port.
2269 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2270 CF_SUBDIR_PATH(cf_search,$1,lib)
2271 for cf_item in $cf_search
2275 CF_ADD_LIBDIR($cf_item)
2280 dnl ---------------------------------------------------------------------------
2281 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2282 dnl -----------------
2283 dnl make ADAFLAGS consistent with CFLAGS
2284 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2285 AC_MSG_CHECKING(optimization options for ADAFLAGS)
2293 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
2294 CF_ADD_ADAFLAGS($cf_O_flag)
2297 AC_MSG_RESULT($ADAFLAGS)
2299 dnl ---------------------------------------------------------------------------
2300 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
2302 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
2303 dnl "-Werror" flags can interfere with configure-checks. Those go into
2306 dnl $1 = variable name to repair
2307 define([CF_FIX_WARNINGS],[
2308 if ( test "$GCC" = yes || test "$GXX" = yes )
2312 CF_VERBOSE(repairing $1: [$]$1)
2314 for cf_temp_scan in [$]$1
2316 case "x$cf_temp_scan" in
2318 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
2321 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
2326 CF_VERBOSE(... fixed [$]$1)
2327 CF_VERBOSE(... extra $EXTRA_CFLAGS)
2331 AC_SUBST(EXTRA_CFLAGS)
2333 dnl ---------------------------------------------------------------------------
2334 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2336 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2337 dnl parameter. POSIX ignores the "b", which c89 specified. Some very old
2338 dnl systems do not accept it.
2339 AC_DEFUN([CF_FOPEN_BIN_R],[
2340 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2344 FILE *fp = fopen("conftest.tmp", "wb");
2348 for (p = 0; p < 256; ++p) {
2352 fp = fopen("conftest.tmp", "rb");
2354 for (p = 0; p < 256; ++p) {
2367 ${cf_cv_main_return:-return} (rc);
2370 [cf_cv_fopen_bin_r=yes],
2371 [cf_cv_fopen_bin_r=no],
2372 [cf_cv_fopen_bin_r=unknown])
2374 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2376 dnl ---------------------------------------------------------------------------
2377 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2379 dnl Forget that we saw the given tool.
2380 AC_DEFUN([CF_FORGET_TOOL],[
2381 unset ac_cv_prog_ac_ct_$1
2385 dnl ---------------------------------------------------------------------------
2386 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2388 dnl Test for dlsym() and related functions, as well as libdl.
2393 AC_DEFUN([CF_FUNC_DLSYM],[
2395 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2398 AC_CHECK_LIB(dl,dlsym,[
2400 cf_have_libdl=yes])])
2402 if test "$cf_have_dlsym" = yes ; then
2403 test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2405 AC_MSG_CHECKING(whether able to link to dl*() functions)
2406 AC_TRY_LINK([#include <dlfcn.h>],[
2408 if ((obj = dlopen("filename", 0)) != 0) {
2409 if (dlsym(obj, "symbolname") == 0) {
2413 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2414 AC_MSG_ERROR(Cannot link test program for libdl)])
2417 AC_MSG_ERROR(Cannot find dlsym function)
2420 dnl ---------------------------------------------------------------------------
2421 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2423 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
2424 dnl is found, add our own version of memmove to the list of objects.
2425 AC_DEFUN([CF_FUNC_MEMMOVE],
2427 AC_CHECK_FUNC(memmove,,[
2428 AC_CHECK_FUNC(bcopy,[
2429 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2432 static char data[] = "abcdefghijklmnopqrstuwwxyz";
2434 bcopy(data, temp, sizeof(data));
2435 bcopy(temp+10, temp, 15);
2436 bcopy(temp+5, temp+15, 10);
2437 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2440 [cf_cv_good_bcopy=yes],
2441 [cf_cv_good_bcopy=no],
2442 [cf_cv_good_bcopy=unknown])
2444 ],[cf_cv_good_bcopy=no])
2445 if test "$cf_cv_good_bcopy" = yes ; then
2446 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2448 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2451 dnl ---------------------------------------------------------------------------
2452 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2453 dnl -----------------
2454 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
2455 dnl AIX 4.x, provide a non-working version.
2456 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2457 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2463 #ifdef HAVE_SYS_TIME_H
2464 #include <sys/time.h>
2468 struct timespec ts1, ts2;
2471 ts1.tv_nsec = 750000000;
2475 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2476 ${cf_cv_main_return:-return}(code != 0);
2479 [cf_cv_func_nanosleep=yes],
2480 [cf_cv_func_nanosleep=no],
2481 [cf_cv_func_nanosleep=unknown])])
2483 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2485 dnl ---------------------------------------------------------------------------
2486 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
2488 dnl Check for openpty() function, along with <pty.h> header. It may need the
2489 dnl "util" library as well.
2490 AC_DEFUN([CF_FUNC_OPENPTY],
2492 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2493 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2494 cf_save_LIBS="$LIBS"
2495 test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
2496 for cf_header in pty.h libutil.h util.h
2499 #include <$cf_header>
2501 int x = openpty((int *)0, (int *)0, (char *)0,
2502 (struct termios *)0, (struct winsize *)0);
2504 cf_cv_func_openpty=$cf_header
2507 cf_cv_func_openpty=no
2510 LIBS="$cf_save_LIBS"
2513 dnl ---------------------------------------------------------------------------
2514 dnl CF_FUNC_POLL version: 9 updated: 2015/10/10 13:27:32
2516 dnl See if the poll function really works. Some platforms have poll(), but
2517 dnl it does not work for terminals or files.
2518 AC_DEFUN([CF_FUNC_POLL],[
2519 tty 2>&1 >/dev/null || { AC_CHECK_FUNCS(posix_openpt) }
2520 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2529 #include <sys/poll.h>
2532 struct pollfd myfds;
2535 /* check for Darwin bug with respect to "devices" */
2536 myfds.fd = open("/dev/null", 1); /* O_WRONLY */
2539 myfds.events = POLLIN;
2542 ret = poll(&myfds, 1, 100);
2544 if (ret < 0 || (myfds.revents & POLLNVAL)) {
2549 fd = open("/dev/tty", 2); /* O_RDWR */
2551 #ifdef HAVE_POSIX_OPENPT
2553 fd = posix_openpt(O_RDWR);
2558 /* also check with standard input */
2560 myfds.events = POLLIN;
2562 ret = poll(&myfds, 1, 100);
2567 ${cf_cv_main_return:-return}(ret < 0);
2569 [cf_cv_working_poll=yes],
2570 [cf_cv_working_poll=no],
2571 [cf_cv_working_poll=unknown])])
2572 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2574 dnl ---------------------------------------------------------------------------
2575 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2577 dnl Some old/broken variations define tcgetattr() only as a macro in
2579 AC_DEFUN([CF_FUNC_TERMIOS],[
2580 AC_REQUIRE([CF_STRUCT_TERMIOS])
2581 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2583 #include <sys/types.h>
2584 #ifdef HAVE_UNISTD_H
2587 #ifdef HAVE_TERMIOS_H
2588 #include <termios.h>
2589 #define TTY struct termios
2591 #ifdef HAVE_TERMIO_H
2593 #define TTY struct termio
2598 tcgetattr(1, &foo);],
2599 [cf_cv_have_tcgetattr=yes],
2600 [cf_cv_have_tcgetattr=no])])
2601 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2603 dnl ---------------------------------------------------------------------------
2604 dnl CF_FUNC_VSSCANF version: 6 updated: 2015/04/18 08:56:57
2606 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2607 dnl versions of C. It is in the GNU C library, and can often be simulated by
2608 dnl other functions.
2609 AC_DEFUN([CF_FUNC_VSSCANF],
2611 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2614 #include <stdio.h>],[
2616 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2619 #include <stdio.h>],[
2623 strbuf._flag = _IOREAD;
2624 strbuf._ptr = strbuf._base = (unsigned char *) str;
2625 strbuf._cnt = strlen(str);
2626 strbuf._file = _NFILE;
2627 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2630 #include <stdio.h>],[
2634 strbuf._flag = _IOREAD;
2635 strbuf._ptr = strbuf._base = (unsigned char *) str;
2636 strbuf._cnt = strlen(str);
2637 strbuf._file = _NFILE;
2638 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2639 cf_cv_func_vsscanf=no])])])])
2641 case $cf_cv_func_vsscanf in
2642 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2643 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2644 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2648 dnl ---------------------------------------------------------------------------
2649 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
2650 dnl -----------------
2651 dnl Test for availability of useful gcc __attribute__ directives to quiet
2652 dnl compiler warnings. Though useful, not all are supported -- and contrary
2653 dnl to documentation, unrecognized directives cause older compilers to barf.
2654 AC_DEFUN([CF_GCC_ATTRIBUTES],
2656 if ( test "$GCC" = yes || test "$GXX" = yes )
2658 cat > conftest.i <<EOF
2660 #define GCC_PRINTF 0
2665 #ifndef GCC_NORETURN
2666 #define GCC_NORETURN /* nothing */
2669 #define GCC_UNUSED /* nothing */
2672 if test "$GCC" = yes
2674 AC_CHECKING([for $CC __attribute__ directives])
2675 cat > conftest.$ac_ext <<EOF
2676 #line __oline__ "${as_me:-configure}"
2677 #include "confdefs.h"
2678 #include "conftest.h"
2679 #include "conftest.i"
2681 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2683 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2686 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
2688 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
2690 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2691 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
2692 extern void foo(void) GCC_NORETURN;
2693 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2695 cf_printf_attribute=no
2696 cf_scanf_attribute=no
2697 for cf_attribute in scanf printf unused noreturn
2699 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2700 cf_directive="__attribute__(($cf_attribute))"
2701 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2703 case $cf_attribute in
2705 cf_printf_attribute=yes
2706 cat >conftest.h <<EOF
2707 #define GCC_$cf_ATTRIBUTE 1
2711 cf_scanf_attribute=yes
2712 cat >conftest.h <<EOF
2713 #define GCC_$cf_ATTRIBUTE 1
2717 cat >conftest.h <<EOF
2718 #define GCC_$cf_ATTRIBUTE $cf_directive
2723 if AC_TRY_EVAL(ac_compile); then
2724 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2725 cat conftest.h >>confdefs.h
2726 case $cf_attribute in
2728 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2731 cf_value='/* nothing */'
2732 if test "$cf_printf_attribute" != no ; then
2733 cf_value='__attribute__((format(printf,fmt,var)))'
2734 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2736 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2739 cf_value='/* nothing */'
2740 if test "$cf_scanf_attribute" != no ; then
2741 cf_value='__attribute__((format(scanf,fmt,var)))'
2742 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2744 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2747 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2753 fgrep define conftest.i >>confdefs.h
2758 dnl ---------------------------------------------------------------------------
2759 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2761 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2762 dnl compatible), attempt to determine if icc/clang is actually used.
2763 AC_DEFUN([CF_GCC_VERSION],[
2764 AC_REQUIRE([AC_PROG_CC])
2766 if test "$GCC" = yes ; then
2767 AC_MSG_CHECKING(version of $CC)
2768 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.]].*//'`"
2769 test -z "$GCC_VERSION" && GCC_VERSION=unknown
2770 AC_MSG_RESULT($GCC_VERSION)
2772 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2773 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2775 dnl ---------------------------------------------------------------------------
2776 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
2778 dnl Check if the compiler supports useful warning options. There's a few that
2779 dnl we don't use, simply because they're too noisy:
2781 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2782 dnl -Winline (usually not worthwhile)
2783 dnl -Wredundant-decls (system headers make this too noisy)
2784 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
2785 dnl -Wwrite-strings (too noisy, but should review occasionally). This
2786 dnl is enabled for ncurses using "--enable-const".
2790 dnl $1 is an optional list of gcc warning flags that a particular
2791 dnl application might want to use, e.g., "no-unused" for
2794 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2796 AC_DEFUN([CF_GCC_WARNINGS],
2798 AC_REQUIRE([CF_GCC_VERSION])
2799 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
2800 cat > conftest.$ac_ext <<EOF
2801 #line __oline__ "${as_me:-configure}"
2802 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2804 if test "$INTEL_COMPILER" = yes
2806 # The "-wdXXX" options suppress warnings:
2807 # remark #1419: external declaration in primary source file
2808 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2809 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2810 # remark #193: zero used for undefined preprocessing identifier
2811 # remark #593: variable "curs_sb_left_arrow" was set but never used
2812 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2813 # remark #869: parameter "tw" was never referenced
2814 # remark #981: operands are evaluated in unspecified order
2815 # warning #279: controlling expression is constant
2817 AC_CHECKING([for $CC warning options])
2818 cf_save_CFLAGS="$CFLAGS"
2819 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
2831 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2832 if AC_TRY_EVAL(ac_compile); then
2833 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2834 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2837 CFLAGS="$cf_save_CFLAGS"
2838 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
2840 AC_CHECKING([for $CC warning options])
2841 cf_save_CFLAGS="$CFLAGS"
2843 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2844 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2845 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2846 for cf_opt in W Wall \
2847 Wbad-function-cast \
2850 Wdeclaration-after-statement \
2853 Wmissing-declarations \
2854 Wmissing-prototypes \
2858 Wstrict-prototypes \
2859 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
2861 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2862 if AC_TRY_EVAL(ac_compile); then
2863 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2866 case $GCC_VERSION in
2868 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2873 case $GCC_VERSION in
2875 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2880 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2883 CFLAGS="$cf_save_CFLAGS"
2887 AC_SUBST(EXTRA_CFLAGS)
2889 dnl ---------------------------------------------------------------------------
2890 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2891 dnl ----------------
2892 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2893 dnl unistd.h or (nonstandard) in getopt.h
2894 AC_DEFUN([CF_GETOPT_HEADER],
2896 AC_HAVE_HEADERS(unistd.h getopt.h)
2897 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2898 cf_cv_getopt_header=none
2899 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2902 #include <$cf_header>],
2903 [int x = optind; char *y = optarg],
2904 [cf_cv_getopt_header=$cf_header
2908 if test $cf_cv_getopt_header != none ; then
2909 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2911 if test $cf_cv_getopt_header = getopt.h ; then
2912 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2915 dnl ---------------------------------------------------------------------------
2916 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2917 dnl -----------------
2918 AC_DEFUN([CF_GNATPREP_OPT_T],[
2919 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2920 cf_cv_gnatprep_opt_t=no
2921 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2923 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2924 AC_SUBST(GNATPREP_OPTS)
2926 dnl ---------------------------------------------------------------------------
2927 dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
2928 dnl ----------------
2929 AC_DEFUN([CF_GNAT_GENERICS],
2931 AC_REQUIRE([CF_GNAT_VERSION])
2933 AC_MSG_CHECKING(if GNAT supports generics)
2934 case $cf_cv_gnat_version in
2935 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
2936 cf_gnat_generics=yes
2942 AC_MSG_RESULT($cf_gnat_generics)
2944 if test "$cf_gnat_generics" = yes
2946 cf_compile_generics=generics
2947 cf_generic_objects="\${GENOBJS}"
2949 cf_compile_generics=
2953 AC_SUBST(cf_compile_generics)
2954 AC_SUBST(cf_generic_objects)
2956 dnl ---------------------------------------------------------------------------
2957 dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54
2958 dnl ----------------
2959 dnl GNAT projects are configured with ".gpr" project files.
2960 dnl GNAT libraries are a further development, using the project feature.
2961 AC_DEFUN([CF_GNAT_PROJECTS],
2963 AC_REQUIRE([CF_GNAT_VERSION])
2964 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2966 cf_gnat_libraries=no
2969 if test "$enable_gnat_projects" != no ; then
2970 AC_MSG_CHECKING(if GNAT supports project files)
2971 case $cf_cv_gnat_version in
2975 case $cf_cv_system_name in
2979 rm -rf conftest* *~conftest*
2980 if mkdir conftest.src conftest.bin conftest.lib
2983 rm -rf conftest* *~conftest*
2984 cat >>library.gpr <<CF_EOF
2986 Kind := External ("LIB_KIND");
2987 for Library_Name use "ConfTest";
2988 for Object_Dir use ".";
2989 for Library_ALI_Dir use External("LIBRARY_DIR");
2990 for Library_Version use External ("SONAME");
2991 for Library_Kind use Kind;
2992 for Library_Dir use External("BUILD_DIR");
2993 Source_Dir := External ("SOURCE_DIR");
2994 for Source_Dirs use (Source_Dir);
2997 cat >>confpackage.ads <<CF_EOF
2998 package ConfPackage is
3002 cat >>confpackage.adb <<CF_EOF
3004 package body ConfPackage is
3005 procedure conftest is
3007 Text_IO.Put ("Hello World");
3012 if ( $cf_ada_make $ADAFLAGS \
3014 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
3015 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
3016 -XSOURCE_DIR=`pwd` \
3017 -XSONAME=libConfTest.so.1 \
3018 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
3019 cf_gnat_projects=yes
3023 if test -f conftest.lib/confpackage.ali
3025 cf_gnat_libraries=yes
3027 rm -rf conftest* *~conftest*
3032 AC_MSG_RESULT($cf_gnat_projects)
3033 fi # enable_gnat_projects
3035 if test $cf_gnat_projects = yes
3037 AC_MSG_CHECKING(if GNAT supports libraries)
3038 AC_MSG_RESULT($cf_gnat_libraries)
3041 if test "$cf_gnat_projects" = yes
3043 USE_OLD_MAKERULES="#"
3044 USE_GNAT_PROJECTS=""
3046 USE_OLD_MAKERULES=""
3047 USE_GNAT_PROJECTS="#"
3050 if test "$cf_gnat_libraries" = yes
3052 USE_GNAT_LIBRARIES=""
3054 USE_GNAT_LIBRARIES="#"
3057 AC_SUBST(USE_OLD_MAKERULES)
3058 AC_SUBST(USE_GNAT_PROJECTS)
3059 AC_SUBST(USE_GNAT_LIBRARIES)
3061 dnl ---------------------------------------------------------------------------
3062 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
3064 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
3065 dnl is noted that gnat may compile a tasking unit even for configurations which
3066 dnl fail at runtime.
3067 AC_DEFUN([CF_GNAT_SIGINT],[
3068 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3069 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3073 pragma Warnings (Off); -- the next pragma exists since 3.11p
3074 pragma Unreserve_All_Interrupts;
3075 pragma Warnings (On);
3077 protected Process is
3079 function Continue return Boolean;
3080 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3082 Done : Boolean := False;
3086 [package body ConfTest is
3087 protected body Process is
3092 function Continue return Boolean is
3098 [cf_cv_gnat_sigint=yes],
3099 [cf_cv_gnat_sigint=no])])
3101 if test $cf_cv_gnat_sigint = yes ; then
3106 AC_SUBST(USE_GNAT_SIGINT)
3108 dnl ---------------------------------------------------------------------------
3109 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
3110 dnl ----------------
3111 dnl Verify that a test program compiles/links with GNAT.
3112 dnl $cf_ada_make is set to the program that compiles/links
3113 dnl $ADAFLAGS may be set to the GNAT flags.
3115 dnl $1 is the text of the spec
3116 dnl $2 is the text of the body
3117 dnl $3 is the shell command to execute if successful
3118 dnl $4 is the shell command to execute if not successful
3119 AC_DEFUN([CF_GNAT_TRY_LINK],
3121 rm -rf conftest* *~conftest*
3122 cat >>conftest.ads <<CF_EOF
3125 cat >>conftest.adb <<CF_EOF
3128 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3129 ifelse($3,, :,[ $3])
3133 rm -rf conftest* *~conftest*
3135 dnl ---------------------------------------------------------------------------
3136 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
3138 dnl Verify that a test program compiles and runs with GNAT
3139 dnl $cf_ada_make is set to the program that compiles/links
3140 dnl $ADAFLAGS may be set to the GNAT flags.
3142 dnl $1 is the text of the spec
3143 dnl $2 is the text of the body
3144 dnl $3 is the shell command to execute if successful
3145 dnl $4 is the shell command to execute if not successful
3146 AC_DEFUN([CF_GNAT_TRY_RUN],
3148 rm -rf conftest* *~conftest*
3149 cat >>conftest.ads <<CF_EOF
3152 cat >>conftest.adb <<CF_EOF
3155 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3156 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3157 ifelse($3,, :,[ $3])
3164 rm -rf conftest* *~conftest*
3166 dnl ---------------------------------------------------------------------------
3167 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3169 dnl $1 = cache variable to update
3170 dnl $2 = program name
3171 dnl Verify version of GNAT or related tool
3172 AC_DEFUN([CF_GNAT_VERSION],
3174 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3175 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3176 grep '[[0-9]].[[0-9]][[0-9]]*' |\
3177 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3179 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3180 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3182 dnl ---------------------------------------------------------------------------
3183 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3185 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3186 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
3187 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3188 dnl since it is interwoven with GNU extensions.
3190 dnl Well, yes we could work around it...
3193 dnl $1 is the nominal value for _XOPEN_SOURCE
3194 AC_DEFUN([CF_GNU_SOURCE],
3196 cf_gnu_xopen_source=ifelse($1,,500,$1)
3198 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3199 AC_TRY_COMPILE([#include <sys/types.h>],[
3200 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3202 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3205 # error not GNU C library
3207 [cf_cv_gnu_library=yes],
3208 [cf_cv_gnu_library=no])
3211 if test x$cf_cv_gnu_library = xyes; then
3213 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3214 # was changed to help a little. newlib incorporated the change about 4
3216 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3218 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3219 AC_TRY_COMPILE([#include <sys/types.h>],[
3220 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3222 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3225 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3227 [cf_cv_gnu_library_219=yes],
3228 [cf_cv_gnu_library_219=no])
3232 if test "x$cf_cv_gnu_library_219" = xyes; then
3234 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3235 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3238 #include <sys/types.h>
3240 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3243 # error GNU C library is too old
3245 [cf_cv_gnu_dftsrc_219=yes],
3246 [cf_cv_gnu_dftsrc_219=no])
3248 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3250 cf_cv_gnu_dftsrc_219=maybe
3253 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3255 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3256 AC_TRY_COMPILE([#include <sys/types.h>],[
3257 #ifndef _XOPEN_SOURCE
3258 #error expected _XOPEN_SOURCE to be defined
3260 [cf_cv_gnu_source=no],
3261 [cf_save="$CPPFLAGS"
3262 CF_ADD_CFLAGS(-D_GNU_SOURCE)
3263 AC_TRY_COMPILE([#include <sys/types.h>],[
3264 #ifdef _XOPEN_SOURCE
3265 #error expected _XOPEN_SOURCE to be undefined
3267 [cf_cv_gnu_source=no],
3268 [cf_cv_gnu_source=yes])
3273 if test "$cf_cv_gnu_source" = yes
3275 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3276 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3277 AC_TRY_COMPILE([#include <sys/types.h>],[
3278 #ifdef _DEFAULT_SOURCE
3279 #error expected _DEFAULT_SOURCE to be undefined
3281 [cf_cv_default_source=no],
3282 [cf_cv_default_source=yes])
3284 if test "$cf_cv_default_source" = yes
3286 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3293 dnl ---------------------------------------------------------------------------
3294 dnl CF_GPP_LIBRARY version: 12 updated: 2015/04/17 21:13:04
3296 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3297 dnl problem :-). If we have the compiler but no library, we'll be able to
3298 dnl configure, but won't be able to build the c++ demo program.
3299 AC_DEFUN([CF_GPP_LIBRARY],
3301 cf_cxx_library=unknown
3302 case $cf_cv_system_name in
3310 if test "$GXX" = yes; then
3311 AC_MSG_CHECKING([for lib$cf_gpp_libname])
3313 CF_ADD_LIB($cf_gpp_libname)
3315 #include <$cf_gpp_libname/builtin.h>
3317 [two_arg_error_handler_t foo2 = lib_error_handler],
3319 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3320 if test "$cf_gpp_libname" = cpp ; then
3321 AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3323 AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3326 #include <builtin.h>
3328 [two_arg_error_handler_t foo2 = lib_error_handler],
3330 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3331 AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3332 [cf_cxx_library=no])])
3334 AC_MSG_RESULT($cf_cxx_library)
3337 dnl ---------------------------------------------------------------------------
3338 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3340 dnl Check for version of g++
3341 AC_DEFUN([CF_GXX_VERSION],[
3342 AC_REQUIRE([AC_PROG_CPP])
3344 if test "$GXX" = yes; then
3345 AC_MSG_CHECKING(version of ${CXX:-g++})
3346 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3347 if test -z "$GXX_VERSION"
3352 AC_MSG_RESULT($GXX_VERSION)
3355 dnl ---------------------------------------------------------------------------
3356 dnl CF_GXX_WARNINGS version: 9 updated: 2015/04/17 21:13:04
3358 dnl Check if the compiler supports useful warning options.
3360 dnl Most of gcc's options apply to g++, except:
3361 dnl -Wbad-function-cast
3362 dnl -Wmissing-declarations
3363 dnl -Wnested-externs
3365 dnl Omit a few (for now):
3369 dnl $1 is an optional list of g++ warning flags that a particular
3370 dnl application might want to use, e.g., "no-unused" for
3373 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
3375 AC_DEFUN([CF_GXX_WARNINGS],
3378 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3379 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3381 AC_REQUIRE([CF_GXX_VERSION])
3386 cat > conftest.$ac_ext <<EOF
3387 #line __oline__ "configure"
3388 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3391 if test "$INTEL_CPLUSPLUS" = yes
3393 # The "-wdXXX" options suppress warnings:
3394 # remark #1419: external declaration in primary source file
3395 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3396 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3397 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3398 # remark #193: zero used for undefined preprocessing identifier
3399 # remark #593: variable "curs_sb_left_arrow" was set but never used
3400 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3401 # remark #869: parameter "tw" was never referenced
3402 # remark #981: operands are evaluated in unspecified order
3403 # warning #269: invalid format string conversion
3405 AC_CHECKING([for $CC warning options])
3406 cf_save_CXXFLAGS="$CXXFLAGS"
3407 EXTRA_CXXFLAGS="-Wall"
3420 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3421 if AC_TRY_EVAL(ac_compile); then
3422 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3423 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3426 CXXFLAGS="$cf_save_CXXFLAGS"
3428 elif test "$GXX" = yes
3430 AC_CHECKING([for $CXX warning options])
3431 cf_save_CXXFLAGS="$CXXFLAGS"
3432 EXTRA_CXXFLAGS="-W -Wall"
3433 cf_gxx_extra_warnings=""
3434 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3435 case "$GCC_VERSION" in
3439 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3446 Wignored-qualifiers \
3448 Woverloaded-virtual \
3456 Wundef $cf_gxx_extra_warnings $1
3458 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3459 if AC_TRY_EVAL(ac_compile); then
3460 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3461 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3463 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3466 CXXFLAGS="$cf_save_CXXFLAGS"
3471 AC_SUBST(EXTRA_CXXFLAGS)
3473 dnl ---------------------------------------------------------------------------
3474 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3476 dnl Look for an instance of the Berkeley hashed database.
3478 dnl $1 = optional parameter, to specify install-prefix for the database.
3479 AC_DEFUN([CF_HASHED_DB],
3486 if test -d "$1" ; then
3487 CF_ADD_INCDIR($1/include)
3488 CF_ADD_LIBDIR($1/lib)
3492 AC_MSG_WARN(no such directory $1)
3495 CF_FIND_SUB_INCDIR($1)
3496 CF_FIND_SUB_LIBDIR($1)
3502 AC_CHECK_HEADER(db.h,[
3503 CF_HASHED_DB_VERSION
3504 if test "$cf_cv_hashed_db_version" = unknown ; then
3505 AC_MSG_ERROR(Cannot determine version of db)
3508 if test "$cf_cv_hashed_db_libs" = unknown ; then
3509 AC_MSG_ERROR(Cannot determine library for db)
3510 elif test "$cf_cv_hashed_db_libs" != default ; then
3511 CF_ADD_LIB($cf_cv_hashed_db_libs)
3515 AC_MSG_ERROR(Cannot find db.h)
3518 dnl ---------------------------------------------------------------------------
3519 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
3520 dnl -----------------
3521 dnl Given that we have the header and version for hashed database, find the
3522 dnl library information.
3523 AC_DEFUN([CF_HASHED_DB_LIBS],
3525 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3526 cf_cv_hashed_db_libs=unknown
3527 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3529 cf_save_libs="$LIBS"
3530 if test -n "$cf_db_libs"; then
3531 CF_ADD_LIB($cf_db_libs)
3533 CF_MSG_LOG(checking for library "$cf_db_libs")
3535 $ac_includes_default
3538 char *path = "/tmp/foo";
3539 #ifdef DB_VERSION_MAJOR
3540 #if DB_VERSION_MAJOR >= 4
3542 db_create(&result, NULL, 0);
3543 result->open(result,
3550 #elif DB_VERSION_MAJOR >= 3
3552 db_create(&result, NULL, 0);
3553 result->open(result,
3559 #elif DB_VERSION_MAJOR >= 2
3568 #endif /* DB_VERSION_MAJOR */
3570 DB *result = dbopen(path,
3576 ${cf_cv_main_return:-return}(result != 0)
3578 if test -n "$cf_db_libs" ; then
3579 cf_cv_hashed_db_libs=$cf_db_libs
3581 cf_cv_hashed_db_libs=default
3583 LIBS="$cf_save_libs"
3586 LIBS="$cf_save_libs"
3590 dnl ---------------------------------------------------------------------------
3591 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3592 dnl --------------------
3593 dnl Given that we have the header file for hashed database, find the version
3595 AC_DEFUN([CF_HASHED_DB_VERSION],
3597 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3598 cf_cv_hashed_db_version=unknown
3600 for cf_db_version in 1 2 3 4 5 6
3602 CF_MSG_LOG(checking for db version $cf_db_version)
3604 $ac_includes_default
3607 #ifdef DB_VERSION_MAJOR
3608 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3609 #if $cf_db_version == DB_VERSION_MAJOR
3615 #if $cf_db_version == 1
3616 /* ok: assuming this is DB 1.8.5 */
3622 cf_cv_hashed_db_version=$cf_db_version
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
3631 dnl Construct a search-list of directories for a nonstandard header-file
3634 dnl $1 = the variable to return as result
3635 dnl $2 = the package name
3636 AC_DEFUN([CF_HEADER_PATH],
3640 # collect the current set of include-directories from compiler flags
3641 cf_header_path_list=""
3642 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3643 for cf_header_path in $CPPFLAGS $CFLAGS
3645 case $cf_header_path in
3647 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3648 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3649 cf_header_path_list="$cf_header_path_list [$]$1"
3655 # add the variations for the package we are looking for
3656 CF_SUBDIR_PATH($1,$2,include)
3658 test "$includedir" != NONE && \
3659 test "$includedir" != "/usr/include" && \
3660 test -d "$includedir" && {
3661 test -d $includedir && $1="[$]$1 $includedir"
3662 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
3665 test "$oldincludedir" != NONE && \
3666 test "$oldincludedir" != "/usr/include" && \
3667 test -d "$oldincludedir" && {
3668 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
3669 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
3672 $1="[$]$1 $cf_header_path_list"
3674 dnl ---------------------------------------------------------------------------
3675 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3677 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3678 AC_DEFUN([CF_HELP_MESSAGE],
3679 [CF_ACVERSION_CHECK(2.53,[],[
3680 AC_DIVERT_HELP($1)])dnl
3682 dnl ---------------------------------------------------------------------------
3683 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3685 dnl Construct the list of include-options according to whether we're building
3686 dnl in the source directory or using '--srcdir=DIR' option.
3687 AC_DEFUN([CF_INCLUDE_DIRS],
3689 if test "$srcdir" != "."; then
3690 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3692 CPPFLAGS="-I../include $CPPFLAGS"
3693 if test "$srcdir" != "."; then
3694 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
3696 CPPFLAGS="-I. $CPPFLAGS"
3699 dnl ---------------------------------------------------------------------------
3700 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
3702 dnl prompt for/fill-in useful install-program options
3703 AC_DEFUN([CF_INSTALL_OPTS],
3709 dnl ---------------------------------------------------------------------------
3710 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
3711 dnl ----------------
3712 dnl Almost all "install" programs default to the current user's ownership.
3713 dnl Almost - MINIX is an exception.
3714 AC_DEFUN([CF_INSTALL_OPT_O],
3716 AC_MSG_CHECKING(if install needs to be told about ownership)
3717 case `$ac_config_guess` in
3726 AC_MSG_RESULT($with_install_o)
3727 if test "x$with_install_o" = xyes
3729 INSTALL_OPT_O=`id root|sed -e 's/uid=[[0-9]]*(/ -o /' -e 's/gid=[[0-9]]*(/ -g /' -e 's/ [[^=[:space:]]][[^=[:space:]]]*=.*/ /' -e 's/)//g'`
3734 AC_SUBST(INSTALL_OPT_O)
3736 dnl ---------------------------------------------------------------------------
3737 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
3738 dnl ----------------
3739 dnl Some install-programs accept a "-p" option to preserve file modification
3740 dnl timestamps. That can be useful as an install option, as well as a way to
3741 dnl avoid the need for ranlib after copying a static archive.
3742 AC_DEFUN([CF_INSTALL_OPT_P],
3744 : ${INSTALL:=install}
3745 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
3750 if $INSTALL -p conftest.in conftest.out 2>/dev/null
3752 if test -f conftest.out/conftest.in
3754 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3755 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3756 if test -s conftest.err
3771 dnl ---------------------------------------------------------------------------
3772 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
3773 dnl ----------------
3774 dnl By default, we should strip executables which are installed, but leave the
3775 dnl ability to suppress that for unit-testing.
3776 AC_DEFUN([CF_INSTALL_OPT_S],
3778 AC_MSG_CHECKING(if you want to install stripped executables)
3779 CF_ARG_DISABLE(stripping,
3780 [ --disable-stripping do not strip (debug info) installed executables],
3781 [with_stripping=no],
3782 [with_stripping=yes])
3783 AC_MSG_RESULT($with_stripping)
3785 if test "$with_stripping" = yes
3791 AC_SUBST(INSTALL_OPT_S)
3793 dnl ---------------------------------------------------------------------------
3794 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
3795 dnl -----------------
3796 dnl Check if the given compiler is really the Intel compiler for Linux. It
3797 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
3798 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
3800 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
3801 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
3802 dnl the wrappers for gcc and g++ warnings.
3804 dnl $1 = GCC (default) or GXX
3805 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
3806 dnl $3 = CFLAGS (default) or CXXFLAGS
3807 AC_DEFUN([CF_INTEL_COMPILER],[
3808 AC_REQUIRE([AC_CANONICAL_HOST])
3809 ifelse([$2],,INTEL_COMPILER,[$2])=no
3811 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
3814 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
3815 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
3816 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
3818 #ifdef __INTEL_COMPILER
3822 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
3823 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
3825 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
3826 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
3831 dnl ---------------------------------------------------------------------------
3832 dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13
3834 dnl Check if we have either a function or macro for 'isascii()'.
3835 AC_DEFUN([CF_ISASCII],
3837 AC_MSG_CHECKING(for isascii)
3838 AC_CACHE_VAL(cf_cv_have_isascii,[
3839 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')],
3840 [cf_cv_have_isascii=yes],
3841 [cf_cv_have_isascii=no])
3843 AC_MSG_RESULT($cf_cv_have_isascii)
3844 test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()])
3846 dnl ---------------------------------------------------------------------------
3847 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
3849 dnl Add checks for large file support.
3850 AC_DEFUN([CF_LARGEFILE],[
3851 ifdef([AC_FUNC_FSEEKO],[
3853 if test "$enable_largefile" != no ; then
3856 # Normally we would collect these definitions in the config.h,
3857 # but (like _XOPEN_SOURCE), some environments rely on having these
3858 # defined before any of the system headers are included. Another
3859 # case comes up with C++, e.g., on AIX the compiler compiles the
3860 # header files by themselves before looking at the body files it is
3861 # told to compile. For ncurses, those header files do not include
3863 if test "$ac_cv_sys_large_files" != no
3865 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
3867 if test "$ac_cv_sys_largefile_source" != no
3869 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
3871 if test "$ac_cv_sys_file_offset_bits" != no
3873 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
3876 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
3878 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
3879 #include <sys/types.h>
3882 /* if transitional largefile support is setup, this is true */
3883 extern struct dirent64 * readdir(DIR *);
3884 struct dirent64 *x = readdir((DIR *)0);
3885 struct dirent *y = readdir((DIR *)0);
3889 [cf_cv_struct_dirent64=yes],
3890 [cf_cv_struct_dirent64=no])
3892 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
3896 dnl ---------------------------------------------------------------------------
3897 dnl CF_LDFLAGS_STATIC version: 12 updated: 2015/04/18 08:56:57
3898 dnl -----------------
3899 dnl Check for compiler/linker flags used to temporarily force usage of static
3900 dnl libraries. This depends on the compiler and platform. Use this to help
3901 dnl ensure that the linker picks up a given library based on its position in
3902 dnl the list of linker options and libraries.
3903 AC_DEFUN([CF_LDFLAGS_STATIC],[
3905 if test "$GCC" = yes ; then
3906 case $cf_cv_system_name in
3907 (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*)
3911 (*) # normally, except when broken
3912 LDFLAGS_STATIC=-static
3913 LDFLAGS_SHARED=-dynamic
3917 case $cf_cv_system_name in
3918 (aix[[4-7]]*) # from ld manpage
3919 LDFLAGS_STATIC=-bstatic
3920 LDFLAGS_SHARED=-bdynamic
3922 (hpux*) # from ld manpage for hpux10.20, hpux11.11
3923 # We could also use just "archive" and "shared".
3924 LDFLAGS_STATIC=-Wl,-a,archive_shared
3925 LDFLAGS_SHARED=-Wl,-a,shared_archive
3927 (irix*) # from ld manpage IRIX64
3928 LDFLAGS_STATIC=-Bstatic
3929 LDFLAGS_SHARED=-Bdynamic
3931 (osf[[45]]*) # from ld manpage osf4.0d, osf5.1
3932 # alternative "-oldstyle_liblookup" (not in cc manpage)
3933 LDFLAGS_STATIC=-noso
3934 LDFLAGS_SHARED=-so_archive
3937 LDFLAGS_STATIC=-Bstatic
3938 LDFLAGS_SHARED=-Bdynamic
3943 if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED"
3945 AC_MSG_CHECKING(if linker supports switching between static/dynamic)
3948 cat >conftest.$ac_ext <<EOF
3949 #line __oline__ "configure"
3951 int cf_ldflags_static(FILE *fp) { return fflush(fp); }
3953 if AC_TRY_EVAL(ac_compile) ; then
3954 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null
3955 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null
3959 cf_save_LIBS="$LIBS"
3961 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS"
3963 #line __oline__ "configure"
3965 int cf_ldflags_static(FILE *fp);
3967 return cf_ldflags_static(stdin);
3969 # some linkers simply ignore the -dynamic
3970 case x`file conftest$ac_exeext 2>/dev/null` in
3972 cf_ldflags_static=no
3975 cf_ldflags_static=yes
3978 ],[cf_ldflags_static=no])
3981 LIBS="$cf_save_LIBS"
3983 AC_MSG_RESULT($cf_ldflags_static)
3985 if test $cf_ldflags_static != yes
3995 AC_SUBST(LDFLAGS_STATIC)
3996 AC_SUBST(LDFLAGS_SHARED)
3998 dnl ---------------------------------------------------------------------------
3999 dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
4001 dnl For the given system and compiler, find the compiler flags to pass to the
4002 dnl loader to use the "rpath" feature.
4003 AC_DEFUN([CF_LD_RPATH_OPT],
4005 AC_REQUIRE([CF_CHECK_CACHE])
4008 if test "x$cf_cv_enable_rpath" != xno
4010 AC_MSG_CHECKING(for an rpath option)
4011 case $cf_cv_system_name in
4013 if test "$GCC" = yes; then
4014 LD_RPATH_OPT="-Wl,-rpath,"
4016 LD_RPATH_OPT="-rpath "
4019 (linux*|gnu*|k*bsd*-gnu|freebsd*)
4020 LD_RPATH_OPT="-Wl,-rpath,"
4022 (openbsd[[2-9]].*|mirbsd*)
4023 LD_RPATH_OPT="-Wl,-rpath,"
4026 LD_RPATH_OPT="-rpath "
4029 LD_RPATH_OPT="-Wl,-rpath,"
4032 LD_RPATH_OPT="-rpath "
4040 AC_MSG_RESULT($LD_RPATH_OPT)
4042 case "x$LD_RPATH_OPT" in
4044 AC_MSG_CHECKING(if we need a space after rpath option)
4045 cf_save_LIBS="$LIBS"
4046 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
4047 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
4048 LIBS="$cf_save_LIBS"
4049 AC_MSG_RESULT($cf_rpath_space)
4050 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
4055 dnl ---------------------------------------------------------------------------
4056 dnl CF_LD_SEARCHPATH version: 2 updated: 2019/09/26 20:34:14
4057 dnl ----------------
4058 dnl Try to obtain the linker's search-path, for use in scripts.
4060 dnl Ignore LD_LIBRARY_PATH, etc.
4061 AC_DEFUN([CF_LD_SEARCHPATH],[
4062 AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[
4064 if test "$cross_compiling" != yes ; then
4066 # GNU binutils' ld does not involve permissions which may stop ldconfig.
4067 cf_pathlist=`ld --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u`
4069 # The -NX options tell newer versions of Linux ldconfig to not attempt to
4070 # update the cache, which makes it run faster.
4071 test -z "$cf_pathlist" && \
4072 cf_pathlist=`ldconfig -NX -v 2>/dev/null | sed -e '/^[[ ]]/d' -e 's/:$//' | sort -u`
4074 test -z "$cf_pathlist" &&
4075 cf_pathlist=`ldconfig -v 2>/dev/null | sed -n -e '/^[[ ]]/d' -e 's/:$//p' | sort -u`
4077 # This works with OpenBSD 6.5, which lists only filenames
4078 test -z "$cf_pathlist" &&
4079 cf_pathlist=`ldconfig -v 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u`
4081 if test -z "$cf_pathlist"
4083 # dyld default path with MacOS
4084 if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin
4086 # do this to bypass check
4087 cf_cv_ld_searchpath='$HOME/lib'
4088 cf_pathlist="/usr/local/lib /lib /usr/lib"
4092 if test -z "$cf_pathlist"
4094 # Solaris is hardcoded
4095 if test -d /opt/SUNWspro/lib
4097 cf_pathlist="/opt/SUNWspro/lib /usr/ccs/lib /usr/lib"
4098 elif test -d /usr/ccs/lib
4100 cf_pathlist="/usr/ccs/lib /usr/lib"
4106 # If nothing else, assume it is conventional
4107 test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib"
4109 # Finally, check that this is only directories
4110 for cf_path in [$]0 $cf_pathlist
4112 if test -d "$cf_path"; then
4113 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} "
4114 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}"
4118 # Ensure that it is nonempty
4119 test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib
4122 LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'`
4123 AC_SUBST(LD_SEARCHPATH)
4125 dnl ---------------------------------------------------------------------------
4126 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
4128 dnl Construct a search-list of directories for a nonstandard library-file
4131 dnl $1 = the variable to return as result
4132 dnl $2 = the package name
4133 AC_DEFUN([CF_LIBRARY_PATH],
4136 cf_library_path_list=""
4137 if test -n "${LDFLAGS}${LIBS}" ; then
4138 for cf_library_path in $LDFLAGS $LIBS
4140 case $cf_library_path in
4142 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
4143 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
4144 cf_library_path_list="$cf_library_path_list [$]$1"
4150 CF_SUBDIR_PATH($1,$2,lib)
4152 $1="$cf_library_path_list [$]$1"
4154 dnl ---------------------------------------------------------------------------
4155 dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
4156 dnl ------------------
4157 AC_DEFUN([CF_LIBTOOL_VERSION],[
4158 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
4160 cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'`
4162 cf_cv_libtool_version=
4164 test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version
4166 dnl ---------------------------------------------------------------------------
4167 dnl CF_LIB_PREFIX version: 13 updated: 2020/04/04 10:11:47
4169 dnl Compute the library-prefix for the given host system
4170 dnl $1 = variable to set
4171 define([CF_LIB_PREFIX],
4173 case $cf_cv_system_name in
4175 if test "$DFT_LWR_MODEL" = libtool; then
4184 (*) LIB_PREFIX='lib'
4187 ifelse($1,,,[$1=$LIB_PREFIX])
4188 AC_SUBST(LIB_PREFIX)
4190 dnl ---------------------------------------------------------------------------
4191 dnl CF_LIB_RULES version: 90 updated: 2020/04/04 10:11:47
4193 dnl Append definitions and rules for the given models to the subdirectory
4194 dnl Makefiles, and the recursion rule for the top-level Makefile. If the
4195 dnl subdirectory is a library-source directory, modify the Libs_To_Make list in
4196 dnl the corresponding makefile to list the models that we'll generate.
4198 dnl For shared libraries, make a list of symbolic links to construct when
4199 dnl generating each library. The convention used for Linux is the simplest
4202 dnl lib<name>.so.<major> ->
4203 dnl lib<name>.so.<maj>.<minor>
4205 dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable.
4206 AC_DEFUN([CF_LIB_RULES],
4208 cf_prefix=$LIB_PREFIX
4209 AC_REQUIRE([CF_SUBST_NCURSES_VERSION])
4211 case $cf_cv_shlib_version in
4212 (cygdll|msysdll|mingw|msvcdll)
4213 TINFO_NAME=$TINFO_ARG_SUFFIX
4218 if test -n "$TINFO_SUFFIX" ; then
4219 case $TINFO_SUFFIX in
4221 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}"
4222 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw'$EXTRA_SUFFIX'//'`
4225 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}"
4226 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t'$EXTRA_SUFFIX'//'`
4229 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}"
4230 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w'$EXTRA_SUFFIX'//'`
4235 for cf_dir in $SRC_SUBDIRS
4237 if test ! -d $srcdir/$cf_dir ; then
4239 elif test -f $srcdir/$cf_dir/modules; then
4244 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5"
4246 cf_awk_program="$cf_awk_program\
4247 /deprecated in ABI${cf_cv_abi_version}/ { next; }\
4248 { sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_version}\"); }\
4252 if test "x$WILDCARD_SYMS" = xno
4254 cf_awk_program="$cf_awk_program\
4255 /[[ ]]_\\*;/ { skip=1; next; }\
4259 if test "x$cf_awk_program" != "x"
4261 cat >>$cf_dir/Makefile <<CF_EOF
4263 # Generated by CF_LIB_RULES
4264 resulting.map: $UNALTERED_SYMS
4265 $AWK 'BEGIN { skip = 1; last=""; } \
4267 { if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\
4268 skip = 0; last = \[$]\[$]0; } \
4269 END { print last; }' < $UNALTERED_SYMS >\[$]@
4276 for cf_item in $cf_LIST_MODELS
4278 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4279 if test "$cf_dir" = "c++"
4281 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4283 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4285 test -z "$cf_libname" && cf_libname="$cf_dir"
4286 if test $cf_item = shared ; then
4287 if test -n "${LIB_SUFFIX}"
4289 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4291 cf_shared_suffix="$cf_suffix"
4293 if test "$cf_cv_do_symlinks" = yes ; then
4296 case "$cf_cv_shlib_version" in
4298 cf_version_name=REL_VERSION
4301 cf_version_name=ABI_VERSION
4305 if test -n "$cf_version_name"
4307 case "$cf_cv_system_name" in
4310 cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix"
4313 cf_suffix="$cf_suffix"'.${'$cf_version_name'}'
4317 if test -n "${USE_LIB_SUFFIX}"
4319 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'`
4321 cf_shared_suffix="$cf_suffix"
4324 # cygwin needs import library, and has unique naming convention
4325 # use autodetected ${cf_prefix} for import lib and static lib, but
4326 # use 'cyg' prefix for shared lib.
4327 case $cf_cv_shlib_version in
4329 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4330 cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}"
4333 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4334 cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}"
4337 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4338 cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}"
4341 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'`
4342 cf_add_lib="../lib/${cf_libname}${cf_cygsuf}"
4348 if test -n "$cf_add_lib"
4350 Libs_To_Make="$Libs_To_Make $cf_add_lib"
4354 cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}"
4355 Libs_To_Make="$Libs_To_Make $cf_add_lib"
4358 if test $cf_dir = ncurses ; then
4359 cf_subsets="$LIB_SUBSETS"
4360 cf_r_parts="$cf_subsets"
4361 cf_liblist="$Libs_To_Make"
4363 while test -n "$cf_r_parts"
4365 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'`
4366 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'`
4367 if test "$cf_l_parts" != "$cf_r_parts" ; then
4371 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g`
4374 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g`
4380 if test -n "$cf_add_lib"; then
4381 Libs_To_Make="$cf_add_lib $Libs_To_Make"
4388 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'`
4391 if test $cf_dir = c++; then
4392 if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then
4394 for cf_item in $Libs_To_Make
4400 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"`
4403 for cf_test in $cf_list
4405 if test "$cf_test" = "$cf_item"
4407 cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'`
4412 test -n "$cf_item" && cf_list="$cf_list $cf_item"
4414 Libs_To_Make="$cf_list"
4418 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \
4419 -e "s%@SHARED_LIB@%$SHARED_LIB%" \
4420 $cf_dir/Makefile >$cf_dir/Makefile.out
4421 mv $cf_dir/Makefile.out $cf_dir/Makefile
4423 $AWK -f $srcdir/mk-0th.awk \
4424 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \
4425 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
4427 for cf_subset in $cf_subsets
4430 for cf_item in $cf_LIST_MODELS
4433 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})"
4434 CF_UPPER(cf_ITEM,$cf_item)
4437 if test "$CXX_MODEL" = SHARED; then
4438 case $cf_cv_shlib_version in
4439 (cygdll|msysdll|mingw|msvcdll)
4440 test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED)
4444 test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL
4449 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf)
4450 CF_OBJ_SUBDIR($cf_item,cf_subdir)
4452 # Test for case where we build libtinfo with a different name.
4454 if test $cf_dir = ncurses ; then
4457 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4460 cf_libname=$TINFO_LIB_SUFFIX
4463 cf_libname=$TICS_LIB_SUFFIX
4466 elif test $cf_dir = c++ ; then
4467 CF_MAP_LIB_BASENAME(cf_libname,cxx)
4468 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4470 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir)
4471 cf_libname=${cf_libname}$USE_LIB_SUFFIX
4473 if test -n "${USE_ARG_SUFFIX}" ; then
4474 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX
4475 cf_suffix=`echo $cf_suffix |sed -e "s%^${USE_LIB_SUFFIX}%%"`
4478 # These dependencies really are for development, not
4479 # builds, but they are useful in porting, too.
4480 cf_depend="../include/ncurses_cfg.h"
4481 if test "$srcdir" = "."; then
4484 cf_reldir="\${srcdir}"
4487 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then
4488 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h"
4489 elif test -f $srcdir/$cf_dir/curses.priv.h; then
4490 cf_depend="$cf_depend $cf_reldir/curses.priv.h"
4494 old_cf_suffix="$cf_suffix"
4495 if test "$cf_cv_shlib_version_infix" = yes ; then
4496 if test -n "$USE_LIB_SUFFIX" ; then
4497 case $USE_LIB_SUFFIX in
4499 cf_libname=`echo $cf_libname | sed 's/tw'$EXTRA_SUFFIX'$//'`
4500 cf_suffix=`echo $cf_suffix | sed 's/^tw'$EXTRA_SUFFIX'//'`
4501 cf_dir_suffix=tw$EXTRA_SUFFIX
4504 cf_libname=`echo $cf_libname | sed 's/t'$EXTRA_SUFFIX'$//'`
4505 cf_suffix=`echo $cf_suffix | sed 's/^t'$EXTRA_SUFFIX'//'`
4506 cf_dir_suffix=t$EXTRA_SUFFIX
4509 cf_libname=`echo $cf_libname | sed 's/w'$EXTRA_SUFFIX'$//'`
4510 cf_suffix=`echo $cf_suffix | sed 's/^w'$EXTRA_SUFFIX'//'`
4511 cf_dir_suffix=w$EXTRA_SUFFIX
4514 cf_libname=`echo $cf_libname | sed 's/'$EXTRA_SUFFIX'$//'`
4515 cf_suffix=`echo $cf_suffix | sed 's/^'$EXTRA_SUFFIX'//'`
4516 cf_dir_suffix=$EXTRA_SUFFIX
4522 $AWK -f $srcdir/mk-1st.awk \
4523 name=${cf_libname}${cf_dir_suffix} \
4524 traces=$LIB_TRACING \
4526 CXX_MODEL=$CXX_MODEL \
4531 driver=$cf_cv_term_driver \
4533 TermlibRoot=$TINFO_NAME \
4534 TermlibSuffix=$TINFO_SUFFIX \
4535 ShlibVer=$cf_cv_shlib_version \
4536 ShlibVerInfix=$cf_cv_shlib_version_infix \
4537 ReLink=${cf_cv_do_relink:-no} \
4538 ReRanlib=${cf_cv_do_reranlib:-yes} \
4539 DoLinks=$cf_cv_do_symlinks \
4540 rmSoLocs=$cf_cv_rm_so_locs \
4541 ldconfig="$LDCONFIG" \
4542 overwrite=$WITH_OVERWRITE \
4543 depend="$cf_depend" \
4545 libtool_version="$LIBTOOL_VERSION" \
4546 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
4548 cf_suffix="$old_cf_suffix"
4550 for cf_subdir2 in $cf_subdirs lib
4552 test $cf_subdir = $cf_subdir2 && break
4554 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \
4555 $AWK -f $srcdir/mk-2nd.awk \
4557 traces=$LIB_TRACING \
4563 crenames=$cf_cv_prog_CC_c_o \
4564 cxxrenames=$cf_cv_prog_CXX_c_o \
4565 $srcdir/$cf_dir/modules >>$cf_dir/Makefile
4566 cf_subdirs="$cf_subdirs $cf_subdir"
4571 echo ' cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile
4574 for cf_dir in $SRC_SUBDIRS
4576 if test ! -d $srcdir/$cf_dir ; then
4580 if test -f $cf_dir/Makefile ; then
4583 echo 'libs \' >> Makefile
4584 echo 'install.libs \' >> Makefile
4585 echo 'uninstall.libs ::' >> Makefile
4586 echo ' cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile
4591 if test -f $srcdir/$cf_dir/modules; then
4593 if test -f $srcdir/$cf_dir/headers; then
4594 cat >> Makefile <<CF_EOF
4596 uninstall.includes \\
4599 if test "$cf_dir" != "c++" ; then
4600 echo 'lint \' >> Makefile
4602 cat >> Makefile <<CF_EOF
4608 uninstall.$cf_dir ::
4609 cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
4611 elif test -f $srcdir/$cf_dir/headers; then
4612 cat >> Makefile <<CF_EOF
4618 uninstall.includes ::
4619 cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@
4624 if test "x$cf_with_db_install" = xyes; then
4625 cat >> Makefile <<CF_EOF
4627 install.libs uninstall.libs \\
4628 install.data uninstall.data ::
4629 $MAKE_TERMINFO cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
4632 cat >> Makefile <<CF_EOF
4634 install.libs uninstall.libs ::
4635 cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@
4639 if test "x$cf_with_manpages" = xyes; then
4640 cat >> Makefile <<CF_EOF
4644 cd man && \${MAKE} \${TOP_MFLAGS} \[$]@
4648 cat >> Makefile <<CF_EOF
4651 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h
4652 rm -f headers.sh headers.sed mk_shared_lib.sh
4653 rm -f edit_man.* man_alias.*
4654 rm -rf \${DIRS_TO_MAKE}
4657 # Special case: tack's manpage lives in its own directory.
4658 if test "x$cf_with_manpages" = xyes; then
4659 if test "x$cf_with_tack" = "xyes"; then
4660 cat >> Makefile <<CF_EOF
4664 cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@
4669 dnl If we're installing into a subdirectory of /usr/include, etc., we should
4670 dnl prepend the subdirectory's name to the "#include" paths. It won't hurt
4671 dnl anything, and will make it more standardized. It's awkward to decide this
4672 dnl at configuration because of quoting, so we'll simply make all headers
4673 dnl installed via a script that can do the right thing.
4675 rm -f headers.sed headers.sh
4677 dnl ( generating this script makes the makefiles a little tidier :-)
4678 echo creating headers.sh
4679 cat >headers.sh <<CF_EOF
4681 # This shell script is generated by the 'configure' script. It is invoked in a
4682 # subdirectory of the build tree. It generates a sed-script in the parent
4683 # directory that is used to adjust includes for header files that reside in a
4684 # subdirectory of /usr/include, etc.
4686 while test \[$]# != 3
4688 PRG="\$PRG \[$]1"; shift
4693 TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$
4694 TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$
4695 echo installing \$SRC in \$DST
4698 if test $WITH_CURSES_H = yes; then
4699 cat >>headers.sh <<CF_EOF
4702 END=\`basename \$DST\`
4703 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
4705 NAME=\`basename \$i\`
4706 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
4716 cat >>headers.sh <<CF_EOF
4719 END=\`basename \$DST\`
4720 for i in \`cat \$REF/../*/headers |fgrep -v "#"\`
4722 NAME=\`basename \$i\`
4723 if test "\$NAME" = "curses.h"
4725 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
4728 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED
4732 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED
4737 cat >>headers.sh <<CF_EOF
4739 sed -f \$TMPSED \$SRC > \$TMPSRC
4740 NAME=\`basename \$SRC\`
4742 if test $WITH_CURSES_H != yes; then
4743 cat >>headers.sh <<CF_EOF
4744 test "\$NAME" = "curses.h" && NAME=ncurses.h
4747 cat >>headers.sh <<CF_EOF
4748 # Just in case someone gzip'd manpages, remove the conflicting copy.
4749 test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz
4751 eval \$PRG \$TMPSRC \$DST/\$NAME
4752 rm -f \$TMPSRC \$TMPSED
4755 chmod 0755 headers.sh
4757 for cf_dir in $SRC_SUBDIRS
4759 if test ! -d $srcdir/$cf_dir ; then
4763 if test -f $srcdir/$cf_dir/headers; then
4764 $AWK -f $srcdir/mk-hdr.awk \
4765 subset="$LIB_SUBSETS" \
4766 compat="$WITH_CURSES_H" \
4767 $srcdir/$cf_dir/headers >>$cf_dir/Makefile
4770 if test -f $srcdir/$cf_dir/modules; then
4771 if test "$cf_dir" != "c++" ; then
4772 cat >>$cf_dir/Makefile <<"CF_EOF"
4773 depend : ${AUTO_SRC}
4774 makedepend -- ${CPPFLAGS} -- ${C_SRC}
4776 # DO NOT DELETE THIS LINE -- make depend depends on it.
4781 AC_SUBST(Libs_To_Make)
4783 dnl ---------------------------------------------------------------------------
4784 dnl CF_LIB_SONAME version: 6 updated: 2017/01/21 11:06:25
4786 dnl Find the and soname for the given shared library. Set the cache variable
4787 dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache
4788 dnl variable to "unknown".
4792 dnl $3 = library name
4793 AC_DEFUN([CF_LIB_SONAME],
4795 AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[
4797 cf_cv_$3_soname=unknown
4798 if test "$cross_compiling" != yes ; then
4799 cat >conftest.$ac_ext <<CF_EOF
4804 ${cf_cv_main_return:-return}(0);
4807 cf_save_LIBS="$LIBS"
4809 if AC_TRY_EVAL(ac_compile) ; then
4810 if AC_TRY_EVAL(ac_link) ; then
4811 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.`
4812 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown
4816 LIBS="$cf_save_LIBS"
4820 dnl ---------------------------------------------------------------------------
4821 dnl CF_LIB_SUFFIX version: 26 updated: 2020/04/04 10:11:47
4823 dnl Compute the library file-suffix from the given model name
4825 dnl $2 = variable to set (the nominal library suffix)
4826 dnl $3 = dependency variable to set (actual filename)
4827 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
4828 AC_DEFUN([CF_LIB_SUFFIX],
4836 case $cf_cv_system_name in
4847 case $cf_cv_system_name in
4858 case $cf_cv_system_name in
4867 (cygwin*|msys*|mingw*)
4905 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
4907 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
4908 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
4911 dnl ---------------------------------------------------------------------------
4912 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
4914 dnl Compute the string to append to -library from the given model name
4916 dnl $2 = variable to set
4917 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
4918 AC_DEFUN([CF_LIB_TYPE],
4924 (profile) $2='_p' ;;
4927 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
4929 dnl ---------------------------------------------------------------------------
4930 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
4931 dnl ----------------
4932 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
4933 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
4934 dnl have to provide wrappers for global tables to ensure they're linked
4936 AC_DEFUN([CF_LINK_DATAONLY],
4938 AC_MSG_CHECKING([if data-only library module links])
4939 AC_CACHE_VAL(cf_cv_link_dataonly,[
4941 cat >conftest.$ac_ext <<EOF
4942 #line __oline__ "configure"
4943 int testdata[[3]] = { 123, 456, 789 };
4945 if AC_TRY_EVAL(ac_compile) ; then
4946 mv conftest.o data.o && \
4947 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
4949 rm -f conftest.$ac_ext data.o
4950 cat >conftest.$ac_ext <<EOF
4951 #line __oline__ "configure"
4955 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
4957 extern int testdata[[3]];
4958 return testdata[[0]] == 123
4959 && testdata[[1]] == 456
4960 && testdata[[2]] == 789;
4964 if AC_TRY_EVAL(ac_compile); then
4965 mv conftest.o func.o && \
4966 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
4968 rm -f conftest.$ac_ext func.o
4969 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
4971 LIBS="conftest.a $LIBS"
4975 extern int testfunc();
4976 ${cf_cv_main_return:-return} (!testfunc());
4979 [cf_cv_link_dataonly=yes],
4980 [cf_cv_link_dataonly=no],
4981 [cf_cv_link_dataonly=unknown])
4984 AC_MSG_RESULT($cf_cv_link_dataonly)
4986 if test "$cf_cv_link_dataonly" = no ; then
4987 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
4990 AC_SUBST(BROKEN_LINKER)
4993 dnl ---------------------------------------------------------------------------
4994 dnl CF_LINK_FUNCS version: 9 updated: 2017/01/21 11:11:02
4996 dnl Most Unix systems have both link and symlink, a few don't have symlink.
4997 dnl A few non-Unix systems implement symlink, but not link.
4998 dnl A few non-systems implement neither (or have nonfunctional versions).
4999 AC_DEFUN([CF_LINK_FUNCS],
5008 if test "$cross_compiling" = yes ; then
5013 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[
5015 for cf_func in link symlink ; do
5017 #include <sys/types.h>
5018 #include <sys/stat.h>
5019 #ifdef HAVE_UNISTD_H
5025 char *src = "config.log";
5026 char *dst = "conftest.chk";
5031 fail = ($cf_func("config.log", "conftest.chk") < 0)
5032 || (stat(dst, &dst_sb) < 0)
5033 || (dst_sb.st_mtime != src_sb.st_mtime);
5039 ${cf_cv_main_return:-return} (fail);
5042 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func"
5043 eval 'ac_cv_func_'$cf_func'=yes'],[
5044 eval 'ac_cv_func_'$cf_func'=no'],[
5045 eval 'ac_cv_func_'$cf_func'=error'])
5047 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no
5049 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function])
5050 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function])
5053 dnl ---------------------------------------------------------------------------
5054 dnl CF_MAKEFLAGS version: 18 updated: 2018/02/21 21:26:03
5056 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
5057 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
5058 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
5059 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
5060 AC_DEFUN([CF_MAKEFLAGS],
5062 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
5064 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
5066 cat >cf_makeflags.tmp <<CF_EOF
5069 @ echo '.$cf_option'
5071 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
5072 case "$cf_result" in
5074 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
5075 case "$cf_result" in
5076 (.*CC=*) cf_cv_makeflags=
5078 (*) cf_cv_makeflags=$cf_option
5086 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
5090 rm -f cf_makeflags.tmp
5093 AC_SUBST(cf_cv_makeflags)
5095 dnl ---------------------------------------------------------------------------
5096 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
5098 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
5099 dnl a monocase filesystem.
5100 AC_DEFUN([CF_MAKE_TAGS],[
5101 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
5103 AC_CHECK_PROGS(CTAGS, exctags ctags)
5104 AC_CHECK_PROGS(ETAGS, exetags etags)
5106 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
5108 if test "$cf_cv_mixedcase" = yes ; then
5109 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
5114 if test "$MAKE_UPPER_TAGS" = yes ; then
5120 if test "$MAKE_LOWER_TAGS" = yes ; then
5129 AC_SUBST(MAKE_UPPER_TAGS)
5130 AC_SUBST(MAKE_LOWER_TAGS)
5132 dnl ---------------------------------------------------------------------------
5133 dnl CF_MANPAGE_FORMAT version: 11 updated: 2015/04/18 08:56:57
5134 dnl -----------------
5135 dnl Option to allow user to override automatic configuration of manpage format.
5136 dnl There are several special cases:
5138 dnl gzip - man checks for, can display gzip'd files
5139 dnl compress - man checks for, can display compressed files
5140 dnl BSDI - files in the cat-directories are suffixed ".0"
5141 dnl formatted - installer should format (put files in cat-directory)
5142 dnl catonly - installer should only format, e.g., for a turnkey system.
5144 dnl There are other configurations which this macro does not test, e.g., HPUX's
5145 dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming
5146 dnl convention would not match our use).
5147 AC_DEFUN([CF_MANPAGE_FORMAT],
5149 AC_REQUIRE([CF_PATHSEP])
5150 AC_MSG_CHECKING(format of man-pages)
5152 AC_ARG_WITH(manpage-format,
5153 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and
5154 optionally formatted/catonly, e.g., gzip,formatted],
5155 [MANPAGE_FORMAT=$withval],
5156 [MANPAGE_FORMAT=unknown])
5158 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown
5159 MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'`
5163 case $MANPAGE_FORMAT in
5165 if test -z "$MANPATH" ; then
5166 MANPATH="/usr/man:/usr/share/man"
5169 # look for the 'date' man-page (it's most likely to be installed!)
5175 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
5176 for cf_dir in $MANPATH; do
5177 test -z "$cf_dir" && cf_dir=/usr/man
5178 for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example
5180 cf_test=`echo $cf_name | sed -e 's/*//'`
5181 if test "x$cf_test" = "x$cf_name" ; then
5184 (*.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";;
5185 (*.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";;
5186 (*.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";;
5187 (*) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";;
5201 # if we found a match in either man* or cat*, stop looking
5202 if test -n "$MANPAGE_FORMAT" ; then
5204 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted"
5205 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly"
5211 test $cf_found=yes && break
5214 # only check the first directory in $MANPATH where we find manpages
5215 if test -n "$MANPAGE_FORMAT" ; then
5219 # if we did not find the example, just assume it is normal
5220 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal
5224 for cf_option in $MANPAGE_FORMAT; do
5226 (gzip|compress|BSDI|normal|formatted|catonly)
5229 cf_unknown="$cf_unknown $cf_option"
5236 AC_MSG_RESULT($MANPAGE_FORMAT)
5237 if test -n "$cf_unknown" ; then
5238 AC_MSG_WARN(Unexpected manpage-format $cf_unknown)
5241 dnl ---------------------------------------------------------------------------
5242 dnl CF_MANPAGE_RENAMES version: 10 updated: 2015/08/05 20:44:28
5243 dnl ------------------
5244 dnl The Debian people have their own naming convention for manpages. This
5245 dnl option lets us override the name of the file containing renaming, or
5246 dnl disable it altogether.
5247 AC_DEFUN([CF_MANPAGE_RENAMES],
5249 AC_MSG_CHECKING(for manpage renaming)
5251 AC_ARG_WITH(manpage-renames,
5252 [ --with-manpage-renames specify manpage-renaming],
5253 [MANPAGE_RENAMES=$withval],
5254 [MANPAGE_RENAMES=yes])
5256 case ".$MANPAGE_RENAMES" in
5260 # Debian 'man' program?
5261 if test -f /etc/debian_version ; then
5262 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames
5269 if test "$MANPAGE_RENAMES" != no ; then
5270 if test -f $srcdir/man/$MANPAGE_RENAMES ; then
5271 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES
5272 elif test ! -f $MANPAGE_RENAMES ; then
5273 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES)
5276 test ! -d man && mkdir man
5278 # Construct a sed-script to perform renaming within man-pages
5279 if test -n "$MANPAGE_RENAMES" ; then
5280 test ! -d man && mkdir man
5281 $SHELL $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed
5285 AC_MSG_RESULT($MANPAGE_RENAMES)
5286 AC_SUBST(MANPAGE_RENAMES)
5288 dnl ---------------------------------------------------------------------------
5289 dnl CF_MANPAGE_SYMLINKS version: 6 updated: 2015/04/17 21:13:04
5290 dnl -------------------
5291 dnl Some people expect each tool to make all aliases for manpages in the
5292 dnl man-directory. This accommodates the older, less-capable implementations
5293 dnl of 'man', and is optional.
5294 AC_DEFUN([CF_MANPAGE_SYMLINKS],
5296 AC_MSG_CHECKING(if manpage aliases will be installed)
5298 AC_ARG_WITH(manpage-aliases,
5299 [ --with-manpage-aliases specify manpage-aliases using .so],
5300 [MANPAGE_ALIASES=$withval],
5301 [MANPAGE_ALIASES=yes])
5303 AC_MSG_RESULT($MANPAGE_ALIASES)
5315 if test "$MANPAGE_ALIASES" = yes ; then
5316 AC_MSG_CHECKING(if manpage symlinks should be used)
5318 AC_ARG_WITH(manpage-symlinks,
5319 [ --with-manpage-symlinks specify manpage-aliases using symlinks],
5320 [MANPAGE_SYMLINKS=$withval],
5321 [MANPAGE_SYMLINKS=$cf_use_symlinks])
5323 if test "$$cf_use_symlinks" = no; then
5324 if test "$MANPAGE_SYMLINKS" = yes ; then
5325 AC_MSG_WARN(cannot make symlinks, will use .so files)
5330 AC_MSG_RESULT($MANPAGE_SYMLINKS)
5334 dnl ---------------------------------------------------------------------------
5335 dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32
5337 dnl This option causes manpages to be run through tbl(1) to generate tables
5339 AC_DEFUN([CF_MANPAGE_TBL],
5341 AC_MSG_CHECKING(for manpage tbl)
5343 AC_ARG_WITH(manpage-tbl,
5344 [ --with-manpage-tbl specify manpage processing with tbl],
5345 [MANPAGE_TBL=$withval],
5348 AC_MSG_RESULT($MANPAGE_TBL)
5350 dnl ---------------------------------------------------------------------------
5351 dnl CF_MAN_PAGES version: 47 updated: 2017/08/12 07:58:51
5353 dnl Try to determine if the man-pages on the system are compressed, and if
5354 dnl so, what format is used. Use this information to construct a script that
5355 dnl will install man-pages.
5356 AC_DEFUN([CF_MAN_PAGES],
5358 CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:)
5364 if test "$prefix" = "NONE" ; then
5365 cf_prefix="$ac_default_prefix"
5370 case "$MANPAGE_FORMAT" in
5385 test ! -d man && mkdir man
5389 case "$MANPAGE_FORMAT" in
5392 cf_compress=compress
5400 cf_edit_man=./edit_man.sh
5401 cf_man_alias=`pwd`/man_alias.sed
5403 cat >$cf_edit_man <<CF_EOF
5405 # this script is generated by the configure-script CF_MAN_PAGES macro.
5408 datarootdir="$datarootdir"
5411 NCURSES_MAJOR="$NCURSES_MAJOR"
5412 NCURSES_MINOR="$NCURSES_MINOR"
5413 NCURSES_PATCH="$NCURSES_PATCH"
5415 NCURSES_OSPEED="$NCURSES_OSPEED"
5416 TERMINFO="$TERMINFO"
5419 INSTALL_DATA="$INSTALL_DATA"
5421 transform="$program_transform_name"
5423 TMP=\${TMPDIR:=/tmp}/man\$\$
5424 trap "rm -f \$TMP" 0 1 2 3 15
5436 top_srcdir=\[$]srcdir/..
5439 if test "\$form" = normal ; then
5440 if test "$cf_format" = yes ; then
5441 if test "$cf_inboth" = no ; then
5442 $SHELL \[$]0 format \$verb \$mandir \$srcdir \[$]*
5446 cf_subdir=\$mandir/man
5447 cf_tables=$MANPAGE_TBL
5449 cf_subdir=\$mandir/cat
5453 # process the list of source-files
5458 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`;
5459 if test \$verb = installing ; then
5460 if test ! -d \$cf_subdir\${section} ; then
5461 mkdir -p \$cf_subdir\$section
5465 # replace variables in man page
5466 if test ! -f $cf_man_alias ; then
5467 cat >>$cf_man_alias <<-CF_EOF2
5468 s,@DATADIR@,\$datadir,g
5469 s,@TERMINFO@,\${TERMINFO:="no default value"},g
5470 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g
5471 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g
5472 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g
5473 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g
5474 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g
5479 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
5480 cf_name=`echo $cf_name|sed "$program_transform_name"`
5481 cat >>$cf_edit_man <<-CF_EOF
5482 s,@$cf_NAME@,$cf_name,g
5486 cat >>$cf_edit_man <<CF_EOF
5488 echo "...made $cf_man_alias"
5492 cf_source=\`basename \$i\`
5494 test ! -f \$inalias && inalias="\$srcdir/\$inalias"
5495 if test ! -f \$inalias ; then
5496 echo .. skipped \$cf_source
5501 if test "$MANPAGE_ALIASES" != no ; then
5502 cat >>$cf_edit_man <<CF_EOF
5504 test $with_curses_h = yes && nCurses=ncurses.3x
5505 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\`
5509 if test "$MANPAGE_RENAMES" = no ; then
5510 cat >>$cf_edit_man <<CF_EOF
5511 # perform program transformations for section 1 man pages
5512 if test \$section = 1 ; then
5513 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\`
5515 cf_target=\$cf_subdir\${section}/\$cf_source
5519 cat >>$cf_edit_man <<CF_EOF
5520 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\`
5521 if test -z "\$cf_target" ; then
5522 echo '? missing rename for '\$cf_source
5523 cf_target="\$cf_source"
5525 cf_target="\$cf_subdir\${section}/\${cf_target}"
5530 cat >>$cf_edit_man <<CF_EOF
5531 sed -f $cf_man_alias \\
5534 if test -f $MANPAGE_RENAMES ; then
5535 cat >>$cf_edit_man <<CF_EOF
5536 < \$i | sed -f `pwd`/edit_man.sed >\$TMP
5539 cat >>$cf_edit_man <<CF_EOF
5544 cat >>$cf_edit_man <<CF_EOF
5545 if test \$cf_tables = yes ; then
5546 tbl \$TMP >\$TMP.out
5551 if test $with_overwrite != yes ; then
5552 cat >>$cf_edit_man <<CF_EOF
5553 sed -e "/\#[ ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out
5558 if test $with_curses_h != yes ; then
5559 cat >>$cf_edit_man <<CF_EOF
5560 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out
5565 cat >>$cf_edit_man <<CF_EOF
5566 if test \$form = format ; then
5567 nroff -man \$TMP >\$TMP.out
5572 if test -n "$cf_compress" ; then
5573 cat >>$cf_edit_man <<CF_EOF
5574 if test \$verb = installing ; then
5575 if ( $cf_compress -f \$TMP )
5577 mv \$TMP.$cf_so_strip \$TMP
5580 cf_target="\$cf_target.$cf_so_strip"
5584 case "$MANPAGE_FORMAT" in
5586 cat >>$cf_edit_man <<CF_EOF
5587 if test \$form = format ; then
5588 # BSDI installs only .0 suffixes in the cat directories
5589 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`"
5595 cat >>$cf_edit_man <<CF_EOF
5596 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\`
5597 if test \$verb = installing ; then
5598 echo \$verb \$cf_target
5599 \$INSTALL_DATA \$TMP \$cf_target
5600 test -d \$cf_subdir\${section} &&
5601 test -n "\$aliases" && (
5602 cd \$cf_subdir\${section} && (
5603 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\`
5604 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\`
5605 cf_target=\`basename \$cf_target\`
5606 for cf_alias in \$aliases
5608 if test \$section = 1 ; then
5609 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
5612 if test "$MANPAGE_SYMLINKS" = yes ; then
5613 if test -f \$cf_alias\${suffix} ; then
5614 if ( cmp -s \$cf_target \$cf_alias\${suffix} )
5619 echo .. \$verb alias \$cf_alias\${suffix}
5623 cat >>$cf_edit_man <<CF_EOF
5624 $LN_S \$cf_target \$cf_alias\${suffix}
5628 cat >>$cf_edit_man <<CF_EOF
5629 rm -f \$cf_alias\${suffix}
5630 $LN_S \$cf_target \$cf_alias\${suffix}
5634 cat >>$cf_edit_man <<CF_EOF
5635 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then
5636 echo ".so \$cf_source" >\$TMP
5638 if test -n "$cf_compress" ; then
5639 cat >>$cf_edit_man <<CF_EOF
5640 if test -n "$cf_so_strip" ; then
5641 $cf_compress -f \$TMP
5642 mv \$TMP.$cf_so_strip \$TMP
5646 cat >>$cf_edit_man <<CF_EOF
5647 echo .. \$verb alias \$cf_alias\${suffix}
5648 rm -f \$cf_alias\${suffix}
5649 \$INSTALL_DATA \$TMP \$cf_alias\${suffix}
5654 elif test \$verb = removing ; then
5655 test -f \$cf_target && (
5656 echo \$verb \$cf_target
5659 test -d \$cf_subdir\${section} &&
5660 test -n "\$aliases" && (
5661 cd \$cf_subdir\${section} && (
5662 for cf_alias in \$aliases
5664 if test \$section = 1 ; then
5665 cf_alias=\`echo \$cf_alias|sed "\${transform}"\`
5668 echo .. \$verb alias \$cf_alias\${suffix}
5669 rm -f \$cf_alias\${suffix}
5681 if test $cf_inboth = yes ; then
5682 if test \$form != format ; then
5683 $SHELL \[$]0 format \$verb \$mandir \$srcdir \[$]*
5689 chmod 755 $cf_edit_man
5692 dnl ---------------------------------------------------------------------------
5693 dnl CF_MAP_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
5694 dnl -------------------
5695 dnl Convert a default-libname to the actual one used via CF_WITH_LIB_BASENAME.
5697 dnl $1 = variable to set
5698 dnl $2 = default-libname
5699 AC_DEFUN([CF_MAP_LIB_BASENAME],[
5700 CF_UPPER(cf_map_lib_basename,$2)
5701 eval $1=\$${cf_map_lib_basename}_NAME
5703 dnl ---------------------------------------------------------------------------
5704 dnl CF_MATH_LIB version: 9 updated: 2017/01/21 11:06:25
5706 dnl Checks for libraries. At least one UNIX system, Apple Macintosh
5707 dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler
5708 dnl AC_CHECK_LIB(m,sin), because that fails for C++.
5709 AC_DEFUN([CF_MATH_LIB],
5711 AC_CACHE_CHECK(if -lm needed for math functions,
5718 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)],
5719 [cf_cv_need_libm=no],
5720 [cf_cv_need_libm=yes])])
5721 if test "$cf_cv_need_libm" = yes
5728 dnl ---------------------------------------------------------------------------
5729 dnl CF_MIXEDCASE_FILENAMES version: 8 updated: 2020/11/14 10:12:15
5730 dnl ----------------------
5731 dnl Check if the file-system supports mixed-case filenames. If we're able to
5732 dnl create a lowercase name and see it as uppercase, it doesn't support that.
5733 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
5735 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
5736 if test "$cross_compiling" = yes ; then
5737 case $target_alias in
5738 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
5746 rm -f conftest CONFTEST
5748 if test -f CONFTEST ; then
5753 rm -f conftest CONFTEST
5756 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
5758 dnl ---------------------------------------------------------------------------
5759 dnl CF_MKSTEMP version: 10 updated: 2017/01/21 11:12:16
5761 dnl Check for a working mkstemp. This creates two files, checks that they are
5762 dnl successfully created and distinct (AmigaOS apparently fails on the last).
5763 AC_DEFUN([CF_MKSTEMP],[
5767 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
5770 #include <sys/types.h>
5771 #ifdef HAVE_UNISTD_H
5777 #include <sys/stat.h>
5780 char *tmpl = "conftestXXXXXX";
5788 for (n = 0; n < 2; ++n) {
5789 strcpy(name[n], tmpl);
5790 if ((fd = mkstemp(name[n])) >= 0) {
5791 if (!strcmp(name[n], tmpl)
5792 || stat(name[n], &sb) != 0
5793 || (sb.st_mode & S_IFMT) != S_IFREG
5794 || (sb.st_mode & 077) != 0) {
5801 && !strcmp(name[0], name[1]))
5803 ${cf_cv_main_return:-return}(result);
5805 ],[cf_cv_func_mkstemp=yes
5806 ],[cf_cv_func_mkstemp=no
5807 ],[cf_cv_func_mkstemp=maybe])
5809 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
5810 AC_CHECK_FUNC(mkstemp)
5812 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
5813 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
5816 dnl ---------------------------------------------------------------------------
5817 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
5819 dnl Write a debug message to config.log, along with the line number in the
5820 dnl configure script.
5821 AC_DEFUN([CF_MSG_LOG],[
5822 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
5824 dnl ---------------------------------------------------------------------------
5825 dnl CF_NCURSES_ABI_6 version: 3 updated: 2015/06/06 16:10:11
5826 dnl ----------------
5827 dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and
5828 dnl warn about this.
5829 AC_DEFUN([CF_NCURSES_ABI_6],[
5830 if test "${with_abi_version+set}" != set; then
5831 case $cf_cv_rel_version in
5833 cf_cv_rel_version=6.0
5835 AC_MSG_WARN(overriding ABI version to $cf_cv_abi_version)
5840 dnl ---------------------------------------------------------------------------
5841 dnl CF_NCURSES_WITH_ABI_VERSION version: 2 updated: 2015/12/19 17:51:52
5842 dnl ---------------------------
5843 dnl Allow ncurses's ABI to be overridden. Generally this happens when a
5844 dnl packager has incremented the ABI past that used in the original package,
5845 dnl and wishes to keep doing this.
5847 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
5849 AC_DEFUN([CF_NCURSES_WITH_ABI_VERSION],[
5850 CF_WITH_ABI_VERSION($1)
5851 if test "x$cf_cv_abi_version" != "x$with_abi_version"
5853 case $cf_cv_rel_version in
5855 cf_cv_rel_version=$with_abi_version.0
5860 dnl ---------------------------------------------------------------------------
5861 dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00
5862 dnl ------------------
5863 dnl see CF_WITH_NO_LEAKS
5864 AC_DEFUN([CF_NO_LEAKS_OPTION],[
5865 AC_MSG_CHECKING(if you want to use $1 for testing)
5868 [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[
5871 : ${with_cflags:=-g}
5872 : ${with_no_leaks:=yes}
5875 AC_MSG_RESULT(${with_$1:-no})
5877 case .$with_cflags in
5889 dnl ---------------------------------------------------------------------------
5890 dnl CF_NUMBER_SYNTAX version: 2 updated: 2015/04/17 21:13:04
5891 dnl ----------------
5892 dnl Check if the given variable is a number. If not, report an error.
5893 dnl $1 is the variable
5894 dnl $2 is the message
5895 AC_DEFUN([CF_NUMBER_SYNTAX],[
5896 if test -n "$1" ; then
5901 AC_MSG_ERROR($2 is not a number: $1)
5905 AC_MSG_ERROR($2 value is empty)
5908 dnl ---------------------------------------------------------------------------
5909 dnl CF_OBJ_SUBDIR version: 7 updated: 2015/04/17 21:13:04
5911 dnl Compute the object-directory name from the given model name
5912 AC_DEFUN([CF_OBJ_SUBDIR],
5915 (libtool) $2='obj_lo' ;;
5916 (normal) $2='objects' ;;
5917 (debug) $2='obj_g' ;;
5918 (profile) $2='obj_p' ;;
5920 case $cf_cv_system_name in
5928 dnl ---------------------------------------------------------------------------
5929 dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00
5931 dnl Provide a value for the $PATH and similar separator (or amend the value
5932 dnl as provided in autoconf 2.5x).
5933 AC_DEFUN([CF_PATHSEP],
5935 AC_MSG_CHECKING(for PATH separator)
5936 case $cf_cv_system_name in
5937 (os2*) PATH_SEPARATOR=';' ;;
5938 (*) ${PATH_SEPARATOR:=':'} ;;
5940 ifelse([$1],,,[$1=$PATH_SEPARATOR])
5941 AC_SUBST(PATH_SEPARATOR)
5942 AC_MSG_RESULT($PATH_SEPARATOR)
5944 dnl ---------------------------------------------------------------------------
5945 dnl CF_PATH_PROG version: 10 updated: 2019/06/30 19:44:43
5947 dnl Check for a given program, defining corresponding symbol.
5948 dnl $1 = environment variable, which is suffixed by "_PATH" in the #define.
5949 dnl $2 = program name to find.
5950 dnl $3 = optional list of additional program names to test.
5953 dnl If there is more than one token in the result, #define the remaining tokens
5954 dnl to $1_ARGS. We need this for 'install' in particular.
5956 dnl FIXME: we should allow this to be overridden by environment variables
5958 AC_DEFUN([CF_PATH_PROG],[
5959 AC_REQUIRE([CF_PATHSEP])
5960 test -z "[$]$1" && $1=$2
5961 AC_PATH_PROGS($1,[$]$1 $2 ifelse($3,,,$3),[$]$1, ifelse($4,,,$4))
5965 IFS="${IFS:- }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR"
5966 for cf_temp in $ac_cv_path_$1
5968 if test -z "$cf_path_prog" ; then
5969 if test "$with_full_paths" = yes ; then
5970 CF_PATH_SYNTAX(cf_temp,break)
5971 cf_path_prog="$cf_temp"
5973 cf_path_prog="`basename $cf_temp`"
5975 elif test -z "$cf_path_args" ; then
5976 cf_path_args="$cf_temp"
5978 cf_path_args="$cf_path_args $cf_temp"
5983 if test -n "$cf_path_prog" ; then
5984 CF_MSG_LOG(defining path for ${cf_path_prog})
5985 AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog",Define to pathname $1)
5986 test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args",Define to provide args for $1)
5989 dnl ---------------------------------------------------------------------------
5990 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
5992 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
5993 dnl begins with one of the prefix/exec_prefix variables, and then again if the
5994 dnl result begins with 'NONE'. This is necessary to work around autoconf's
5995 dnl delayed evaluation of those symbols.
5996 AC_DEFUN([CF_PATH_SYNTAX],[
5997 if test "x$prefix" != xNONE; then
5998 cf_path_syntax="$prefix"
6000 cf_path_syntax="$ac_default_prefix"
6004 (.\[$]\(*\)*|.\'*\'*)
6008 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
6010 (.\[$]{*prefix}*|.\[$]{*dir}*)
6014 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
6019 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
6022 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
6026 dnl ---------------------------------------------------------------------------
6027 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
6029 dnl Check for the package-config program, unless disabled by command-line.
6030 AC_DEFUN([CF_PKG_CONFIG],
6032 AC_MSG_CHECKING(if you want to use pkg-config)
6033 AC_ARG_WITH(pkg-config,
6034 [ --with-pkg-config{=path} enable/disable use of pkg-config],
6035 [cf_pkg_config=$withval],
6036 [cf_pkg_config=yes])
6037 AC_MSG_RESULT($cf_pkg_config)
6039 case $cf_pkg_config in
6044 CF_ACVERSION_CHECK(2.52,
6045 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
6046 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
6053 test -z "$PKG_CONFIG" && PKG_CONFIG=none
6054 if test "$PKG_CONFIG" != none ; then
6055 CF_PATH_SYNTAX(PKG_CONFIG)
6056 elif test "x$cf_pkg_config" != xno ; then
6057 AC_MSG_WARN(pkg-config is not installed)
6060 AC_SUBST(PKG_CONFIG)
6062 dnl ---------------------------------------------------------------------------
6063 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
6064 dnl -----------------
6065 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
6067 dnl POSIX.1-1990 _POSIX_SOURCE
6068 dnl POSIX.1-1990 and _POSIX_SOURCE and
6069 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
6071 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
6072 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
6073 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
6076 dnl $1 is the nominal value for _POSIX_C_SOURCE
6077 AC_DEFUN([CF_POSIX_C_SOURCE],
6078 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
6080 if test "$cf_cv_posix_visible" = no; then
6082 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
6084 cf_save_CFLAGS="$CFLAGS"
6085 cf_save_CPPFLAGS="$CPPFLAGS"
6087 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
6088 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
6090 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
6091 CF_MSG_LOG(if the symbol is already defined go no further)
6092 AC_TRY_COMPILE([#include <sys/types.h>],[
6093 #ifndef _POSIX_C_SOURCE
6096 [cf_cv_posix_c_source=no],
6097 [cf_want_posix_source=no
6098 case .$cf_POSIX_C_SOURCE in
6100 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6103 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
6104 cf_want_posix_source=yes
6107 cf_want_posix_source=yes
6110 if test "$cf_want_posix_source" = yes ; then
6111 AC_TRY_COMPILE([#include <sys/types.h>],[
6112 #ifdef _POSIX_SOURCE
6115 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
6117 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
6118 CFLAGS="$cf_trim_CFLAGS"
6119 CPPFLAGS="$cf_trim_CPPFLAGS"
6120 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
6121 CF_MSG_LOG(if the second compile does not leave our definition intact error)
6122 AC_TRY_COMPILE([#include <sys/types.h>],[
6123 #ifndef _POSIX_C_SOURCE
6126 [cf_cv_posix_c_source=no])
6127 CFLAGS="$cf_save_CFLAGS"
6128 CPPFLAGS="$cf_save_CPPFLAGS"
6132 if test "$cf_cv_posix_c_source" != no ; then
6133 CFLAGS="$cf_trim_CFLAGS"
6134 CPPFLAGS="$cf_trim_CPPFLAGS"
6135 CF_ADD_CFLAGS($cf_cv_posix_c_source)
6138 fi # cf_cv_posix_visible
6141 dnl ---------------------------------------------------------------------------
6142 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
6143 dnl ----------------
6144 dnl POSIX documents test-macros which an application may set before any system
6145 dnl headers are included to make features available.
6147 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
6148 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
6149 dnl recent features visible in the system header files unless the application
6150 dnl overrides the corresponding test-macros. Doing that introduces portability
6153 dnl This macro makes a special check for the symbols used for this, to avoid a
6154 dnl conflicting definition.
6155 AC_DEFUN([CF_POSIX_VISIBLE],
6157 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
6158 AC_TRY_COMPILE([#include <stdio.h>],[
6159 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
6160 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
6161 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
6162 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
6163 #error conflicting symbols found
6165 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
6168 dnl ---------------------------------------------------------------------------
6169 dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57
6171 dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles.
6173 dnl $1 = symbol to test
6174 dnl $2 = value (if any) to use for a predefinition
6175 AC_DEFUN([CF_PREDEFINE],
6177 AC_MSG_CHECKING(if we must define $1)
6178 AC_TRY_COMPILE([#include <sys/types.h>
6182 #endif],[cf_result=no],[cf_result=yes])
6183 AC_MSG_RESULT($cf_result)
6185 if test "$cf_result" = yes ; then
6186 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])"
6187 elif test "x$2" != "x" ; then
6188 AC_MSG_CHECKING(checking for compatible value versus $2)
6189 AC_TRY_COMPILE([#include <sys/types.h>
6193 #endif],[cf_result=yes],[cf_result=no])
6194 AC_MSG_RESULT($cf_result)
6195 if test "$cf_result" = no ; then
6196 # perhaps we can override it - try...
6197 CPPFLAGS="$CPPFLAGS -D$1=$2"
6201 dnl ---------------------------------------------------------------------------
6202 dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08
6204 dnl Append definitions and rules for the given programs to the subdirectory
6205 dnl Makefiles, and the recursion rule for the top-level Makefile.
6208 dnl $1 = script to run
6209 dnl $2 = list of subdirectories
6213 AC_DEFUN([CF_PRG_RULES],
6217 if test ! -d $srcdir/$cf_dir; then
6219 elif test -f $srcdir/$cf_dir/programs; then
6220 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile
6225 dnl ---------------------------------------------------------------------------
6226 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
6228 dnl Check for archiver "ar".
6229 AC_DEFUN([CF_PROG_AR],[
6230 AC_CHECK_TOOL(AR, ar, ar)
6232 dnl ---------------------------------------------------------------------------
6233 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
6235 dnl Check for awk, ensure that the check found something.
6236 AC_DEFUN([CF_PROG_AWK],
6239 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
6241 dnl ---------------------------------------------------------------------------
6242 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
6244 dnl standard check for CC, plus followup sanity checks
6245 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
6246 AC_DEFUN([CF_PROG_CC],[
6247 CF_ACVERSION_CHECK(2.53,
6248 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
6249 AC_REQUIRE([AC_PROG_CC])],
6251 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
6253 CF_ACVERSION_CHECK(2.52,
6258 dnl ---------------------------------------------------------------------------
6259 dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25
6261 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
6262 dnl the output file can be renamed, and allows for a shell variable that can
6263 dnl be used later. The parameter is either CC or CXX. The result is the
6265 dnl $cf_cv_prog_CC_c_o
6266 dnl $cf_cv_prog_CXX_c_o
6269 dnl $2 = compiler options, if any
6270 AC_DEFUN([CF_PROG_CC_C_O],
6271 [AC_REQUIRE([AC_PROG_CC])dnl
6272 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
6273 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
6275 cat > conftest.$ac_ext <<CF_EOF
6278 ${cf_cv_main_return:-return}(0);
6281 # We do the test twice because some compilers refuse to overwrite an
6282 # existing .o file with -o, though they will create one.
6283 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
6284 if AC_TRY_EVAL(ac_try) &&
6285 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
6287 eval cf_cv_prog_$1_c_o=yes
6289 eval cf_cv_prog_$1_c_o=no
6293 if test $cf_cv_prog_$1_c_o = yes; then
6294 AC_MSG_RESULT([yes])
6299 dnl ---------------------------------------------------------------------------
6300 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
6302 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
6303 dnl This macro adds a check to ensure the script found something.
6304 AC_DEFUN([CF_PROG_EGREP],
6305 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
6306 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
6307 then ac_cv_prog_egrep='grep -E'
6308 else ac_cv_prog_egrep='egrep'
6310 EGREP=$ac_cv_prog_egrep
6312 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
6314 dnl ---------------------------------------------------------------------------
6315 dnl CF_PROG_GNAT version: 10 updated: 2019/12/31 08:53:54
6317 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
6318 AC_DEFUN([CF_PROG_GNAT],[
6319 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
6321 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
6323 unset ac_cv_path_cf_TEMP_gnat
6325 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
6326 eval cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat
6328 if test "x$cf_TEMP_gnat" != xno; then
6329 unset cf_cv_gnat_version
6331 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
6333 eval cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat
6336 unset cf_cv_gnat_version
6337 unset ac_cv_path_cf_TEMP_gnat
6340 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
6342 cf_cv_prog_gnat_correct=no
6344 cf_ada_make=gnatmake
6345 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
6346 # gprconfig is newer than gnatmake; we can continue...
6349 rm -rf conftest* *~conftest*
6350 if mkdir conftest.src
6354 for cf_gprconfig in Ada C
6356 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
6357 if test $cf_gprconfig = C
6359 for cf_gprconfig_param in \
6360 $cf_gprconfig,,,,GNATGCC \
6361 $cf_gprconfig,,,,GCC \
6364 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6365 test -n "$cf_gprconfig_value" && break
6368 cf_gprconfig_param=$cf_gprconfig
6369 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
6371 if test -n "$cf_gprconfig_value"
6373 eval cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value
6374 AC_MSG_RESULT($cf_gprconfig_value)
6376 AC_MSG_RESULT(missing)
6382 rm -rf conftest* *~conftest*
6385 if test "x$cf_ada_config" != "x#"
6388 CF_CHECK_GNAT_VERSION
6389 AC_CHECK_PROG(M4_exists, m4, yes, no)
6390 if test "$ac_cv_prog_M4_exists" = no; then
6391 cf_cv_prog_gnat_correct=no
6392 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
6394 if test "$cf_cv_prog_gnat_correct" = yes; then
6395 AC_MSG_CHECKING(if GNAT works)
6396 CF_GNAT_TRY_RUN([procedure conftest;],
6399 procedure conftest is
6401 Text_IO.Put ("Hello World");
6403 GNAT.OS_Lib.OS_Exit (0);
6405 [cf_cv_prog_gnat_correct=yes],
6406 [cf_cv_prog_gnat_correct=no])
6407 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
6410 cf_cv_prog_gnat_correct=no
6414 AC_SUBST(cf_ada_make)
6415 AC_SUBST(cf_ada_config)
6416 AC_SUBST(cf_ada_config_Ada)
6417 AC_SUBST(cf_ada_config_C)
6419 dnl ---------------------------------------------------------------------------
6420 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
6422 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
6423 dnl misc/tabset install won't work properly. Usually this happens only when
6424 dnl using the fallback mkinstalldirs script
6425 AC_DEFUN([CF_PROG_INSTALL],
6431 CF_DIRNAME(cf_dir,$INSTALL)
6432 test -z "$cf_dir" && cf_dir=.
6433 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
6437 dnl ---------------------------------------------------------------------------
6438 dnl CF_PROG_LDCONFIG version: 5 updated: 2015/04/18 08:56:57
6439 dnl ----------------
6440 dnl Check for ldconfig, needed to fixup shared libraries that would be built
6441 dnl and then used in the install.
6442 AC_DEFUN([CF_PROG_LDCONFIG],[
6443 if test "$cross_compiling" = yes ; then
6446 case "$cf_cv_system_name" in
6447 (dragonfly*|mirbsd*|freebsd*)
6448 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R"
6450 (*) LDPATH=$PATH:/sbin:/usr/sbin
6451 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH)
6457 dnl ---------------------------------------------------------------------------
6458 dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37
6460 AC_DEFUN([CF_PROG_LINT],
6462 AC_CHECK_PROGS(LINT, lint cppcheck splint)
6464 (xcppcheck|x*/cppcheck)
6465 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all"
6470 dnl ---------------------------------------------------------------------------
6471 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
6473 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
6474 dnl option if it is supported.
6475 AC_DEFUN([CF_PROG_LN_S],[
6477 AC_MSG_CHECKING(if $LN_S -f options work)
6479 rm -f conf$$.src conf$$dst
6481 echo first >conf$$.src
6482 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
6487 rm -f conf$$.dst conf$$src
6488 AC_MSG_RESULT($cf_prog_ln_sf)
6490 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
6492 dnl ---------------------------------------------------------------------------
6493 dnl CF_REGEX version: 16 updated: 2020/09/26 19:56:36
6495 dnl Attempt to determine if we've got one of the flavors of regular-expression
6496 dnl code that we can support.
6497 AC_DEFUN([CF_REGEX],
6504 # -lsystre -ltre -lintl -liconv
6505 AC_CHECK_LIB(systre,regcomp,[
6506 AC_CHECK_LIB(iconv,libiconv_open,[CF_ADD_LIB(iconv)])
6507 AC_CHECK_LIB(intl,libintl_gettext,[CF_ADD_LIB(intl)])
6508 AC_CHECK_LIB(tre,tre_regcomp,[CF_ADD_LIB(tre)])
6510 cf_regex_func=regcomp
6512 AC_CHECK_LIB(gnurx,regcomp,[
6514 cf_regex_func=regcomp])
6518 cf_regex_libs="regex re"
6519 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[
6520 for cf_regex_lib in $cf_regex_libs
6522 AC_CHECK_LIB($cf_regex_lib,regcomp,[
6523 CF_ADD_LIB($cf_regex_lib)
6524 cf_regex_func=regcomp
6531 if test "$cf_regex_func" = no ; then
6532 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[
6533 AC_CHECK_LIB(gen,compile,[
6535 cf_regex_func=compile])])
6538 if test "$cf_regex_func" = no ; then
6539 AC_MSG_WARN(cannot find regular expression library)
6542 AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[
6545 case $cf_regex_func in
6547 for cf_regex_hdr in regexp.h regexpr.h
6549 AC_TRY_LINK([#include <$cf_regex_hdr>],[
6550 char *p = compile("", "", "", 0);
6551 int x = step("", "");
6555 cf_cv_regex_hdrs=$cf_regex_hdr
6561 for cf_regex_hdr in regex.h
6563 AC_TRY_LINK([#include <sys/types.h>
6564 #include <$cf_regex_hdr>],[
6566 int x = regcomp(p, "", 0);
6567 int y = regexec(p, "", 0, 0, 0);
6572 cf_cv_regex_hdrs=$cf_regex_hdr
6581 case $cf_cv_regex_hdrs in
6582 (no) AC_MSG_WARN(no regular expression header found) ;;
6583 (regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;;
6584 (regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;;
6585 (regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;;
6588 dnl ---------------------------------------------------------------------------
6589 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
6590 dnl ----------------
6591 dnl Remove all -U and -D options that refer to the given symbol from a list
6592 dnl of C compiler options. This works around the problem that not all
6593 dnl compilers process -U and -D options from left-to-right, so a -U option
6594 dnl cannot be used to cancel the effect of a preceding -D option.
6596 dnl $1 = target (which could be the same as the source variable)
6597 dnl $2 = source (including '$')
6598 dnl $3 = symbol to remove
6599 define([CF_REMOVE_DEFINE],
6602 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
6603 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
6605 dnl ---------------------------------------------------------------------------
6606 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
6608 dnl Remove the given library from the symbol
6610 dnl $1 = target (which could be the same as the source variable)
6611 dnl $2 = source (including '$')
6612 dnl $3 = library to remove
6613 define([CF_REMOVE_LIB],
6615 # remove $3 library from $2
6616 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
6618 dnl ---------------------------------------------------------------------------
6619 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
6620 dnl ---------------------
6621 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
6622 dnl $1 = name of current macro
6623 define([CF_RESTORE_XTRA_FLAGS],
6625 LIBS="$cf_save_LIBS_$1"
6626 CFLAGS="$cf_save_CFLAGS_$1"
6627 CPPFLAGS="$cf_save_CPPFLAGS_$1"
6629 dnl ---------------------------------------------------------------------------
6630 dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00
6632 AC_DEFUN([CF_RPATH_HACK],
6634 AC_REQUIRE([CF_LD_RPATH_OPT])
6635 AC_MSG_CHECKING(for updated LDFLAGS)
6636 if test -n "$LD_RPATH_OPT" ; then
6637 AC_MSG_RESULT(maybe)
6639 AC_CHECK_PROGS(cf_ldd_prog,ldd,no)
6640 cf_rpath_list="/usr/lib /lib"
6641 if test "$cf_ldd_prog" != no
6645 AC_TRY_LINK([#include <stdio.h>],
6647 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq`
6648 cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`])
6650 # If we passed the link-test, but get a "not found" on a given library,
6651 # this could be due to inept reconfiguration of gcc to make it only
6652 # partly honor /usr/local/lib (or whatever). Sometimes this behavior
6653 # is intentional, e.g., installing gcc in /usr/bin and suppressing the
6654 # /usr/local libraries.
6655 if test -n "$cf_rpath_oops"
6657 for cf_rpath_src in $cf_rpath_oops
6659 for cf_rpath_dir in \
6664 if test -f $cf_rpath_dir/lib/$cf_rpath_src
6666 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src)
6667 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib"
6675 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS)
6677 CF_RPATH_HACK_2(LDFLAGS)
6678 CF_RPATH_HACK_2(LIBS)
6680 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS)
6684 AC_SUBST(EXTRA_LDFLAGS)
6686 dnl ---------------------------------------------------------------------------
6687 dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00
6689 dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to
6690 dnl EXTRA_LDFLAGS for each -L option found.
6692 dnl $cf_rpath_list contains a list of directories to ignore.
6694 dnl $1 = variable name to update. The LDFLAGS variable should be the only one,
6695 dnl but LIBS often has misplaced -L options.
6696 AC_DEFUN([CF_RPATH_HACK_2],
6698 CF_VERBOSE(...checking $1 [$]$1)
6701 for cf_rpath_src in [$]$1
6703 case $cf_rpath_src in
6706 # check if this refers to a directory which we will ignore
6708 if test -n "$cf_rpath_list"
6710 for cf_rpath_item in $cf_rpath_list
6712 if test "x$cf_rpath_src" = "x-L$cf_rpath_item"
6720 if test "$cf_rpath_skip" = no
6722 # transform the option
6723 if test "$LD_RPATH_OPT" = "-R " ; then
6724 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"`
6726 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"`
6729 # if we have not already added this, add it now
6730 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"`
6731 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS"
6733 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp)
6734 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS"
6739 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src"
6743 CF_VERBOSE(...checked $1 [$]$1)
6744 AC_SUBST(EXTRA_LDFLAGS)
6746 dnl ---------------------------------------------------------------------------
6747 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
6748 dnl ------------------
6749 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
6750 dnl and libraries which do not update those variables.
6752 dnl $1 = name of current macro
6753 define([CF_SAVE_XTRA_FLAGS],
6755 cf_save_LIBS_$1="$LIBS"
6756 cf_save_CFLAGS_$1="$CFLAGS"
6757 cf_save_CPPFLAGS_$1="$CPPFLAGS"
6758 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
6759 for cf_X_CFLAGS in $X_CFLAGS
6761 case "x$cf_X_CFLAGS" in
6763 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
6766 CFLAGS="$CFLAGS $cf_X_CFLAGS"
6771 dnl ---------------------------------------------------------------------------
6772 dnl CF_SHARED_OPTS version: 102 updated: 2020/08/22 18:17:19
6775 dnl Attempt to determine the appropriate CC/LD options for creating a shared
6779 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
6780 dnl the build-tree, i.e., by making use of the libraries that are compiled in
6781 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
6782 dnl shared library since that can lead to unexpected results at runtime.
6783 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
6784 dnl libraries are compiled in ../../lib
6786 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
6787 dnl to install symbolic links to the rel/abi versions of shared libraries.
6789 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
6790 dnl version when making symbolic links.
6792 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
6793 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
6794 dnl (ex: libncurses.so.<ver>).
6796 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
6797 AC_DEFUN([CF_SHARED_OPTS],
6799 AC_REQUIRE([CF_LD_RPATH_OPT])
6805 INSTALL_LIB="-m 644"
6806 : ${rel_builddir:=.}
6814 cf_cv_do_symlinks=no
6816 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
6818 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
6819 AC_ARG_WITH(shlib-version,
6820 [ --with-shlib-version=X Specify rel or abi version for shared libs],
6821 [test -z "$withval" && withval=auto
6824 cf_cv_shlib_version=auto
6827 cf_cv_shlib_version=$withval
6830 AC_MSG_RESULT($withval)
6831 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
6834 ],[cf_cv_shlib_version=auto])
6835 AC_MSG_RESULT($cf_cv_shlib_version)
6840 # Some less-capable ports of gcc support only -fpic
6844 if test "$GCC" = yes
6848 case $cf_cv_system_name in
6849 (*linux*) # e.g., PGI compiler
6855 if test "$cf_try_fPIC" = yes
6857 AC_MSG_CHECKING(which $CC option to use)
6858 cf_save_CFLAGS="$CFLAGS"
6859 for CC_SHARED_OPTS in -fPIC -fpic ''
6861 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
6862 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
6864 AC_MSG_RESULT($CC_SHARED_OPTS)
6865 CFLAGS="$cf_save_CFLAGS"
6868 cf_cv_shlib_version_infix=no
6870 case $cf_cv_system_name in
6871 (aix4.[3-9]*|aix[[5-7]]*)
6872 if test "$GCC" = yes; then
6873 CC_SHARED_OPTS='-Wl,-brtl'
6874 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
6876 CC_SHARED_OPTS='-brtl'
6877 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
6878 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
6882 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
6886 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
6887 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
6888 cf_cv_shlib_version=cygdll
6889 cf_cv_shlib_version_infix=cygdll
6892 cat >mk_shared_lib.sh <<-CF_EOF
6895 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
6898 Linking shared library
6899 ** SHARED_LIB \[$]SHARED_LIB
6900 ** IMPORT_LIB \[$]IMPORT_LIB
6902 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
6904 chmod +x mk_shared_lib.sh
6908 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
6909 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
6910 cf_cv_shlib_version=msysdll
6911 cf_cv_shlib_version_infix=msysdll
6914 cat >mk_shared_lib.sh <<-CF_EOF
6917 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
6920 Linking shared library
6921 ** SHARED_LIB \[$]SHARED_LIB
6922 ** IMPORT_LIB \[$]IMPORT_LIB
6924 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
6926 chmod +x mk_shared_lib.sh
6929 cf_try_cflags="no-cpp-precomp"
6930 CC_SHARED_OPTS="-dynamic"
6931 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
6932 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
6933 cf_cv_shlib_version_infix=yes
6934 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
6935 cf_save_LDFLAGS=$LDFLAGS
6936 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
6937 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
6938 LDFLAGS=$cf_save_LDFLAGS])
6939 if test $cf_cv_ldflags_search_paths_first = yes; then
6940 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
6944 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
6945 if test "$GCC" != yes; then
6948 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
6949 INSTALL_LIB="-m 555"
6952 # (tested with gcc 2.7.2 -- I don't have c89)
6953 if test "$GCC" = yes; then
6954 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
6957 LD_SHARED_OPTS='-Wl,+b,${libdir}'
6959 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
6960 # HP-UX shared libraries must be executable, and should be
6961 # readonly to exploit a quirk in the memory manager.
6962 INSTALL_LIB="-m 555"
6965 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
6966 if test "$cf_cv_shlib_version" = rel; then
6967 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
6969 cf_shared_soname='`basename $[@]`'
6972 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
6975 if test "$cf_cv_enable_rpath" = yes ; then
6976 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
6978 # tested with IRIX 5.2 and 'cc'.
6979 if test "$GCC" != yes; then
6980 CC_SHARED_OPTS='-KPIC'
6981 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
6983 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
6985 cf_cv_rm_so_locs=yes
6987 (linux*|gnu*|k*bsd*-gnu)
6988 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
6989 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
6990 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
6992 if test "$cf_cv_enable_rpath" = yes ; then
6993 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
6996 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
6999 cf_cv_shlib_version=msvcdll
7000 cf_cv_shlib_version_infix=msvcdll
7003 if test "$DFT_LWR_MODEL" = "shared" ; then
7004 LOCAL_LDFLAGS="-link -dll"
7005 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7006 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
7009 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
7010 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
7011 cat >mk_shared_lib.sh <<-CF_EOF
7014 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
7019 Linking shared library
7020 ** SHARED LIB \$SHARED_LIB
7021 ** IMPORT_LIB \$IMPORT_LIB
7023 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
7024 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
7025 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
7027 chmod +x mk_shared_lib.sh
7028 cat >mk_prog.sh <<-CF_EOF
7031 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
7034 ldopts=("/subsystem:console")
7037 while test \[$]# -gt 0; do
7040 # ignore -link argument
7042 -M[[TD]] | -M[[TD]]d)
7043 # ignore runtime-library option
7058 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
7061 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
7067 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
7068 ldopts+=("\[$]{linkarg}")
7076 ldopts+=("-out:\[$]1")
7085 if [[ "\$isdll" -ne 0 ]]; then
7086 for lib in \[$]{libs[[*]]}; do
7087 ldopts+=("\[$]lib.dll.lib")
7090 for lib in \[$]{libs[[*]]}; do
7091 ldopts+=("\[$]lib.lib")
7096 ** ld options: "\[$]{ldopts[[@]]}"
7098 exec \[$]LD \[$]{ldopts[[@]]}
7101 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
7102 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
7105 cf_cv_shlib_version=mingw
7106 cf_cv_shlib_version_infix=mingw
7109 if test "$DFT_LWR_MODEL" = "shared" ; then
7110 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
7111 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7112 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
7115 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
7116 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
7117 cat >mk_shared_lib.sh <<-CF_EOF
7120 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
7123 Linking shared library
7124 ** SHARED_LIB \[$]SHARED_LIB
7125 ** IMPORT_LIB \[$]IMPORT_LIB
7127 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
7129 chmod +x mk_shared_lib.sh
7131 (openbsd[[2-9]].*|mirbsd*)
7132 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7133 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7134 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7136 if test "$cf_cv_enable_rpath" = yes ; then
7137 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7139 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7141 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7145 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
7149 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
7151 (nto-qnx*|openbsd*|freebsd[[12]].*)
7152 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7153 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
7154 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7156 (dragonfly*|freebsd*)
7157 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7158 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7159 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7160 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
7161 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7164 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
7167 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
7168 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
7169 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
7170 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7171 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
7172 if test "$cf_cv_shlib_version" = auto; then
7173 if test -f /usr/libexec/ld.elf_so; then
7174 cf_cv_shlib_version=abi
7176 cf_cv_shlib_version=rel
7180 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
7182 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
7186 # tested with OSF/1 V3.2 and 'cc'
7187 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
7188 # link with shared libs).
7189 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
7192 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
7195 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
7196 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
7197 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
7198 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7200 cf_cv_rm_so_locs=yes
7202 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
7203 # tested with osr5.0.5
7204 if test "$GCC" != yes; then
7205 CC_SHARED_OPTS='-belf -KPIC'
7207 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
7208 if test "$cf_cv_enable_rpath" = yes ; then
7209 # only way is to set LD_RUN_PATH but no switch for it
7212 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7213 LINK_PROGS='LD_RUN_PATH=${libdir}'
7214 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
7217 # tested with SunOS 4.1.1 and gcc 2.7.0
7218 if test "$GCC" != yes; then
7219 CC_SHARED_OPTS='-KPIC'
7221 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
7222 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
7225 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
7226 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
7227 if test "$DFT_LWR_MODEL" = "shared" ; then
7228 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
7229 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
7231 if test "$cf_cv_enable_rpath" = yes ; then
7232 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
7235 if test "$GCC" != yes; then
7236 cf_save_CFLAGS="$CFLAGS"
7237 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
7239 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
7240 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
7242 CFLAGS="$cf_save_CFLAGS"
7243 CC_SHARED_OPTS=$cf_shared_opts
7244 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7246 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
7249 (sysv5uw7*|unix_sv*)
7250 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
7251 if test "$GCC" != yes; then
7252 CC_SHARED_OPTS='-KPIC'
7254 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
7257 CC_SHARED_OPTS='unknown'
7258 MK_SHARED_LIB='echo unknown'
7262 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
7263 case "$cf_cv_shlib_version" in
7265 case "$MK_SHARED_LIB" in
7267 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
7270 AC_MSG_WARN(ignored --with-shlib-version)
7276 if test -n "$cf_try_cflags"
7278 cat > conftest.$ac_ext <<EOF
7279 #line __oline__ "${as_me:-configure}"
7281 int main(int argc, char *argv[[]])
7284 return (argv[[argc-1]] == 0) ;
7287 cf_save_CFLAGS="$CFLAGS"
7288 for cf_opt in $cf_try_cflags
7290 CFLAGS="$cf_save_CFLAGS -$cf_opt"
7291 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
7292 if AC_TRY_EVAL(ac_compile); then
7294 cf_save_CFLAGS="$CFLAGS"
7299 CFLAGS="$cf_save_CFLAGS"
7303 # RPATH_LIST is a colon-separated list of directories
7304 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
7305 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
7307 test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
7309 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
7310 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
7312 AC_SUBST(CC_SHARED_OPTS)
7313 AC_SUBST(LD_RPATH_OPT)
7314 AC_SUBST(LD_SHARED_OPTS)
7315 AC_SUBST(MK_SHARED_LIB)
7316 AC_SUBST(RM_SHARED_OPTS)
7318 AC_SUBST(LINK_PROGS)
7319 AC_SUBST(LINK_TESTS)
7321 AC_SUBST(EXTRA_LDFLAGS)
7322 AC_SUBST(LOCAL_LDFLAGS)
7323 AC_SUBST(LOCAL_LDFLAGS2)
7325 AC_SUBST(INSTALL_LIB)
7326 AC_SUBST(RPATH_LIST)
7328 dnl ---------------------------------------------------------------------------
7329 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
7330 dnl ----------------
7331 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
7332 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
7335 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
7336 dnl If missing, use "rel".
7337 define([CF_SHARED_SONAME],
7339 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
7340 if test "$cf_cv_shlib_version" = rel; then
7341 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
7343 cf_cv_shared_soname='`basename $[@]`'
7346 dnl ---------------------------------------------------------------------------
7347 dnl CF_SIGWINCH version: 3 updated: 2020/03/10 18:53:47
7349 dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all
7350 dnl programs need this test).
7352 dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE
7353 dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct
7354 dnl winsize declaration is left alone - we may revisit this if Apple choose to
7355 dnl break that part of the interface as well.
7356 AC_DEFUN([CF_SIGWINCH],
7358 AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[
7360 #include <sys/types.h>
7361 #include <sys/signal.h>
7362 ],[int x = SIGWINCH; (void)x],
7363 [cf_cv_define_sigwinch=yes],
7365 #undef _XOPEN_SOURCE
7366 #undef _POSIX_SOURCE
7367 #undef _POSIX_C_SOURCE
7368 #include <sys/types.h>
7369 #include <sys/signal.h>
7370 ],[int x = SIGWINCH; (void)x],
7371 [cf_cv_define_sigwinch=maybe],
7372 [cf_cv_define_sigwinch=no])
7376 if test "$cf_cv_define_sigwinch" = maybe ; then
7377 AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[
7378 cf_cv_fixup_sigwinch=unknown
7380 while test $cf_sigwinch != 1
7383 #undef _XOPEN_SOURCE
7384 #undef _POSIX_SOURCE
7385 #undef _POSIX_C_SOURCE
7386 #include <sys/types.h>
7387 #include <sys/signal.h>
7389 #if SIGWINCH != $cf_sigwinch
7392 int x = SIGWINCH; (void)x],
7393 [cf_cv_fixup_sigwinch=$cf_sigwinch
7396 cf_sigwinch=`expr $cf_sigwinch - 1`
7400 if test "$cf_cv_fixup_sigwinch" != unknown ; then
7401 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch"
7405 dnl ---------------------------------------------------------------------------
7406 dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47
7408 dnl signal handler, but there are some gcc dependencies in that recommendation.
7410 AC_DEFUN([CF_SIG_ATOMIC_T],
7412 AC_MSG_CHECKING(for signal global datatype)
7413 AC_CACHE_VAL(cf_cv_sig_atomic_t,[
7415 "volatile sig_atomic_t" \
7420 #include <sys/types.h>
7426 static void handler(int sig)
7431 [signal(SIGINT, handler);
7433 [cf_cv_sig_atomic_t=$cf_type],
7434 [cf_cv_sig_atomic_t=no])
7435 test "$cf_cv_sig_atomic_t" != no && break
7438 AC_MSG_RESULT($cf_cv_sig_atomic_t)
7439 test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype])
7441 dnl ---------------------------------------------------------------------------
7442 dnl CF_SIZECHANGE version: 16 updated: 2020/03/19 20:46:13
7444 dnl Check for definitions & structures needed for window size-changing
7446 dnl https://stackoverflow.com/questions/18878141/difference-between-structures-ttysize-and-winsize/50769952#50769952
7447 AC_DEFUN([CF_SIZECHANGE],
7449 AC_REQUIRE([CF_STRUCT_TERMIOS])
7450 AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[
7451 cf_cv_sizechange=unknown
7452 cf_save_CPPFLAGS="$CPPFLAGS"
7454 for cf_opts in "" "NEED_PTEM_H"
7457 CPPFLAGS="$cf_save_CPPFLAGS"
7458 if test -n "$cf_opts"
7460 CF_APPEND_TEXT(CPPFLAGS,-D$cf_opts)
7462 AC_TRY_COMPILE([#include <sys/types.h>
7463 #ifdef HAVE_TERMIOS_H
7464 #include <termios.h>
7466 #ifdef HAVE_TERMIO_H
7472 /* This is a workaround for SCO: they neglected to define struct winsize in
7473 * termios.h -- it's only in termio.h and ptem.h
7475 #include <sys/stream.h>
7476 #include <sys/ptem.h>
7479 #ifdef HAVE_SYS_IOCTL_H
7480 #include <sys/ioctl.h>
7484 struct ttysize win; /* SunOS 3.0... */
7485 int y = win.ts_lines = 2;
7486 int x = win.ts_cols = 1;
7491 struct winsize win; /* everything else */
7492 int y = win.ws_row = 2;
7493 int x = win.ws_col = 1;
7497 no TIOCGSIZE or TIOCGWINSZ
7498 #endif /* TIOCGWINSZ */
7499 #endif /* TIOCGSIZE */
7501 [cf_cv_sizechange=yes],
7502 [cf_cv_sizechange=no])
7504 CPPFLAGS="$cf_save_CPPFLAGS"
7505 if test "$cf_cv_sizechange" = yes ; then
7506 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC
7507 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts"
7512 if test "$cf_cv_sizechange" != no ; then
7513 AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechange declarations are provided])
7514 case $cf_cv_sizechange in
7516 AC_DEFINE_UNQUOTED($cf_cv_sizechange )
7521 dnl ---------------------------------------------------------------------------
7522 dnl CF_SRC_MODULES version: 32 updated: 2020/03/07 20:05:14
7524 dnl For each parameter, test if the source-directory exists, and if it contains
7525 dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll
7526 dnl use in CF_LIB_RULES.
7528 dnl This uses the configured value to make the lists SRC_SUBDIRS and
7529 dnl SUB_MAKEFILES which are used in the makefile-generation scheme.
7530 AC_DEFUN([CF_SRC_MODULES],
7532 AC_REQUIRE([CF_CHECK_GNAT_VERSION])
7533 AC_MSG_CHECKING(for src modules)
7535 # dependencies and linker-arguments for test-programs
7536 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS"
7537 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2"
7538 if test "$DFT_LWR_MODEL" = "libtool"; then
7539 TEST_ARGS="${TEST_DEPS}"
7540 TEST_ARG2="${TEST_DEP2}"
7542 TEST_ARGS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS"
7543 TEST_ARG2="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARG2"
7546 PC_MODULES_TO_MAKE="ncurses${USE_ARG_SUFFIX}"
7550 if test -f $srcdir/$cf_dir/modules; then
7552 # We may/may not have tack in the distribution, though the
7554 if test $cf_dir = tack ; then
7555 if test "x$cf_with_tack" != "xyes"; then
7560 if test -z "$cf_cv_src_modules"; then
7561 cf_cv_src_modules=$cf_dir
7563 cf_cv_src_modules="$cf_cv_src_modules $cf_dir"
7566 # Make the ncurses_cfg.h file record the library interface files as
7567 # well. These are header files that are the same name as their
7568 # directory. Ncurses is the only library that does not follow
7570 if test $cf_dir = tack ; then
7572 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then
7573 CF_UPPER(cf_have_include,$cf_dir)
7574 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H)
7575 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include})
7576 CF_MAP_LIB_BASENAME(TEST_ROOT,$cf_dir)
7577 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEPS"
7578 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEP2"
7579 if test "$DFT_LWR_MODEL" = "libtool"; then
7580 TEST_ARGS="${TEST_DEPS}"
7581 TEST_ARG2="${TEST_DEP2}"
7583 TEST_ARGS="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARGS"
7584 TEST_ARG2="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARG2"
7586 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${USE_ARG_SUFFIX}"
7590 AC_MSG_RESULT($cf_cv_src_modules)
7592 TEST_ARGS="-L${LIB_DIR} $TEST_ARGS"
7593 TEST_ARG2="-L${LIB_2ND} $TEST_ARG2"
7602 if test "x$cf_with_manpages" != xno ; then
7603 SRC_SUBDIRS="$SRC_SUBDIRS man"
7605 SRC_SUBDIRS="$SRC_SUBDIRS include"
7606 for cf_dir in $cf_cv_src_modules
7608 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir"
7610 if test "x$cf_with_tests" != "xno" ; then
7611 SRC_SUBDIRS="$SRC_SUBDIRS test"
7613 # always make this, to install the ncurses-config script
7614 SRC_SUBDIRS="$SRC_SUBDIRS misc"
7615 if test "$cf_with_cxx_binding" != no; then
7616 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${USE_ARG_SUFFIX}"
7617 SRC_SUBDIRS="$SRC_SUBDIRS c++"
7620 test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX"
7621 test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX"
7623 AC_SUBST(PC_MODULES_TO_MAKE)
7626 if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f $srcdir/Ada95/Makefile.in; then
7627 SRC_SUBDIRS="$SRC_SUBDIRS Ada95"
7628 ADA_SUBDIRS="gen src"
7629 if test "x$cf_with_tests" != "xno" ; then
7630 ADA_SUBDIRS="$ADA_SUBDIRS samples"
7635 for cf_dir in $SRC_SUBDIRS
7637 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile"
7640 if test -n "$ADA_SUBDIRS"; then
7641 for cf_dir in $ADA_SUBDIRS
7643 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile"
7645 AC_SUBST(ADA_SUBDIRS)
7648 dnl ---------------------------------------------------------------------------
7649 dnl CF_STDCPP_LIBRARY version: 11 updated: 2015/10/17 19:03:33
7650 dnl -----------------
7651 dnl Check for -lstdc++, which is GNU's standard C++ library.
7652 dnl If $CXXLIBS is set, add that to the libraries used for test-linking.
7653 dnl If -lstdc++ was not already added to $LIBS or $CXXLIBS, and is needed,
7654 dnl add it to $CXXLIBS.
7655 AC_DEFUN([CF_STDCPP_LIBRARY],
7657 if test -n "$GXX" ; then
7660 LIBS="$LIBS $CXXLIBS"
7661 AC_MSG_CHECKING(if we already have C++ library)
7663 #include <iostream>],[
7664 std::cout << "Hello World!" << std::endl;],
7665 [cf_have_libstdcpp=yes],
7666 [cf_have_libstdcpp=no])
7667 AC_MSG_RESULT($cf_have_libstdcpp)
7670 if test $cf_have_libstdcpp != yes
7672 case $cf_cv_system_name in
7674 if test -z "`g++ -dM -E - < /dev/null | grep __KLIBC__`"; then
7675 cf_stdcpp_libname=stdcpp
7677 cf_stdcpp_libname=stdc++
7681 cf_stdcpp_libname=stdc++
7685 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[
7687 LIBS="$LIBS $CXXLIBS"
7688 CF_ADD_LIB($cf_stdcpp_libname)
7690 #include <iostream>],[
7691 std::cout << "Hello World!" << std::endl;],
7692 [cf_cv_libstdcpp=yes],
7693 [cf_cv_libstdcpp=no])
7696 test "$cf_cv_libstdcpp" = yes && { CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS) }
7700 dnl ---------------------------------------------------------------------------
7701 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
7703 dnl Remove "-g" option from the compiler options
7704 AC_DEFUN([CF_STRIP_G_OPT],
7705 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
7706 dnl ---------------------------------------------------------------------------
7707 dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13
7708 dnl -------------------
7709 dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only
7710 dnl do this if we've found the sigaction function.
7711 AC_DEFUN([CF_STRUCT_SIGACTION],[
7712 AC_REQUIRE([CF_XOPEN_SOURCE])
7714 if test "$ac_cv_func_sigaction" = yes; then
7715 AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE)
7717 #include <sys/types.h>
7718 #include <signal.h>],
7719 [struct sigaction act],
7723 #define _POSIX_SOURCE
7724 #include <sys/types.h>
7725 #include <signal.h>],
7726 [struct sigaction act],
7728 AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])],
7729 [sigact_bad=unknown])])
7730 AC_MSG_RESULT($sigact_bad)
7733 dnl ---------------------------------------------------------------------------
7734 dnl CF_STRUCT_TERMIOS version: 11 updated: 2020/03/19 20:46:13
7735 dnl -----------------
7736 dnl Some machines require _POSIX_SOURCE to completely define struct termios.
7737 AC_DEFUN([CF_STRUCT_TERMIOS],[
7738 AC_REQUIRE([CF_XOPEN_SOURCE])
7748 if test "$ac_cv_header_termios_h" = yes ; then
7749 case "$CFLAGS $CPPFLAGS" in
7751 termios_bad=dunno ;;
7752 (*) termios_bad=maybe ;;
7754 if test "$termios_bad" = maybe ; then
7755 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE)
7756 AC_TRY_COMPILE([#include <termios.h>],
7757 [struct termios foo; int x = foo.c_iflag = 1; (void)x],
7760 #define _POSIX_SOURCE
7761 #include <termios.h>],
7762 [struct termios foo; int x = foo.c_iflag = 2; (void)x],
7763 termios_bad=unknown,
7764 termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE]))
7766 AC_MSG_RESULT($termios_bad)
7770 dnl ---------------------------------------------------------------------------
7771 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
7773 dnl Construct a search-list for a nonstandard header/lib-file
7774 dnl $1 = the variable to return as result
7775 dnl $2 = the package name
7776 dnl $3 = the subdirectory, e.g., bin, include or lib
7777 AC_DEFUN([CF_SUBDIR_PATH],
7781 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
7783 for cf_subdir_prefix in \
7791 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
7794 dnl ---------------------------------------------------------------------------
7795 dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03
7797 dnl Shorthand macro for substituting things that the user may override
7798 dnl with an environment variable.
7800 dnl $1 = condition to pass to "test"
7801 dnl $2 = environment variable
7802 dnl $3 = value if the test succeeds
7803 dnl $4 = value if the test fails
7804 AC_DEFUN([CF_SUBST_IF],
7813 dnl ---------------------------------------------------------------------------
7814 dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59
7815 dnl ------------------------
7816 dnl Get the version-number for use in shared-library naming, etc.
7817 AC_DEFUN([CF_SUBST_NCURSES_VERSION],
7819 AC_REQUIRE([CF_PROG_EGREP])
7820 NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
7821 NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
7822 NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`"
7823 cf_cv_abi_version=${NCURSES_MAJOR}
7824 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
7825 dnl Show the computed version, for logging
7826 cf_cv_timestamp=`date`
7827 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
7828 dnl We need these values in the generated headers
7829 AC_SUBST(NCURSES_MAJOR)
7830 AC_SUBST(NCURSES_MINOR)
7831 AC_SUBST(NCURSES_PATCH)
7832 dnl We need these values in the generated makefiles
7833 AC_SUBST(cf_cv_rel_version)
7834 AC_SUBST(cf_cv_abi_version)
7835 AC_SUBST(cf_cv_builtin_bool)
7836 AC_SUBST(cf_cv_header_stdbool_h)
7837 AC_SUBST(cf_cv_type_of_bool)dnl
7839 dnl ---------------------------------------------------------------------------
7840 dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57
7841 dnl ------------------
7842 dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on
7843 dnl older SCO configurations.
7844 AC_DEFUN([CF_SYS_TIME_SELECT],
7846 AC_MSG_CHECKING(if sys/time.h works with sys/select.h)
7847 AC_CACHE_VAL(cf_cv_sys_time_select,[
7849 #include <sys/types.h>
7850 #ifdef HAVE_SYS_TIME_H
7851 #include <sys/time.h>
7853 #ifdef HAVE_SYS_SELECT_H
7854 #include <sys/select.h>
7856 ],[],[cf_cv_sys_time_select=yes],
7857 [cf_cv_sys_time_select=no])
7859 AC_MSG_RESULT($cf_cv_sys_time_select)
7860 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>])
7862 dnl ---------------------------------------------------------------------------
7863 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
7865 dnl Define a top_builddir symbol, for applications that need an absolute path.
7866 AC_DEFUN([CF_TOP_BUILDDIR],
7868 top_builddir=ifelse($1,,`pwd`,$1)
7869 AC_SUBST(top_builddir)
7871 dnl ---------------------------------------------------------------------------
7872 dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06
7873 dnl -----------------
7874 dnl This is a simple wrapper to use for pkg-config, for libraries which may be
7875 dnl available in that form.
7877 dnl $1 = package name
7878 dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS
7879 dnl $3 = logic to use if pkg-config does not have the package
7880 AC_DEFUN([CF_TRY_PKG_CONFIG],[
7881 AC_REQUIRE([CF_PKG_CONFIG])
7883 if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then
7884 CF_VERBOSE(found package $1)
7885 cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`"
7886 cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`"
7887 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs)
7888 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs)
7889 CF_ADD_CFLAGS($cf_pkgconfig_incs)
7890 CF_ADD_LIBS($cf_pkgconfig_libs)
7891 ifelse([$2],,:,[$2])
7895 ifelse([$3],,:,[$3])
7898 dnl ---------------------------------------------------------------------------
7899 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
7900 dnl -------------------
7901 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
7902 dnl can define it successfully.
7903 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
7904 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
7908 #include <sys/types.h>
7910 #ifndef _XOPEN_SOURCE
7913 [cf_cv_xopen_source=no],
7914 [cf_save="$CPPFLAGS"
7915 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
7919 #include <sys/types.h>
7921 #ifdef _XOPEN_SOURCE
7924 [cf_cv_xopen_source=no],
7925 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
7930 if test "$cf_cv_xopen_source" != no ; then
7931 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
7932 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
7933 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
7934 CF_ADD_CFLAGS($cf_temp_xopen_source)
7937 dnl ---------------------------------------------------------------------------
7938 dnl CF_TYPEOF_CHTYPE version: 10 updated: 2017/01/21 11:06:25
7939 dnl ----------------
7940 dnl Determine the type we should use for chtype (and attr_t, which is treated
7941 dnl as the same thing). We want around 32 bits, so on most machines want a
7942 dnl long, but on newer 64-bit machines, probably want an int. If we're using
7943 dnl wide characters, we have to have a type compatible with that, as well.
7944 AC_DEFUN([CF_TYPEOF_CHTYPE],
7946 AC_MSG_CHECKING([for type of chtype])
7947 AC_CACHE_VAL(cf_cv_typeof_chtype,[
7949 #define WANT_BITS 31
7953 FILE *fp = fopen("cf_test.out", "w");
7955 char *result = "long";
7956 if (sizeof(unsigned long) > sizeof(unsigned int)) {
7959 for (n = 0; n < WANT_BITS; n++) {
7962 if (y != 1 || x == 0) {
7968 * If x is nonzero, an int is big enough for the bits
7971 result = (x != 0) ? "int" : "long";
7976 ${cf_cv_main_return:-return}(0);
7979 [cf_cv_typeof_chtype=`cat cf_test.out`],
7980 [cf_cv_typeof_chtype=long],
7981 [cf_cv_typeof_chtype=long])
7984 AC_MSG_RESULT($cf_cv_typeof_chtype)
7986 AC_SUBST(cf_cv_typeof_chtype)
7987 AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype])
7989 dnl ---------------------------------------------------------------------------
7990 dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13
7991 dnl -----------------
7993 AC_DEFUN([CF_TYPE_SIGACTION],
7995 AC_MSG_CHECKING([for type sigaction_t])
7996 AC_CACHE_VAL(cf_cv_type_sigaction,[
7998 #include <signal.h>],
8000 [cf_cv_type_sigaction=yes],
8001 [cf_cv_type_sigaction=no])])
8002 AC_MSG_RESULT($cf_cv_type_sigaction)
8003 test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type])
8005 dnl ---------------------------------------------------------------------------
8006 dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16
8007 dnl --------------------
8008 dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers
8009 dnl won't, but they're still there.
8010 AC_DEFUN([CF_UNSIGNED_LITERALS],
8012 AC_MSG_CHECKING([if unsigned literals are legal])
8013 AC_CACHE_VAL(cf_cv_unsigned_literals,[
8014 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1],
8015 [cf_cv_unsigned_literals=yes],
8016 [cf_cv_unsigned_literals=no])
8018 AC_MSG_RESULT($cf_cv_unsigned_literals)
8020 dnl ---------------------------------------------------------------------------
8021 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
8023 dnl Make an uppercase version of a variable
8024 dnl $1=uppercase($2)
8025 AC_DEFUN([CF_UPPER],
8027 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
8029 dnl ---------------------------------------------------------------------------
8030 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
8032 dnl Check for multibyte support, and if not found, utf8 compatibility library
8033 AC_DEFUN([CF_UTF8_LIB],
8035 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
8036 cf_save_LIBS="$LIBS"
8038 #include <stdlib.h>],[putwc(0,0);],
8039 [cf_cv_utf8_lib=yes],
8041 #include <libutf8.h>],[putwc(0,0);],utf8,
8042 [cf_cv_utf8_lib=add-on],
8043 [cf_cv_utf8_lib=no])
8046 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
8048 if test "$cf_cv_utf8_lib" = "add-on" ; then
8049 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
8050 CF_ADD_INCDIR($cf_cv_header_path_utf8)
8051 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
8052 CF_ADD_LIBS($cf_cv_library_file_utf8)
8055 dnl ---------------------------------------------------------------------------
8056 dnl CF_VA_COPY version: 6 updated: 2018/12/04 18:14:25
8058 dnl check for va_copy, part of stdarg.h starting with ISO C 1999.
8059 dnl Also, workaround for glibc's __va_copy, by checking for both.
8060 dnl Finally, try to accommodate pre-ISO C 1999 headers.
8061 AC_DEFUN([CF_VA_COPY],[
8062 AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[
8069 cf_cv_have_va_copy=yes,
8070 cf_cv_have_va_copy=no)])
8072 if test "$cf_cv_have_va_copy" = yes;
8074 AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy])
8075 else # !cf_cv_have_va_copy
8077 AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[
8083 __va_copy(dst, src)],
8084 cf_cv_have___va_copy=yes,
8085 cf_cv_have___va_copy=no)])
8087 if test "$cf_cv_have___va_copy" = yes
8089 AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy])
8090 else # !cf_cv_have___va_copy
8092 AC_CACHE_CHECK(for __builtin_va_copy, cf_cv_have___builtin_va_copy,[
8098 __builtin_va_copy(dst, src)],
8099 cf_cv_have___builtin_va_copy=yes,
8100 cf_cv_have___builtin_va_copy=no)])
8102 test "$cf_cv_have___builtin_va_copy" = yes &&
8103 AC_DEFINE(HAVE___BUILTIN_VA_COPY,1,[Define to 1 if we have __builtin_va_copy])
8105 fi # cf_cv_have___va_copy
8107 fi # cf_cv_have_va_copy
8109 case "${cf_cv_have_va_copy}${cf_cv_have___va_copy}${cf_cv_have___builtin_va_copy}" in
8114 AC_CACHE_CHECK(if we can simply copy va_list, cf_cv_pointer_va_list,[
8121 cf_cv_pointer_va_list=yes,
8122 cf_cv_pointer_va_list=no)])
8124 if test "$cf_cv_pointer_va_list" = no
8126 AC_CACHE_CHECK(if we can copy va_list indirectly, cf_cv_array_va_list,[
8133 cf_cv_array_va_list=yes,
8134 cf_cv_array_va_list=no)])
8135 test "$cf_cv_array_va_list" = yes && AC_DEFINE(ARRAY_VA_LIST,1,[Define to 1 if we can copy va_list indirectly])
8140 dnl ---------------------------------------------------------------------------
8141 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
8143 dnl Use AC_VERBOSE w/o the warnings
8144 AC_DEFUN([CF_VERBOSE],
8145 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
8148 dnl ---------------------------------------------------------------------------
8149 dnl CF_VERSION_INFO version: 7 updated: 2015/04/17 21:13:04
8151 dnl Define several useful symbols derived from the VERSION file. A separate
8152 dnl file is preferred to embedding the version numbers in various scripts.
8153 dnl (automake is a textbook-example of why the latter is a bad idea, but there
8156 dnl The file contents are:
8157 dnl libtool-version release-version patch-version
8161 dnl libtool-version (see ?) consists of 3 integers separated by '.'
8162 dnl release-version consists of a major version and minor version
8163 dnl separated by '.', optionally followed by a patch-version
8164 dnl separated by '-'. The minor version need not be an
8165 dnl integer (but it is preferred).
8166 dnl patch-version is an integer in the form yyyymmdd, so ifdef's and
8167 dnl scripts can easily compare versions.
8169 dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL
8170 dnl simply extracts the first field using 'cut -f1'.
8172 dnl Optional parameters:
8173 dnl $1 = internal name for package
8174 dnl $2 = external name for package
8175 AC_DEFUN([CF_VERSION_INFO],
8177 if test -f $srcdir/VERSION ; then
8178 AC_MSG_CHECKING(for package version)
8180 # if there are not enough fields, cut returns the last one...
8181 cf_field1=`sed -e '2,$d' $srcdir/VERSION|cut -f1`
8182 cf_field2=`sed -e '2,$d' $srcdir/VERSION|cut -f2`
8183 cf_field3=`sed -e '2,$d' $srcdir/VERSION|cut -f3`
8185 # this is how CF_BUNDLED_INTL uses $VERSION:
8186 VERSION="$cf_field1"
8188 VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'`
8189 test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version)
8191 VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'`
8192 test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version)
8194 AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR})
8196 AC_MSG_CHECKING(for package patch date)
8197 VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'`
8198 case .$VERSION_PATCH in
8200 AC_MSG_ERROR(missing patch-date $VERSION_PATCH)
8202 (.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]])
8205 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH)
8208 AC_MSG_RESULT($VERSION_PATCH)
8210 AC_MSG_ERROR(did not find $srcdir/VERSION)
8213 # show the actual data that we have for versions:
8214 CF_VERBOSE(ABI VERSION $VERSION)
8215 CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR)
8216 CF_VERBOSE(VERSION_MINOR $VERSION_MINOR)
8217 CF_VERBOSE(VERSION_PATCH $VERSION_PATCH)
8220 AC_SUBST(VERSION_MAJOR)
8221 AC_SUBST(VERSION_MINOR)
8222 AC_SUBST(VERSION_PATCH)
8224 dnl if a package name is given, define its corresponding version info. We
8225 dnl need the package name to ensure that the defined symbols are unique.
8228 PACKAGE=ifelse($2,,$1,$2)
8229 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name])
8231 CF_UPPER(cf_PACKAGE,$cf_PACKAGE)
8232 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}")
8233 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH})
8236 dnl ---------------------------------------------------------------------------
8237 dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58
8239 dnl Check if type wide-character type $1 is declared, and if so, which header
8240 dnl file is needed. The second parameter is used to set a shell variable when
8241 dnl the type is not found. The first parameter sets a shell variable for the
8243 AC_DEFUN([CF_WCHAR_TYPE],
8245 # This is needed on Tru64 5.0 to declare $1
8246 AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[
8251 #ifdef HAVE_LIBUTF8_H
8252 #include <libutf8.h>
8261 #ifdef HAVE_LIBUTF8_H
8262 #include <libutf8.h>
8266 [cf_cv_$1=unknown])])])
8268 if test "$cf_cv_$1" = yes ; then
8269 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h])
8274 # if we do not find $1 in either place, use substitution to provide a fallback.
8275 if test "$cf_cv_$1" = unknown ; then
8280 # if we find $1 in either place, use substitution to provide a fallback.
8281 if test "$cf_cv_$1" != unknown ; then
8286 dnl ---------------------------------------------------------------------------
8287 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
8289 dnl Check for compiler-support for weak symbols.
8290 dnl This works with "recent" gcc.
8291 AC_DEFUN([CF_WEAK_SYMBOLS],[
8292 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
8295 #include <stdio.h>],
8297 #if defined(__GNUC__)
8298 # if defined __USE_ISOC99
8299 # define _cat_pragma(exp) _Pragma(#exp)
8300 # define _weak_pragma(exp) _cat_pragma(weak name)
8302 # define _weak_pragma(exp)
8304 # define _declare(name) __extension__ extern __typeof__(name) name
8305 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
8309 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
8312 dnl ---------------------------------------------------------------------------
8313 dnl CF_WITH_ABI_VERSION version: 3 updated: 2015/06/06 16:10:11
8314 dnl -------------------
8315 dnl Allow library's ABI to be overridden. Generally this happens when a
8316 dnl packager has incremented the ABI past that used in the original package,
8317 dnl and wishes to keep doing this.
8319 dnl $1 is the package name, if any, to derive a corresponding {package}_ABI
8321 AC_DEFUN([CF_WITH_ABI_VERSION],[
8322 test -z "$cf_cv_abi_version" && cf_cv_abi_version=0
8323 AC_ARG_WITH(abi-version,
8324 [ --with-abi-version=XXX override derived ABI version],[
8325 if test "x$cf_cv_abi_version" != "x$withval"
8327 AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval)
8328 case $cf_cv_rel_version in
8330 cf_cv_rel_version=$withval.0
8333 cf_cv_rel_version=$withval.9 # FIXME: should be 10 as of 6.0 release
8337 cf_cv_abi_version=$withval])
8338 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version)
8340 $1_ABI=$cf_cv_abi_version
8343 dnl ---------------------------------------------------------------------------
8344 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
8345 dnl --------------------
8346 dnl Command-line option to specify the Ada95 compiler.
8347 AC_DEFUN([CF_WITH_ADA_COMPILER],[
8348 AC_MSG_CHECKING(for ada-compiler)
8349 AC_ARG_WITH(ada-compiler,
8350 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
8351 [cf_ada_compiler=$withval],
8352 [cf_ada_compiler=gnatmake])
8353 AC_SUBST(cf_ada_compiler)
8354 AC_MSG_RESULT($cf_ada_compiler)
8356 dnl ---------------------------------------------------------------------------
8357 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
8358 dnl -------------------
8359 dnl Command-line option to specify where Ada includes will install.
8360 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
8361 AC_MSG_CHECKING(for ada-include)
8362 CF_WITH_PATH(ada-include,
8363 [ --with-ada-include=DIR Ada includes are in DIR],
8365 PREFIX/share/ada/adainclude,
8366 [$]prefix/share/ada/adainclude)
8367 AC_SUBST(ADA_INCLUDE)
8368 AC_MSG_RESULT($ADA_INCLUDE)
8370 dnl ---------------------------------------------------------------------------
8371 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
8372 dnl -------------------
8373 dnl CF_WITH_ADA_LIBNAME
8374 dnl -------------------
8375 dnl Command-line option to specify how to name the resulting Ada library.
8376 dnl $1 = default value
8377 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
8378 AC_MSG_CHECKING(for ada-libname)
8379 AC_ARG_WITH(ada-libname,
8380 [ --with-ada-libname=XXX override default Ada library-name],
8381 ADA_LIBNAME=[$]withval,
8383 case "x$ADA_LIBNAME" in
8388 AC_SUBST(ADA_LIBNAME)
8389 AC_MSG_RESULT($ADA_LIBNAME)
8391 dnl ---------------------------------------------------------------------------
8392 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
8393 dnl -------------------
8394 dnl Command-line option to specify where Ada objects will install.
8395 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
8396 AC_MSG_CHECKING(for ada-objects)
8397 CF_WITH_PATH(ada-objects,
8398 [ --with-ada-objects=DIR Ada objects are in DIR],
8400 PREFIX/lib/ada/adalib,
8401 [$]prefix/lib/ada/adalib)
8402 AC_SUBST(ADA_OBJECTS)
8403 AC_MSG_RESULT($ADA_OBJECTS)
8405 dnl ---------------------------------------------------------------------------
8406 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
8407 dnl ---------------------
8408 dnl Command-line option to specify if an Ada95 shared-library should be built,
8409 dnl and optionally what its soname should be.
8410 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
8411 AC_REQUIRE([CF_GNAT_PROJECTS])
8412 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
8413 AC_ARG_WITH(ada-sharedlib,
8414 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
8415 [with_ada_sharedlib=$withval],
8416 [with_ada_sharedlib=no])
8417 AC_MSG_RESULT($with_ada_sharedlib)
8419 if test "x$with_ada_sharedlib" != xno
8421 if test "x$cf_gnat_projects" != xyes
8423 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
8424 with_ada_sharedlib=no
8428 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
8429 MAKE_ADA_SHAREDLIB="#"
8431 if test "x$with_ada_sharedlib" != xno
8434 if test "x$with_ada_sharedlib" != xyes
8436 ADA_SHAREDLIB="$with_ada_sharedlib"
8440 AC_SUBST(ADA_SHAREDLIB)
8441 AC_SUBST(MAKE_ADA_SHAREDLIB)
8443 dnl ---------------------------------------------------------------------------
8444 dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47
8445 dnl ----------------
8446 dnl Configure-option for dbmalloc. The optional parameter is used to override
8447 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
8448 AC_DEFUN([CF_WITH_DBMALLOC],[
8449 CF_NO_LEAKS_OPTION(dbmalloc,
8450 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library],
8453 if test "$with_dbmalloc" = yes ; then
8454 AC_CHECK_HEADER(dbmalloc.h,
8455 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))])
8458 dnl ---------------------------------------------------------------------------
8459 dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47
8461 dnl Configure-option for dmalloc. The optional parameter is used to override
8462 dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests.
8463 AC_DEFUN([CF_WITH_DMALLOC],[
8464 CF_NO_LEAKS_OPTION(dmalloc,
8465 [ --with-dmalloc test: use Gray Watson's dmalloc library],
8468 if test "$with_dmalloc" = yes ; then
8469 AC_CHECK_HEADER(dmalloc.h,
8470 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))])
8473 dnl ---------------------------------------------------------------------------
8474 dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08
8475 dnl -------------------
8476 dnl Use this with libtool to specify the list of symbols that may be exported.
8477 dnl The input file contains one symbol per line; comments work with "#".
8479 dnl $1 = basename of the ".sym" file (default $PACKAGE)
8480 AC_DEFUN([CF_WITH_EXPORT_SYMS],
8482 AC_MSG_CHECKING(if exported-symbols file should be used)
8483 AC_ARG_WITH(export-syms,
8484 [ --with-export-syms=XXX limit exported symbols using libtool],
8485 [with_export_syms=$withval],
8486 [with_export_syms=no])
8487 if test "x$with_export_syms" = xyes
8489 with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym'
8492 AC_MSG_RESULT($with_export_syms)
8493 if test "x$with_export_syms" != xno
8495 EXPORT_SYMS="-export-symbols $with_export_syms"
8496 AC_SUBST(EXPORT_SYMS)
8499 dnl ---------------------------------------------------------------------------
8500 dnl CF_WITH_GPM version: 10 updated: 2017/04/29 18:32:18
8503 dnl The option parameter (if neither yes/no) is assumed to be the name of
8504 dnl the gpm library, e.g., for dynamic loading.
8505 AC_DEFUN([CF_WITH_GPM],
8507 AC_MSG_CHECKING(if you want to link with the GPM mouse library)
8509 [ --with-gpm use Alessandro Rubini's GPM library],
8510 [with_gpm=$withval],
8512 AC_MSG_RESULT($with_gpm)
8514 if test "$with_gpm" != no ; then
8515 AC_CHECK_HEADER(gpm.h,[
8516 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header])
8517 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then
8518 CF_VERBOSE(assuming we really have GPM library)
8519 AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library])
8522 AC_CHECK_LIB(gpm,Gpm_Open,[with_gpm=yes],[
8523 if test "$with_gpm" = maybe; then
8524 AC_MSG_WARN(Cannot link with GPM library)
8527 AC_MSG_ERROR(Cannot link with GPM library)
8532 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header)
8537 dnl ---------------------------------------------------------------------------
8538 dnl CF_WITH_LIBTOOL version: 35 updated: 2017/08/12 07:58:51
8540 dnl Provide a configure option to incorporate libtool. Define several useful
8541 dnl symbols for the makefile rules.
8543 dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses
8544 dnl macros from libtool.m4 which is in the aclocal directory of automake.
8545 dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro.
8546 dnl But that still does not work properly since the macro is expanded outside
8547 dnl the CF_WITH_LIBTOOL macro:
8550 dnl ACLOCAL=`aclocal --print-ac-dir`
8551 dnl if test -z "$ACLOCAL" ; then
8552 dnl echo cannot find aclocal directory
8554 dnl elif test ! -f $ACLOCAL/libtool.m4 ; then
8555 dnl echo cannot find libtool.m4 file
8559 dnl LOCAL=aclocal.m4
8560 dnl ORIG=aclocal.m4.orig
8562 dnl trap "mv $ORIG $LOCAL" 0 1 2 3 15
8566 dnl # sed the LIBTOOL= assignment to omit the current directory?
8567 dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL
8568 dnl cat $ORIG >>$LOCAL
8572 AC_DEFUN([CF_WITH_LIBTOOL],
8574 AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION])
8575 ifdef([AC_PROG_LIBTOOL],,[
8578 # common library maintenance symbols that are convenient for libtool scripts:
8579 LIB_CREATE='${AR} -cr'
8580 LIB_OBJECT='${OBJECTS}'
8584 # symbols used to prop libtool up to enable it to determine what it should be
8592 AC_MSG_CHECKING(if you want to build libraries with libtool)
8593 AC_ARG_WITH(libtool,
8594 [ --with-libtool generate libraries with libtool],
8595 [with_libtool=$withval],
8597 AC_MSG_RESULT($with_libtool)
8598 if test "$with_libtool" != "no"; then
8599 ifdef([AC_PROG_LIBTOOL],[
8600 # missing_content_AC_PROG_LIBTOOL{{
8602 # missing_content_AC_PROG_LIBTOOL}}
8604 if test "$with_libtool" != "yes" ; then
8605 CF_PATH_SYNTAX(with_libtool)
8606 LIBTOOL=$with_libtool
8608 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none)
8610 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool
8612 CF_FORGET_TOOL(LIBTOOL)
8613 AC_CHECK_TOOLS(LIBTOOL,[glibtool],none)
8617 if test -z "$LIBTOOL" ; then
8618 AC_MSG_ERROR(Cannot find libtool)
8621 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o'
8622 LIB_OBJECT='${OBJECTS:.o=.lo}'
8624 LIB_CLEAN='${LIBTOOL} --mode=clean'
8625 LIB_COMPILE='${LIBTOOL} --mode=compile'
8626 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}'
8627 LIB_INSTALL='${LIBTOOL} --mode=install'
8628 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall'
8631 CF_CHECK_LIBTOOL_VERSION
8633 # special hack to add -no-undefined (which libtool should do for itself)
8635 case "$cf_cv_system_name" in
8636 (cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]])
8637 LT_UNDEF=-no-undefined
8640 AC_SUBST([LT_UNDEF])
8642 # special hack to add --tag option for C++ compiler
8643 case $cf_cv_libtool_version in
8644 (1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*)
8645 LIBTOOL_CXX="$LIBTOOL --tag=CXX"
8646 LIBTOOL="$LIBTOOL --tag=CC"
8649 LIBTOOL_CXX="$LIBTOOL"
8657 test -z "$LIBTOOL" && ECHO_LT=
8660 AC_SUBST(LIBTOOL_CXX)
8661 AC_SUBST(LIBTOOL_OPTS)
8663 AC_SUBST(LIB_CREATE)
8664 AC_SUBST(LIB_OBJECT)
8665 AC_SUBST(LIB_SUFFIX)
8669 AC_SUBST(LIB_COMPILE)
8671 AC_SUBST(LIB_INSTALL)
8672 AC_SUBST(LIB_UNINSTALL)
8675 dnl ---------------------------------------------------------------------------
8676 dnl CF_WITH_LIBTOOL_OPTS version: 4 updated: 2015/04/17 21:13:04
8677 dnl --------------------
8678 dnl Allow user to pass additional libtool options into the library creation
8679 dnl and link steps. The main use for this is to do something like
8680 dnl ./configure --with-libtool-opts=-static
8681 dnl to get the same behavior as automake-flavored
8682 dnl ./configure --enable-static
8683 AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[
8684 AC_MSG_CHECKING(for additional libtool options)
8685 AC_ARG_WITH(libtool-opts,
8686 [ --with-libtool-opts=XXX specify additional libtool options],
8687 [with_libtool_opts=$withval],
8688 [with_libtool_opts=no])
8689 AC_MSG_RESULT($with_libtool_opts)
8691 case .$with_libtool_opts in
8695 LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts"
8699 AC_SUBST(LIBTOOL_OPTS)
8701 dnl ---------------------------------------------------------------------------
8702 dnl CF_WITH_LIB_BASENAME version: 1 updated: 2020/03/07 20:05:14
8703 dnl --------------------
8704 dnl Allow for overriding the basename of a library, i.e., the part to which
8705 dnl prefixes/suffixes are attached.
8707 dnl $1 = variable to set
8708 dnl $2 = option name
8709 dnl $3 = default basename for library, if omitted use $2
8710 AC_DEFUN([CF_WITH_LIB_BASENAME],
8712 AC_MSG_CHECKING(for desired basename for $2 library)
8713 AC_ARG_WITH($2-libname,
8714 [ --with-$2-libname=XXX override ifelse($3,,$2,$3) basename of library],
8715 [with_lib_basename=$withval],
8716 [with_lib_basename=ifelse($3,,$2,$3)])
8717 $1="$with_lib_basename"
8721 $1=ifelse($3,,$2,$3)
8727 AC_MSG_RESULT([$]$1)
8730 dnl ---------------------------------------------------------------------------
8731 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
8732 dnl ------------------
8733 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
8734 dnl "lib" prefix, e.g., because it used the dll naming convention.
8736 dnl $1 = variable to set
8737 AC_DEFUN([CF_WITH_LIB_PREFIX],
8739 AC_MSG_CHECKING(if you want to have a library-prefix)
8740 AC_ARG_WITH(lib-prefix,
8741 [ --with-lib-prefix override library-prefix],
8742 [with_lib_prefix=$withval],
8743 [with_lib_prefix=auto])
8744 AC_MSG_RESULT($with_lib_prefix)
8746 if test $with_lib_prefix = auto
8749 elif test $with_lib_prefix = no
8753 LIB_PREFIX=$with_lib_prefix
8756 dnl ---------------------------------------------------------------------------
8757 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
8759 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
8760 dnl defaulting to yes/no.
8762 dnl $1 = option name
8764 dnl $3 = environment variable to set
8765 dnl $4 = default value, shown in the help-message, must be a constant
8766 dnl $5 = default value, if it's an expression & cannot be in the help-message
8768 AC_DEFUN([CF_WITH_PATH],
8769 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
8770 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
8771 if ifelse([$5],,true,[test -n "$5"]) ; then
8772 CF_PATH_SYNTAX(withval)
8777 dnl ---------------------------------------------------------------------------
8778 dnl CF_WITH_PATHLIST version: 10 updated: 2015/04/17 21:13:04
8779 dnl ----------------
8780 dnl Process an option specifying a list of colon-separated paths.
8782 dnl $1 = option name
8784 dnl $3 = environment variable to set
8785 dnl $4 = default value, shown in the help-message, must be a constant
8786 dnl $5 = default value, if it's an expression & cannot be in the help-message
8787 dnl $6 = flag to tell if we want to define or substitute
8789 AC_DEFUN([CF_WITH_PATHLIST],[
8790 AC_REQUIRE([CF_PATHSEP])
8791 AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),,
8792 ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl
8794 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}"
8796 for cf_src_path in $withval
8798 CF_PATH_SYNTAX(cf_src_path)
8799 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR"
8800 cf_dst_path="${cf_dst_path}${cf_src_path}"
8805 # Strip single quotes from the value, e.g., when it was supplied as a literal
8807 case $cf_dst_path in
8809 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//`
8812 cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'`
8815 # This may use the prefix/exec_prefix symbols which will only yield "NONE"
8816 # so we have to check/work around. We do prefer the result of "eval"...
8817 eval cf_dst_eval="$cf_dst_path"
8818 case "x$cf_dst_eval" in
8829 dnl ---------------------------------------------------------------------------
8830 dnl CF_WITH_PATH_PROG version: 1 updated: 2019/06/30 19:44:43
8831 dnl -----------------
8832 dnl Check for a given program, like CF_PATH_PROG, but allow override using a
8833 dnl "--with-xxx" option.
8836 dnl $1 = environment variable to set/update
8837 dnl $2 = program name
8840 AC_DEFUN([CF_WITH_PATH_PROG],[
8841 AC_ARG_WITH($2-path,
8842 [ --with-$2-path=XXX specify path of $2 ifelse($3,,,$3)],
8843 [AC_MSG_CHECKING(for $2 program ifelse($3,,,$3))
8845 AC_MSG_RESULT([$]$1)
8848 [CF_PATH_PROG($1,$2,,ifelse($4,,,$4))
8851 AC_MSG_WARN(no $2 program found ifelse($3,,,$3))
8855 dnl ---------------------------------------------------------------------------
8856 dnl CF_WITH_PCRE2 version: 3 updated: 2020/02/29 16:09:19
8858 dnl Add PCRE2 (Perl-compatible regular expressions v2) to the build if it is
8859 dnl available and the user requests it. Assume the application will otherwise
8860 dnl use the POSIX interface.
8862 dnl TODO allow $withval to specify package location
8863 AC_DEFUN([CF_WITH_PCRE2],
8865 AC_REQUIRE([CF_PKG_CONFIG])
8867 AC_MSG_CHECKING(if you want to use PCRE2 for regular-expressions)
8869 [ --with-pcre2 use PCRE2 for regular-expressions])
8870 test -z "$with_pcre2" && with_pcre2=no
8871 AC_MSG_RESULT($with_pcre2)
8873 if test "x$with_pcre2" != xno ; then
8874 CF_TRY_PKG_CONFIG(libpcre2,,[
8875 CF_TRY_PKG_CONFIG(libpcre,,[
8876 AC_MSG_ERROR(Cannot find PCRE2 library)])])
8878 AC_DEFINE(HAVE_LIB_PCRE2,1,[Define to 1 if we can/should compile with the PCRE2 library])
8880 # if pkgconfig gave no results, look for the libraries directly
8882 (*pcre2-posix*|*pcreposix*)
8885 AC_CHECK_LIB(pcre2-posix,regcomp,[
8886 CF_ADD_LIB(pcre2-posix)],
8887 [AC_CHECK_LIB(pcreposix,regcomp,[
8888 CF_ADD_LIB(pcreposix)
8889 ],[AC_MSG_ERROR(Cannot find PCRE2 POSIX library)])])
8893 # either way, check for the library header files
8894 AC_CHECK_HEADERS(pcre2posix.h pcreposix.h)
8897 dnl ---------------------------------------------------------------------------
8898 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56
8899 dnl -------------------------
8900 dnl Allow the choice of the pkg-config library directory to be overridden.
8901 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
8905 AC_MSG_CHECKING(for pkg-config library directory)
8908 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
8912 PKG_CONFIG_LIBDIR=no
8913 AC_ARG_WITH(pkg-config-libdir,
8914 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
8915 [PKG_CONFIG_LIBDIR=$withval],
8916 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
8918 case x$PKG_CONFIG_LIBDIR in
8922 # Look for the library directory using the same prefix as the executable
8923 if test "x$PKG_CONFIG" = xnone
8927 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
8930 # If you don't like using the default architecture, you have to specify the
8931 # intended library directory and corresponding compiler/linker options.
8933 # This case allows for Debian's 2014-flavor of multiarch, along with the
8934 # most common variations before that point. Some other variants spell the
8935 # directory differently, e.g., "pkg-config", and put it in unusual places.
8936 # pkg-config has always been poorly standardized, which is ironic...
8937 case x`(arch) 2>/dev/null` in
8940 $cf_path/lib/*64-linux-gnu \
8948 $cf_path/lib/*-linux-gnu \
8957 for cf_config in $cf_search_path
8959 CF_VERBOSE(checking $cf_config/pkgconfig)
8960 if test -d $cf_config/pkgconfig
8962 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
8963 AC_MSG_CHECKING(done)
8972 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
8973 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
8976 AC_SUBST(PKG_CONFIG_LIBDIR)
8978 dnl ---------------------------------------------------------------------------
8979 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
8981 dnl Check for POSIX thread library.
8982 AC_DEFUN([CF_WITH_PTHREAD],
8984 AC_MSG_CHECKING(if you want to link with the pthread library)
8985 AC_ARG_WITH(pthread,
8986 [ --with-pthread use POSIX thread library],
8987 [with_pthread=$withval],
8989 AC_MSG_RESULT($with_pthread)
8991 if test "$with_pthread" != no ; then
8992 AC_CHECK_HEADER(pthread.h,[
8993 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
8995 for cf_lib_pthread in pthread c_r
8997 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
8998 cf_save_LIBS="$LIBS"
8999 CF_ADD_LIB($cf_lib_pthread)
9001 #include <pthread.h>
9003 int rc = pthread_create(0,0,0,0);
9004 int r2 = pthread_mutexattr_settype(0, 0);
9005 ],[with_pthread=yes],[with_pthread=no])
9006 LIBS="$cf_save_LIBS"
9007 AC_MSG_RESULT($with_pthread)
9008 test "$with_pthread" = yes && break
9011 if test "$with_pthread" = yes ; then
9012 CF_ADD_LIB($cf_lib_pthread)
9013 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
9015 AC_MSG_ERROR(Cannot link with pthread library)
9020 dnl ---------------------------------------------------------------------------
9021 dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49
9022 dnl -------------------
9023 dnl Allow library's release-version to be overridden. Generally this happens when a
9024 dnl packager has incremented the release-version past that used in the original package,
9025 dnl and wishes to keep doing this.
9027 dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR
9028 dnl and {package}_MINOR symbols
9030 AC_DEFUN([CF_WITH_REL_VERSION],[
9031 test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0
9032 AC_ARG_WITH(rel-version,
9033 [ --with-rel-version=XXX override derived release version],
9034 [AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval)
9035 cf_cv_rel_version=$withval])
9037 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version)
9039 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'`
9040 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'`
9041 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version)
9042 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version)
9045 dnl ---------------------------------------------------------------------------
9046 dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13
9047 dnl ----------------
9048 dnl If we can compile with sysmouse, make it available unless it is not wanted.
9049 AC_DEFUN([CF_WITH_SYSMOUSE],[
9050 # not everyone has "test -c"
9051 if test -c /dev/sysmouse 2>/dev/null ; then
9052 AC_MSG_CHECKING(if you want to use sysmouse)
9053 AC_ARG_WITH(sysmouse,
9054 [ --with-sysmouse use sysmouse (FreeBSD console)],
9055 [cf_with_sysmouse=$withval],
9056 [cf_with_sysmouse=maybe])
9057 if test "$cf_with_sysmouse" != no ; then
9059 #include <osreldate.h>
9060 #if (__FreeBSD_version >= 400017)
9061 #include <sys/consio.h>
9062 #include <sys/fbio.h>
9064 #include <machine/console.h>
9067 struct mouse_info the_mouse;
9068 ioctl(0, CONS_MOUSECTL, &the_mouse);
9069 ],[cf_with_sysmouse=yes],[cf_with_sysmouse=no])
9071 AC_MSG_RESULT($cf_with_sysmouse)
9072 test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface])
9075 dnl ---------------------------------------------------------------------------
9076 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
9078 dnl For testing, override the derived host system-type which is used to decide
9079 dnl things such as the linker commands used to build shared libraries. This is
9080 dnl normally chosen automatically based on the type of system which you are
9081 dnl building on. We use it for testing the configure script.
9083 dnl This is different from the --host option: it is used only for testing parts
9084 dnl of the configure script which would not be reachable with --host since that
9085 dnl relies on the build environment being real, rather than mocked up.
9086 AC_DEFUN([CF_WITH_SYSTYPE],[
9087 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
9088 AC_ARG_WITH(system-type,
9089 [ --with-system-type=XXX test: override derived host system-type],
9090 [AC_MSG_WARN(overriding system type to $withval)
9091 cf_cv_system_name=$withval
9095 dnl ---------------------------------------------------------------------------
9096 dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21
9097 dnl ----------------
9098 AC_DEFUN([CF_WITH_VALGRIND],[
9099 CF_NO_LEAKS_OPTION(valgrind,
9100 [ --with-valgrind test: use valgrind],
9103 dnl ---------------------------------------------------------------------------
9104 dnl CF_WITH_VERSIONED_SYMS version: 8 updated: 2018/10/20 20:24:34
9105 dnl ----------------------
9106 dnl Use this when building shared library with ELF, to markup symbols with the
9107 dnl version identifier from the given input file. Generally that identifier is
9108 dnl the same as the SONAME at which the symbol was first introduced.
9110 dnl $1 = basename of the ".map" file (default $PACKAGE)
9111 AC_DEFUN([CF_WITH_VERSIONED_SYMS],
9113 AC_MSG_CHECKING(if versioned-symbols file should be used)
9114 AC_ARG_WITH(versioned-syms,
9115 [ --with-versioned-syms=X markup versioned symbols using ld],
9116 [with_versioned_syms=$withval],
9117 [with_versioned_syms=no])
9118 case "x$with_versioned_syms" in
9120 with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map'
9126 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9129 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms)
9130 with_versioned_syms=`pwd`/"$with_versioned_syms"
9133 AC_MSG_RESULT($with_versioned_syms)
9139 if test "x$with_versioned_syms" != xno
9141 RESULTING_SYMS=$with_versioned_syms
9142 case "x$MK_SHARED_LIB" in
9144 VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}"
9145 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"`
9146 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
9149 VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}"
9150 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"`
9151 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
9154 AC_MSG_WARN(this system does not support versioned-symbols)
9158 # Linux ld can selectively override scope, e.g., of symbols beginning with
9159 # "_" by first declaring some as global, and then using a wildcard to
9160 # declare the others as local. Some other loaders cannot do this. Check
9161 # by constructing a (very) simple shared library and inspecting its
9163 if test "x$VERSIONED_SYMS" != "x"
9165 AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols)
9171 cat >conftest.ver <<EOF
9200 cat >conftest.$ac_ext <<EOF
9201 #line __oline__ "configure"
9202 int _ismissing(void) { return 1; }
9203 int _localf1(void) { return 1; }
9204 int _localf2(void) { return 2; }
9205 int globalf1(void) { return 1; }
9206 int globalf2(void) { return 2; }
9207 int _sublocalf1(void) { return 1; }
9208 int _sublocalf2(void) { return 2; }
9209 int subglobalf1(void) { return 1; }
9210 int subglobalf2(void) { return 2; }
9212 cat >conftest.mk <<EOF
9215 CPPFLAGS=${CPPFLAGS}
9218 VERSIONED_SYMS=${VERSIONED_SYMS}
9219 RESULTING_SYMS=conftest.ver
9220 MK_SHARED_LIB=${MK_SHARED_LIB}
9221 conftest.so: conftest.$ac_cv_objext
9222 \$(MK_SHARED_LIB) conftest.$ac_cv_objext
9225 # compile source, make library
9226 if make -f conftest.mk 2>&AC_FD_CC >/dev/null
9228 # test for missing symbol in either Data or Text section
9229 cf_missing=`nm -P conftest.so 2>&AC_FD_CC |fgrep _ismissing | egrep '[[ ]][[DT]][[ ]]'`
9230 test -n "$cf_missing" && WILDCARD_SYMS=yes
9232 AC_MSG_RESULT($WILDCARD_SYMS)
9236 AC_SUBST(RESULTING_SYMS)
9237 AC_SUBST(VERSIONED_SYMS)
9238 AC_SUBST(WILDCARD_SYMS)
9240 dnl ---------------------------------------------------------------------------
9241 dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54
9243 dnl Handle configure option "--with-x11-rgb", setting these shell
9246 dnl $RGB_PATH is the option value, used for finding the X11 rgb file.
9247 dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given.
9249 dnl Most Linux's use this:
9250 dnl /usr/share/X11/rgb.txt
9251 dnl Debian uses this:
9252 dnl /etc/X11/rgb.txt
9253 dnl DragonFlyBSD ports uses this:
9254 dnl /usr/pkg/lib/X11/rgb.txt
9255 dnl FreeBSD ports use these:
9256 dnl /usr/local/lib/X11/rgb.txt
9257 dnl /usr/local/share/X11/rgb.txt
9258 dnl Mandriva has these:
9259 dnl /usr/lib/X11/rgb.txt
9260 dnl /usr/lib64/X11/rgb.txt
9261 dnl NetBSD has these
9262 dnl /usr/X11R7/lib/X11/rgb.txt
9263 dnl OpenSolaris uses
9265 dnl /usr/X11/etc/X11/rgb.txt
9266 dnl /usr/X11/share/X11/rgb.txt
9267 dnl /usr/X11/lib/X11/rgb.txt
9269 dnl /opt/local/share/X11/rgb.txt (MacPorts)
9270 dnl /opt/X11/share/X11/rgb.txt (non-ports)
9272 dnl /usr/X11/etc/X11/rgb.txt
9273 dnl /usr/X11/share/X11/rgb.txt (perhaps)
9274 dnl /usr/X11/lib/amd64/X11/rgb.txt
9275 dnl Solaris10 uses (in this order):
9276 dnl /usr/openwin/lib/X11/rgb.txt
9277 dnl /usr/X11/lib/X11/rgb.txt
9278 AC_DEFUN([CF_WITH_X11_RGB],[
9279 AC_MSG_CHECKING(for X11 rgb file)
9280 AC_ARG_WITH(x11-rgb,
9281 [ --with-x11-rgb=FILE file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)],
9282 [RGB_PATH=$withval],
9285 if test "x[$]RGB_PATH" = xauto
9287 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt'
9289 /opt/local/share/X11/rgb.txt \
9290 /opt/X11/share/X11/rgb.txt \
9291 /usr/share/X11/rgb.txt \
9292 /usr/X11/share/X11/rgb.txt \
9293 /usr/X11/lib/X11/rgb.txt \
9294 /usr/lib/X11/rgb.txt \
9296 /usr/pkg/lib/X11/rgb.txt \
9297 /usr/X11R7/lib/X11/rgb.txt \
9298 /usr/X11R6/lib/X11/rgb.txt \
9299 /usr/X11R5/lib/X11/rgb.txt \
9300 /usr/X11R4/lib/X11/rgb.txt \
9301 /usr/local/lib/X11/rgb.txt \
9302 /usr/local/share/X11/rgb.txt \
9303 /usr/lib64/X11/rgb.txt
9305 if test -f "$cf_path" ; then
9312 CF_PATH_SYNTAX(cf_path)
9315 AC_MSG_RESULT($RGB_PATH)
9317 AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt])
9320 if test "$RGB_PATH" = no
9324 AC_SUBST(no_x11_rgb)
9326 dnl ---------------------------------------------------------------------------
9327 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
9329 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
9330 dnl or adapt to the vendor's definitions to get equivalent functionality,
9331 dnl without losing the common non-POSIX features.
9334 dnl $1 is the nominal value for _XOPEN_SOURCE
9335 dnl $2 is the nominal value for _POSIX_C_SOURCE
9336 AC_DEFUN([CF_XOPEN_SOURCE],[
9337 AC_REQUIRE([AC_CANONICAL_HOST])
9338 AC_REQUIRE([CF_POSIX_VISIBLE])
9340 if test "$cf_cv_posix_visible" = no; then
9342 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
9343 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
9348 cf_xopen_source="-D_ALL_SOURCE"
9354 cf_xopen_source="-D_APPLE_C_SOURCE"
9357 cf_xopen_source="-D_DARWIN_C_SOURCE"
9360 (freebsd*|dragonfly*|midnightbsd*)
9361 # 5.x headers associate
9362 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
9363 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
9364 cf_POSIX_C_SOURCE=200112L
9366 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
9369 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
9372 cf_xopen_source="-D_HPUX_SOURCE"
9375 cf_xopen_source="-D_SGI_SOURCE"
9378 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
9379 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
9382 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
9385 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
9387 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
9390 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
9393 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
9394 cf_xopen_source="-D_BSD_SOURCE"
9398 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
9401 cf_xopen_source="-D_OSF_SOURCE"
9404 cf_xopen_source="-D_QNX_SOURCE"
9407 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
9410 cf_xopen_source="-D__EXTENSIONS__"
9411 cf_cv_xopen_source=broken
9413 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
9419 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
9423 if test -n "$cf_xopen_source" ; then
9424 CF_ADD_CFLAGS($cf_xopen_source,true)
9427 dnl In anything but the default case, we may have system-specific setting
9428 dnl which is still not guaranteed to provide all of the entrypoints that
9429 dnl _XOPEN_SOURCE would yield.
9430 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
9431 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
9432 AC_TRY_COMPILE([#include <stdlib.h>],[
9433 #ifndef _XOPEN_SOURCE
9436 [cf_XOPEN_SOURCE_set=yes],
9437 [cf_XOPEN_SOURCE_set=no])
9438 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
9439 if test $cf_XOPEN_SOURCE_set = yes
9441 AC_TRY_COMPILE([#include <stdlib.h>],[
9442 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
9445 [cf_XOPEN_SOURCE_set_ok=yes],
9446 [cf_XOPEN_SOURCE_set_ok=no])
9447 if test $cf_XOPEN_SOURCE_set_ok = no
9449 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
9455 fi # cf_cv_posix_visible