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.931 2020/09/12 22:30:53 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: 15 updated: 2017/01/21 11:06:25
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_MSG_CHECKING([for size of bool])
617 AC_CACHE_VAL(cf_cv_type_of_bool,[
623 #if defined(__cplusplus)
625 #ifdef HAVE_GXX_BUILTIN_H
626 #include <g++/builtin.h>
627 #elif HAVE_GPP_BUILTIN_H
628 #include <gpp/builtin.h>
635 #if $cf_cv_header_stdbool_h
643 FILE *fp = fopen("cf_test.out", "w");
647 fputs("unsigned ", fp);
648 if (sizeof(x) == sizeof(int)) fputs("int", fp);
649 else if (sizeof(x) == sizeof(char)) fputs("char", fp);
650 else if (sizeof(x) == sizeof(short))fputs("short",fp);
651 else if (sizeof(x) == sizeof(long)) fputs("long", fp);
654 ${cf_cv_main_return:-return}(0);
657 [cf_cv_type_of_bool=`cat cf_test.out`
658 if test -z "$cf_cv_type_of_bool"; then
659 cf_cv_type_of_bool=unknown
661 [cf_cv_type_of_bool=unknown],
662 [cf_cv_type_of_bool=unknown])
665 AC_MSG_RESULT($cf_cv_type_of_bool)
666 if test "$cf_cv_type_of_bool" = unknown ; then
667 case .$NCURSES_BOOL in
668 (.auto|.) NCURSES_BOOL=unsigned;;
670 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool)
671 cf_cv_type_of_bool=$NCURSES_BOOL
674 dnl ---------------------------------------------------------------------------
675 dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04
677 dnl If we're cross-compiling, allow the user to override the tools and their
678 dnl options. The configure script is oriented toward identifying the host
679 dnl compiler, etc., but we need a build compiler to generate parts of the
682 dnl $1 = default for $CPPFLAGS
683 dnl $2 = default for $LIBS
684 AC_DEFUN([CF_BUILD_CC],[
685 CF_ACVERSION_CHECK(2.52,,
686 [AC_REQUIRE([CF_PROG_EXT])])
687 if test "$cross_compiling" = yes ; then
689 # defaults that we might want to override
690 : ${BUILD_CFLAGS:=''}
691 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
692 : ${BUILD_LDFLAGS:=''}
693 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
694 : ${BUILD_EXEEXT:='$x'}
695 : ${BUILD_OBJEXT:='o'}
697 AC_ARG_WITH(build-cc,
698 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
699 [BUILD_CC="$withval"],
700 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
701 AC_MSG_CHECKING(for native build C compiler)
702 AC_MSG_RESULT($BUILD_CC)
704 AC_MSG_CHECKING(for native build C preprocessor)
705 AC_ARG_WITH(build-cpp,
706 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
707 [BUILD_CPP="$withval"],
708 [BUILD_CPP='${BUILD_CC} -E'])
709 AC_MSG_RESULT($BUILD_CPP)
711 AC_MSG_CHECKING(for native build C flags)
712 AC_ARG_WITH(build-cflags,
713 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
714 [BUILD_CFLAGS="$withval"])
715 AC_MSG_RESULT($BUILD_CFLAGS)
717 AC_MSG_CHECKING(for native build C preprocessor-flags)
718 AC_ARG_WITH(build-cppflags,
719 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
720 [BUILD_CPPFLAGS="$withval"])
721 AC_MSG_RESULT($BUILD_CPPFLAGS)
723 AC_MSG_CHECKING(for native build linker-flags)
724 AC_ARG_WITH(build-ldflags,
725 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
726 [BUILD_LDFLAGS="$withval"])
727 AC_MSG_RESULT($BUILD_LDFLAGS)
729 AC_MSG_CHECKING(for native build linker-libraries)
730 AC_ARG_WITH(build-libs,
731 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
732 [BUILD_LIBS="$withval"])
733 AC_MSG_RESULT($BUILD_LIBS)
735 # this assumes we're on Unix.
739 : ${BUILD_CC:='${CC}'}
741 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
742 AC_MSG_ERROR([Cross-build requires two compilers.
743 Use --with-build-cc to specify the native compiler.])
747 : ${BUILD_CC:='${CC}'}
748 : ${BUILD_CPP:='${CPP}'}
749 : ${BUILD_CFLAGS:='${CFLAGS}'}
750 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
751 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
752 : ${BUILD_LIBS:='${LIBS}'}
753 : ${BUILD_EXEEXT:='$x'}
754 : ${BUILD_OBJEXT:='o'}
759 AC_SUBST(BUILD_CFLAGS)
760 AC_SUBST(BUILD_CPPFLAGS)
761 AC_SUBST(BUILD_LDFLAGS)
763 AC_SUBST(BUILD_EXEEXT)
764 AC_SUBST(BUILD_OBJEXT)
766 dnl ---------------------------------------------------------------------------
767 dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
769 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
770 dnl into CC. This will not help with broken scripts that wrap the compiler
771 dnl with options, but eliminates a more common category of user confusion.
773 dnl In particular, it addresses the problem of being able to run the C
774 dnl preprocessor in a consistent manner.
776 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
777 dnl the nuisance of having inconsistent settings for compiler and preprocessor
778 dnl outweighs that limitation.
779 AC_DEFUN([CF_CC_ENV_FLAGS],
781 # This should have been defined by AC_PROG_CC
784 AC_MSG_CHECKING(\$CFLAGS variable)
787 AC_MSG_RESULT(broken)
788 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
791 for cf_arg in $cf_flags
793 CF_ADD_CFLAGS($cf_arg)
801 AC_MSG_CHECKING(\$CC variable)
804 AC_MSG_RESULT(broken)
805 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
807 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
808 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
810 for cf_arg in $cf_flags
814 CF_ADD_CFLAGS($cf_arg)
821 CF_VERBOSE(resulting CC: '$CC')
822 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
823 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
830 dnl ---------------------------------------------------------------------------
831 dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
833 dnl Determine the default configuration into which we'll install ncurses. This
834 dnl can be overridden by the user's command-line options. There's two items to
836 dnl 1. the prefix (e.g., /usr)
837 dnl 2. the header files (e.g., /usr/include/ncurses)
838 dnl We'll look for a previous installation of ncurses and use the same defaults.
840 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
841 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
842 dnl programs from a vendor's.
843 AC_DEFUN([CF_CFG_DEFAULTS],
845 AC_MSG_CHECKING(for prefix)
846 if test "x$prefix" = "xNONE" ; then
847 case "$cf_cv_system_name" in
848 # non-vendor systems don't have a conflict
849 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
852 (*) prefix=$ac_default_prefix
856 AC_MSG_RESULT($prefix)
858 if test "x$prefix" = "xNONE" ; then
859 AC_MSG_CHECKING(for default include-directory)
860 test -n "$verbose" && echo 1>&AC_FD_MSG
863 $includedir/ncurses \
865 $prefix/include/ncurses \
867 /usr/local/include/ncurses \
871 cf_dir=`eval echo $cf_symbol`
872 if test -f $cf_dir/curses.h ; then
873 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
874 includedir="$cf_symbol"
875 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
879 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
881 AC_MSG_RESULT($includedir)
884 dnl ---------------------------------------------------------------------------
885 dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25
887 dnl Check if the terminal-capability database functions are available. If not,
888 dnl ncurses has a much-reduced version.
889 AC_DEFUN([CF_CGETENT],[
890 AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[
892 #include <stdlib.h>],[
895 char *db_array = temp;
896 cgetent(&buf, &db_array, "vt100");
897 cgetcap(buf, "tc", '=');
898 cgetmatch(buf, "tc");
904 if test "$cf_cv_cgetent" = yes
906 AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent])
907 AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[
909 #pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers"
910 #include <stdlib.h>],[
913 #ifndef _NETBSD_SOURCE /* given, since April 2004 in stdlib.h */
914 const char *db_array = temp;
915 cgetent(&buf, &db_array, "vt100");
917 cgetcap(buf, "tc", '=');
918 cgetmatch(buf, "tc");
920 [cf_cv_cgetent_const=yes],
921 [cf_cv_cgetent_const=no])
923 if test "$cf_cv_cgetent_const" = yes
925 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations])
929 dnl ---------------------------------------------------------------------------
930 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
932 dnl Check if we're accidentally using a cache from a different machine.
933 dnl Derive the system name, as a check for reusing the autoconf cache.
935 dnl If we've packaged config.guess and config.sub, run that (since it does a
936 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
937 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
938 dnl which is useful in cross-compiles.
940 dnl Note: we would use $ac_config_sub, but that is one of the places where
941 dnl autoconf 2.5x broke compatibility with autoconf 2.13
942 AC_DEFUN([CF_CHECK_CACHE],
944 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
945 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
946 system_name="$host_os"
948 system_name="`(uname -s -r) 2>/dev/null`"
949 if test -z "$system_name" ; then
950 system_name="`(hostname) 2>/dev/null`"
953 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
954 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
956 test -z "$system_name" && system_name="$cf_cv_system_name"
957 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
959 if test ".$system_name" != ".$cf_cv_system_name" ; then
960 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
961 AC_MSG_ERROR("Please remove config.cache and try again.")
964 dnl ---------------------------------------------------------------------------
965 dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57
967 dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ'
968 dnl variable. Define a DECL_xxx symbol if we must declare it ourselves.
970 dnl $1 = the name to check
971 dnl $2 = the assumed type
972 AC_DEFUN([CF_CHECK_ENVIRON],
974 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
979 #include <unistd.h> ],
980 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1,
985 if test "$cf_cv_dcl_$1" = no ; then
986 CF_UPPER(cf_result,decl_$1)
987 AC_DEFINE_UNQUOTED($cf_result)
990 # It's possible (for near-UNIX clones) that the data doesn't exist
991 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
993 dnl ---------------------------------------------------------------------------
994 dnl CF_CHECK_ERRNO version: 13 updated: 2020/03/10 18:53:47
996 dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g.,
997 dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it
1000 dnl $1 = the name to check
1001 dnl $2 = the assumed type
1002 AC_DEFUN([CF_CHECK_ERRNO],
1004 AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[
1006 #ifdef HAVE_STDLIB_H
1010 #include <sys/types.h>
1011 #include <errno.h> ],
1012 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x,
1017 if test "$cf_cv_dcl_$1" = no ; then
1018 CF_UPPER(cf_result,decl_$1)
1019 AC_DEFINE_UNQUOTED($cf_result)
1022 # It's possible (for near-UNIX clones) that the data doesn't exist
1023 CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2]))
1025 dnl ---------------------------------------------------------------------------
1026 dnl CF_CHECK_EXTERN_DATA version: 4 updated: 2015/04/18 08:56:57
1027 dnl --------------------
1028 dnl Check for existence of external data in the current set of libraries. If
1029 dnl we can modify it, it's real enough.
1030 dnl $1 = the name to check
1032 AC_DEFUN([CF_CHECK_EXTERN_DATA],
1034 AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[
1040 [cf_cv_have_$1=yes],
1044 if test "$cf_cv_have_$1" = yes ; then
1045 CF_UPPER(cf_result,have_$1)
1046 AC_DEFINE_UNQUOTED($cf_result)
1050 dnl ---------------------------------------------------------------------------
1051 dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13
1052 dnl --------------------
1053 dnl Check whether the compiler understands -fvisibility=hidden
1056 dnl $2 = compiler-flags variable name
1057 dnl $3 = cache variable to set
1058 AC_DEFUN([CF_CHECK_FVISIBILITY],[
1059 AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[
1060 cf_save_cflags="[$]$2"
1061 $2="[$]$2 -fvisibility=hidden"
1063 __attribute__ ((visibility("default"))) int somefunc() {return 42;}
1065 if (somefunc()) return 1;
1072 dnl ---------------------------------------------------------------------------
1073 dnl CF_CHECK_GETENV version: 1 updated: 2019/06/23 15:28:15
1075 dnl Check if repeated getenv calls return the same pointer, e.g., it does not
1076 dnl discard the previous pointer when returning a new one.
1077 AC_DEFUN([CF_CHECK_GETENV],
1079 AC_REQUIRE([CF_CHECK_ENVIRON])
1080 AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) )
1081 AC_CHECK_FUNCS( putenv setenv strdup )
1082 AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[
1088 #include <sys/types.h>
1090 #if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ)
1091 extern char **environ; /* POSIX, but some systems are not... */
1094 #if defined(HAVE_STRDUP)
1095 #define str_alloc(s) strdup(s)
1097 #define str_alloc(s) strcpy(malloc(strlen(s) + 1, s))
1100 static void set_value(const char *name, const char *value)
1102 #if defined(HAVE_SETENV)
1103 setenv(name, value, 1);
1104 #elif defined(HAVE_PUTENV)
1106 sprintf(buffer, "%s=%s", name, value);
1107 putenv(str_alloc(buffer));
1109 #error neither putenv/setenv found
1115 size_t numenv, limit, j;
1120 for (numenv = 0; environ[numenv]; ++numenv) ;
1121 limit = numenv + 10;
1122 mynames = (char **) calloc(limit + 1, sizeof(char *));
1123 myvalues = (char **) calloc(limit + 1, sizeof(char *));
1124 mypointer = (char **) calloc(limit + 1, sizeof(char *));
1125 #if defined(HAVE_ENVIRON)
1126 for (j = 0; environ[j]; ++j) {
1127 mynames[j] = str_alloc(environ[j]);
1128 equals = strchr(mynames[j], '=');
1131 myvalues[j] = str_alloc(equals);
1133 myvalues[j] = str_alloc("");
1137 for (j = numenv; j < limit; ++j) {
1145 sprintf(name, "TERM%lu", (unsigned long) k);
1146 for (jk = 0; jk < j; ++jk) {
1147 if (!strcmp(name, mynames[jk])) {
1154 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]);
1155 set_value(name, value);
1156 mynames[j] = str_alloc(name);
1157 myvalues[j] = str_alloc(value);
1159 for (pass = 0; pass < 3; ++pass) {
1160 for (j = 0; j < limit; ++j) {
1161 char *value = getenv(mynames[j]);
1164 fprintf(stderr, "getenv returned null for %s\n", mynames[j]);
1165 ${cf_cv_main_return:-return}(1);
1166 } else if (value != mypointer[j]) {
1167 fprintf(stderr, "getenv returned different pointer for %s\n", mynames[j]);
1168 ${cf_cv_main_return:-return}(1);
1169 } else if (strcmp(value, myvalues[j])) {
1170 fprintf(stderr, "getenv returned different value for %s\n", mynames[j]);
1171 ${cf_cv_main_return:-return}(1);
1175 mypointer[j] = value;
1176 for (k = 0; k < j; ++k) {
1177 if (mypointer[j] == mypointer[k]) {
1178 fprintf(stderr, "getenv returned same pointer for %s and %s\n", mynames[j], mynames[k]);
1179 ${cf_cv_main_return:-return}(1);
1185 ${cf_cv_main_return:-return}(0);
1188 [cf_cv_consistent_getenv=yes],
1189 [cf_cv_consistent_getenv=no],
1190 [cf_cv_consistent_getenv=unknown])
1193 if test "x$cf_cv_consistent_getenv" = xno
1195 AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name])
1198 dnl ---------------------------------------------------------------------------
1199 dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
1200 dnl ---------------------
1201 AC_DEFUN([CF_CHECK_GNAT_VERSION],
1203 AC_REQUIRE([CF_GNAT_VERSION])
1204 case $cf_cv_gnat_version in
1205 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1206 cf_cv_prog_gnat_correct=yes
1209 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
1210 cf_cv_prog_gnat_correct=no
1214 dnl ---------------------------------------------------------------------------
1215 dnl CF_CHECK_GPM_WGETCH version: 3 updated: 2017/01/21 11:06:25
1216 dnl -------------------
1217 dnl Check if GPM is already linked with curses. If so - and if the linkage
1218 dnl is not "weak" - warn about this because it can create problems linking
1219 dnl applications with ncurses.
1220 AC_DEFUN([CF_CHECK_GPM_WGETCH],[
1221 AC_CHECK_LIB(gpm,Gpm_Wgetch,[
1223 AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[
1224 cf_cv_check_gpm_wgetch=unknown
1225 if test "$cross_compiling" != yes ; then
1227 cat >conftest.$ac_ext <<CF_EOF
1232 ${cf_cv_main_return:-return}(0);
1236 cf_save_LIBS="$LIBS"
1237 # This only works if we can look at the symbol table. If a shared
1238 # library is stripped for install, we cannot use that. So we're forced
1239 # to rely on the static library, noting that some packagers may not
1241 LIBS="-static -lgpm -dynamic $LIBS"
1242 if AC_TRY_EVAL(ac_compile) ; then
1243 if AC_TRY_EVAL(ac_link) ; then
1244 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'`
1245 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes
1246 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no
1250 LIBS="$cf_save_LIBS"
1254 if test "$cf_cv_check_gpm_wgetch" != yes ; then
1255 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ)
1258 dnl ---------------------------------------------------------------------------
1259 dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09
1260 dnl ------------------------
1261 dnl Show the version of libtool
1263 dnl Save the version in a cache variable - this is not entirely a good thing,
1264 dnl but the version string from libtool is very ugly, and for bug reports it
1265 dnl might be useful to have the original string.
1266 AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[
1267 if test -n "$LIBTOOL" && test "$LIBTOOL" != none
1269 AC_MSG_CHECKING(version of $LIBTOOL)
1271 AC_MSG_RESULT($cf_cv_libtool_version)
1272 if test -z "$cf_cv_libtool_version" ; then
1273 AC_MSG_ERROR(This is not GNU libtool)
1276 AC_MSG_ERROR(GNU libtool has not been found)
1279 dnl ---------------------------------------------------------------------------
1280 dnl CF_CHECK_WCHAR_H version: 2 updated: 2017/01/21 11:06:25
1281 dnl ----------------
1282 dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED
1283 AC_DEFUN([CF_CHECK_WCHAR_H],[
1288 AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[
1295 #ifdef HAVE_WCTYPE_H
1300 int bar = iswpunct(foo)],
1301 [cf_cv_wchar_h_okay=yes],
1302 [cf_cv_wchar_h_okay=no])])
1304 if test $cf_cv_wchar_h_okay = no
1306 CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED)
1309 dnl ---------------------------------------------------------------------------
1310 dnl CF_CHECK_WCWIDTH_GRAPHICS version: 1 updated: 2015/12/19 17:47:56
1311 dnl -------------------------
1312 dnl Most "modern" terminal emulators are based to some degree on VT100, and
1313 dnl should support line-drawing. Even with Unicode. There is a problem.
1315 dnl While most of the VT100 graphics characters were incorporated into Unicode,
1316 dnl all of those were combined into a page of useful graphics characters.
1318 dnl So far, so good.
1320 dnl However, while they are useful, there are other considerations. CJK
1321 dnl is (because of poor device resolution) often rendered as double-width
1322 dnl characters. So... for these generally-useful characters, what should
1323 dnl be the width (to make them consistent with adjacent characters)?
1325 dnl The obvious choice would have been to make this locale-dependent, and use
1326 dnl wcwidth() to tell applications what the actual width is. That was too
1327 dnl obvious. Instead, we have a slew of "ambiguous-width" characters.
1329 dnl http://www.unicode.org/reports/tr11/tr11-29.html
1330 dnl http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html
1332 dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists
1333 dnl more than 22,000 characters, with 1281 of those as ambiguous-width. For
1334 dnl instance, it lists half (44/96) of the Latin-1 characters as
1335 dnl ambiguous-width. Also, all of the box-characters at 0x2500 are ambiguous.
1337 dnl What this means for the implementor is that on some systems wcwidth() can
1338 dnl give bad advice. On Solaris, some of the ambiguous widths are returned as
1339 dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing
1340 dnl characters). These do not necessarily match the behavior of the terminal
1341 dnl emulator. xterm, for instance, does an optional startup check to find if
1342 dnl this problem (or similar) exists with the system's locale tables, rejecting
1343 dnl them if they are too unreliable.
1344 AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[
1345 AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[
1346 cat >conftest.in <<CF_EOF
1348 0x250c upper left corner
1349 0x2514 lower left corner
1350 0x2510 upper right corner
1351 0x2518 lower right corner
1352 0x251c tee pointing left
1353 0x2524 tee pointing right
1354 0x2534 tee pointing up
1355 0x252c tee pointing down
1356 0x2500 horizontal line
1357 0x2502 vertical line
1358 0x253c large plus or crossover
1362 0x2592 checker board (stipple)
1363 0x00b0 degree symbol
1366 - Teletype 5410v1 symbols
1367 0x2190 arrow pointing left
1368 0x2192 arrow pointing right
1369 0x2193 arrow pointing down
1370 0x2191 arrow pointing up
1371 0x2592 board of squares
1372 0x2603 lantern symbol
1373 0x25ae solid square block
1374 - these defaults were invented for ncurses
1377 0x2264 less-than-or-equal-to
1378 0x2265 greater-than-or-equal-to
1381 0x00a3 pound-sterling symbol
1382 - thick-line-drawing
1383 0x250f upper left corner
1384 0x2517 lower left corner
1385 0x2513 upper right corner
1386 0x251b lower right corner
1387 0x2523 tee pointing left
1388 0x252b tee pointing right
1389 0x253b tee pointing up
1390 0x2533 tee pointing down
1391 0x2501 horizontal line
1392 0x2503 vertical line
1393 0x254b large plus or crossover
1394 - double-line-drawing
1395 0x2554 upper left corner
1396 0x255a lower left corner
1397 0x2557 upper right corner
1398 0x255d lower right corner
1399 0x2563 tee pointing left
1400 0x2560 tee pointing right
1401 0x2569 tee pointing up
1402 0x2566 tee pointing down
1403 0x2550 horizontal line
1404 0x2551 vertical line
1405 0x256c large plus or crossover
1419 char buffer[MY_LEN + 1];
1420 char notes[MY_LEN + 1];
1424 if (setlocale(LC_ALL, "en_US.UTF8") ||
1425 setlocale(LC_ALL, "en_US.UTF-8") ||
1426 setlocale(LC_ALL, "en_US.utf8") ||
1427 setlocale(LC_ALL, "en_US.utf-8")) {
1428 if ((fp = fopen("conftest.in", "r")) != 0) {
1429 while (fgets(buffer, MY_LEN, fp) != 0) {
1430 if (*buffer == '-') {
1431 fprintf(stderr, "\t%s", buffer);
1432 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) {
1434 if (wcwidth(value) == 1)
1436 fprintf(stderr, "%d\t%s", wcwidth(value), buffer);
1438 fprintf(stderr, "?\t%s", buffer);
1443 fprintf(stderr, "%d/%d passed wcwidth/graphics check\n", passed, totals);
1444 return (totals == passed) ? 0 : 1;
1447 [cf_cv_wcwidth_graphics=yes],
1448 [cf_cv_wcwidth_graphics=no],
1449 [cf_cv_wcwidth_graphics=unknown])
1452 dnl ---------------------------------------------------------------------------
1453 dnl CF_CLANG_COMPILER version: 3 updated: 2020/08/28 04:10:22
1454 dnl -----------------
1455 dnl Check if the given compiler is really clang. clang's C driver defines
1456 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
1457 dnl not ignore some gcc options.
1459 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1460 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1461 dnl the wrappers for gcc and g++ warnings.
1463 dnl $1 = GCC (default) or GXX
1464 dnl $2 = CLANG_COMPILER (default)
1465 dnl $3 = CFLAGS (default) or CXXFLAGS
1466 AC_DEFUN([CF_CLANG_COMPILER],[
1467 ifelse([$2],,CLANG_COMPILER,[$2])=no
1469 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1470 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
1471 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1472 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
1478 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
1479 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
1481 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1482 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
1485 if test "x$CLANG_COMPILER" = "xyes" ; then
1486 CF_APPEND_TEXT(CFLAGS,-Wno-error=implicit-function-declaration)
1489 dnl ---------------------------------------------------------------------------
1490 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
1491 dnl -----------------
1492 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
1493 dnl character-strings.
1495 dnl It is ambiguous because the specification accommodated the pre-ANSI
1496 dnl compilers bundled by more than one vendor in lieu of providing a standard C
1497 dnl compiler other than by costly add-ons. Because of this, the specification
1498 dnl did not take into account the use of const for telling the compiler that
1499 dnl string literals would be in readonly memory.
1501 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
1502 dnl let the compiler decide how to represent Xt's strings which were #define'd.
1503 dnl That does not solve the problem of using the block of Xt's strings which
1504 dnl are compiled into the library (and is less efficient than one might want).
1506 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
1507 dnl when compiling the library and compiling using the library, to tell the
1508 dnl compiler that String is const.
1509 AC_DEFUN([CF_CONST_X_STRING],
1511 AC_REQUIRE([AC_PATH_XTRA])
1513 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
1518 #include <X11/Intrinsic.h>
1520 [String foo = malloc(1); (void)foo],[
1522 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
1525 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
1526 #undef XTSTRINGDEFINES /* X11R5 and later */
1528 #include <X11/Intrinsic.h>
1529 ],[String foo = malloc(1); *foo = 0],[
1530 cf_cv_const_x_string=no
1532 cf_cv_const_x_string=yes
1536 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
1538 case $cf_cv_const_x_string in
1540 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
1543 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
1549 dnl ---------------------------------------------------------------------------
1550 dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25
1551 dnl -----------------
1552 dnl Check if the C++ compiler accepts duplicate parameter initialization. This
1553 dnl is a late feature for the standard and is not in some recent compilers
1555 AC_DEFUN([CF_CPP_PARAM_INIT],
1557 if test -n "$CXX"; then
1558 AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[
1570 TEST::TEST(int x = 1) // some compilers do not like second initializer
1576 [cf_cv_cpp_param_init=yes],
1577 [cf_cv_cpp_param_init=no],
1578 [cf_cv_cpp_param_init=unknown])
1582 test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization])
1584 dnl ---------------------------------------------------------------------------
1585 dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21
1586 dnl ------------------
1587 dnl Check if the C++ compiler accepts static_cast in generics. This appears to
1588 dnl not be supported in g++ before 3.0
1589 AC_DEFUN([CF_CPP_STATIC_CAST],
1591 if test -n "$CXX"; then
1593 AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[
1601 NCursesPanel(int nlines,
1611 template<class T> class NCursesUserPanel : public NCursesPanel
1614 NCursesUserPanel (int nlines,
1618 const T* p_UserData = static_cast<T*>(0))
1619 : NCursesPanel (nlines, ncols, begin_y, begin_x)
1622 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel()
1626 virtual ~NCursesUserPanel() {};
1629 const char* p_UserData = static_cast<char*>(0)],
1630 [cf_cv_cpp_static_cast=yes],
1631 [cf_cv_cpp_static_cast=no])
1638 test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast])
1640 dnl ---------------------------------------------------------------------------
1641 dnl CF_CXX_AR_FLAGS version: 2 updated: 2015/04/17 21:13:04
1643 dnl Setup special archiver flags for given compilers.
1644 AC_DEFUN([CF_CXX_AR_FLAGS],[
1646 CXX_ARFLAGS='$(ARFLAGS)'
1647 case $cf_cv_system_name in
1649 if test "$GXX" != yes ; then
1651 CXX_ARFLAGS='-ar -o'
1655 CXXLDFLAGS="-u main"
1658 if test "$GXX" != yes ; then
1660 CXX_ARFLAGS='-xar -o'
1664 AC_SUBST(CXXLDFLAGS)
1666 AC_SUBST(CXX_ARFLAGS)
1668 dnl ---------------------------------------------------------------------------
1669 dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13
1670 dnl -------------------------
1671 dnl For c++, check if iostream uses "std::" namespace.
1672 AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[
1673 AC_CHECK_HEADERS(iostream)
1674 if test x"$ac_cv_header_iostream" = xyes ; then
1675 AC_MSG_CHECKING(if iostream uses std-namespace)
1680 cerr << "testing" << endl;
1681 ],[cf_iostream_namespace=yes],[cf_iostream_namespace=no])
1682 AC_MSG_RESULT($cf_iostream_namespace)
1683 if test "$cf_iostream_namespace" = yes ; then
1684 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream])
1688 dnl ---------------------------------------------------------------------------
1689 dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36
1691 dnl Check if the C compiler supports "inline".
1692 dnl $1 is the name of a shell variable to set if inline is supported
1693 dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size
1694 AC_DEFUN([CF_C_INLINE],[
1695 AC_REQUIRE([CF_GCC_VERSION])
1698 if test "$ac_cv_c_inline" != no ; then
1700 if test "$INTEL_COMPILER" = yes
1703 elif test "$CLANG_COMPILER" = yes
1706 elif test "$GCC" = yes
1708 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[
1709 cf_save_CFLAGS=$CFLAGS
1710 CFLAGS="$CFLAGS --param max-inline-insns-single=$2"
1711 AC_TRY_COMPILE([inline int foo(void) { return 1; }],
1712 [${cf_cv_main_return:-return} foo()],
1713 [cf_cv_gcc_inline=yes],
1714 [cf_cv_gcc_inline=no])
1715 CFLAGS=$cf_save_CFLAGS
1717 if test "$cf_cv_gcc_inline" = yes ; then
1718 CF_ADD_CFLAGS([--param max-inline-insns-single=$2])
1724 dnl ---------------------------------------------------------------------------
1725 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
1727 dnl "dirname" is not portable, so we fake it with a shell script.
1728 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
1729 dnl ---------------------------------------------------------------------------
1730 dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31
1732 AC_DEFUN([CF_DIRS_TO_MAKE],
1735 for cf_item in $cf_list_models
1737 CF_OBJ_SUBDIR($cf_item,cf_subdir)
1738 for cf_item2 in $DIRS_TO_MAKE
1740 test $cf_item2 = $cf_subdir && break
1742 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir"
1744 for cf_dir in $DIRS_TO_MAKE
1746 test ! -d $cf_dir && mkdir $cf_dir
1748 AC_SUBST(DIRS_TO_MAKE)
1750 dnl ---------------------------------------------------------------------------
1751 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
1753 dnl You can always use "make -n" to see the actual options, but it's hard to
1754 dnl pick out/analyze warning messages when the compile-line is long.
1757 dnl ECHO_LT - symbol to control if libtool is verbose
1758 dnl ECHO_LD - symbol to prefix "cc -o" lines
1759 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
1760 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
1761 dnl ECHO_CC - symbol to put before any "cc" line
1763 AC_DEFUN([CF_DISABLE_ECHO],[
1764 AC_MSG_CHECKING(if you want to see long compiling messages)
1765 CF_ARG_DISABLE(echo,
1766 [ --disable-echo do not display "compiling" commands],
1769 ECHO_LD='@echo linking [$]@;'
1770 RULE_CC='@echo compiling [$]<'
1771 SHOW_CC='@echo compiling [$]@'
1780 AC_MSG_RESULT($enableval)
1787 dnl ---------------------------------------------------------------------------
1788 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
1789 dnl ------------------------
1790 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
1791 AC_MSG_CHECKING(if we want to use GNAT projects)
1792 CF_ARG_DISABLE(gnat-projects,
1793 [ --disable-gnat-projects test: disable GNAT projects even if usable],
1794 [enable_gnat_projects=no],
1795 [enable_gnat_projects=yes])
1796 AC_MSG_RESULT($enable_gnat_projects)
1798 dnl ---------------------------------------------------------------------------
1799 dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03
1800 dnl ----------------
1801 dnl Combine no-leak checks with the libraries or tools that are used for the
1803 AC_DEFUN([CF_DISABLE_LEAKS],[
1805 AC_REQUIRE([CF_WITH_DMALLOC])
1806 AC_REQUIRE([CF_WITH_DBMALLOC])
1807 AC_REQUIRE([CF_WITH_VALGRIND])
1809 AC_MSG_CHECKING(if you want to perform memory-leak testing)
1810 AC_ARG_ENABLE(leaks,
1811 [ --disable-leaks test: free permanent memory, analyze leaks],
1812 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi],
1813 : ${with_no_leaks:=no})
1814 AC_MSG_RESULT($with_no_leaks)
1816 if test "$with_no_leaks" = yes ; then
1817 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1818 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.])
1821 dnl ---------------------------------------------------------------------------
1822 dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04
1823 dnl --------------------------
1824 dnl Check if we should use the libtool 1.5 feature "-version-number" instead of
1825 dnl the older "-version-info" feature. The newer feature allows us to use
1826 dnl version numbering on shared libraries which make them compatible with
1827 dnl various systems.
1828 AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION],
1830 AC_MSG_CHECKING(if libtool -version-number should be used)
1831 CF_ARG_DISABLE(libtool-version,
1832 [ --disable-libtool-version enable to use libtool's incompatible naming scheme],
1833 [cf_libtool_version=no],
1834 [cf_libtool_version=yes])
1835 AC_MSG_RESULT($cf_libtool_version)
1837 if test "$cf_libtool_version" = yes ; then
1838 LIBTOOL_VERSION="-version-number"
1840 LIBTOOL_VERSION="-version-info"
1843 AC_MSG_WARN(VERSION was not set)
1846 ABI_VERSION="$VERSION"
1847 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1850 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'`
1851 CF_VERBOSE(ABI_VERSION: $ABI_VERSION)
1854 AC_MSG_WARN(unexpected VERSION value: $VERSION)
1859 AC_SUBST(ABI_VERSION)
1860 AC_SUBST(LIBTOOL_VERSION)
1862 dnl ---------------------------------------------------------------------------
1863 dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33
1864 dnl ---------------------
1865 dnl The rpath-hack makes it simpler to build programs, particularly with the
1866 dnl *BSD ports which may have essential libraries in unusual places. But it
1867 dnl can interfere with building an executable for the base system. Use this
1868 dnl option in that case.
1869 AC_DEFUN([CF_DISABLE_RPATH_HACK],
1871 AC_MSG_CHECKING(if rpath-hack should be disabled)
1872 CF_ARG_DISABLE(rpath-hack,
1873 [ --disable-rpath-hack don't add rpath options for additional libraries],
1874 [cf_disable_rpath_hack=yes],
1875 [cf_disable_rpath_hack=no])
1876 AC_MSG_RESULT($cf_disable_rpath_hack)
1877 if test "$cf_disable_rpath_hack" = no ; then
1881 dnl ---------------------------------------------------------------------------
1882 dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
1883 dnl -----------------------
1884 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
1885 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
1886 dnl an unconditional feature.
1887 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
1889 AC_MSG_CHECKING(if you want broken-linker support code)
1890 AC_ARG_ENABLE(broken_linker,
1891 [ --enable-broken_linker compile with broken-linker support code],
1892 [with_broken_linker=$enableval],
1893 [with_broken_linker=no])
1894 AC_MSG_RESULT($with_broken_linker)
1896 : ${BROKEN_LINKER:=0}
1897 if test "x$with_broken_linker" = xyes ; then
1898 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1901 AC_SUBST(BROKEN_LINKER)
1903 dnl ---------------------------------------------------------------------------
1904 dnl CF_ENABLE_PC_FILES version: 13 updated: 2015/11/01 05:27:39
1905 dnl ------------------
1906 dnl This is the "--enable-pc-files" option, which is available if there is a
1907 dnl pkg-config configuration on the local machine.
1908 AC_DEFUN([CF_ENABLE_PC_FILES],[
1909 AC_REQUIRE([CF_PKG_CONFIG])
1910 AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR])
1912 if test "x$PKG_CONFIG" != xnone
1914 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG)
1916 AC_MSG_CHECKING(if we should install .pc files)
1919 AC_ARG_ENABLE(pc-files,
1920 [ --enable-pc-files generate and install .pc files for pkg-config],
1921 [enable_pc_files=$enableval],
1922 [enable_pc_files=no])
1923 AC_MSG_RESULT($enable_pc_files)
1925 if test "x$enable_pc_files" != xno
1928 case "x$PKG_CONFIG_LIBDIR" in
1930 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found)
1933 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR)
1939 AC_SUBST(MAKE_PC_FILES)
1941 dnl ---------------------------------------------------------------------------
1942 dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42
1944 dnl Check if the rpath option should be used, setting cache variable
1945 dnl cf_cv_enable_rpath if so.
1946 AC_DEFUN([CF_ENABLE_RPATH],
1948 AC_MSG_CHECKING(if rpath option should be used)
1949 AC_ARG_ENABLE(rpath,
1950 [ --enable-rpath use rpath option when generating shared libraries],
1951 [cf_cv_enable_rpath=$enableval],
1952 [cf_cv_enable_rpath=no])
1953 AC_MSG_RESULT($cf_cv_enable_rpath)
1955 dnl ---------------------------------------------------------------------------
1956 dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11
1957 dnl ----------------------
1958 dnl On a few platforms, the compiler and/or loader nags with untruthful
1959 dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect,
1960 dnl and implying that most uses of the recommended alternatives are correct.
1962 dnl Factually speaking, no one has actually counted the number of uses of these
1963 dnl functions versus the total of incorrect uses. Samples of a few thousand
1964 dnl instances are meaningless compared to the hundreds of millions of lines of
1965 dnl existing C code.
1967 dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some
1968 dnl platforms, in implementations of varying quality. Likewise, snprintf is
1969 dnl standard - but evolved through phases, and older implementations are likely
1970 dnl to yield surprising results, as documented in manpages on various systems.
1971 AC_DEFUN([CF_ENABLE_STRING_HACKS],
1973 AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings)
1974 AC_ARG_ENABLE(string-hacks,
1975 [ --enable-string-hacks work around bogus compiler/loader warnings],
1976 [with_string_hacks=$enableval],
1977 [with_string_hacks=no])
1978 AC_MSG_RESULT($with_string_hacks)
1980 if test "x$with_string_hacks" = "xyes"; then
1981 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings])
1982 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings)
1983 AC_CHECK_FUNC(strlcat,[
1984 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1986 AC_CHECK_LIB(bsd,strlcat,[
1988 AC_CHECK_HEADERS(bsd/string.h)
1989 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function])
1992 AC_CHECK_FUNCS( strlcpy snprintf )
1995 dnl ---------------------------------------------------------------------------
1996 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
1997 dnl ------------------
1998 dnl Configure-option to enable gcc warnings
2000 dnl $1 = extra options to add, if supported
2001 dnl $2 = option for checking attributes. By default, this is done when
2002 dnl warnings are enabled. For other values:
2003 dnl yes: always do this, e.g., to use in generated library-headers
2004 dnl no: never do this
2005 AC_DEFUN([CF_ENABLE_WARNINGS],[
2006 if ( test "$GCC" = yes || test "$GXX" = yes )
2008 CF_FIX_WARNINGS(CFLAGS)
2009 CF_FIX_WARNINGS(CPPFLAGS)
2010 CF_FIX_WARNINGS(LDFLAGS)
2011 AC_MSG_CHECKING(if you want to turn on gcc warnings)
2012 CF_ARG_ENABLE(warnings,
2013 [ --enable-warnings test: turn on gcc compiler warnings],
2014 [with_warnings=yes],
2016 AC_MSG_RESULT($with_warnings)
2017 if test "$with_warnings" = "yes"
2019 ifelse($2,,[CF_GCC_ATTRIBUTES])
2022 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
2025 dnl ---------------------------------------------------------------------------
2026 dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39
2028 dnl Check if 'errno' is declared in <errno.h>
2029 AC_DEFUN([CF_ERRNO],
2031 CF_CHECK_ERRNO(errno)
2033 dnl ---------------------------------------------------------------------------
2034 dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07
2036 dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between
2037 dnl math.h and builtin.h, only for ncurses
2038 AC_DEFUN([CF_ETIP_DEFINES],
2040 AC_MSG_CHECKING(for special defines needed for etip.h)
2041 cf_save_CXXFLAGS="$CXXFLAGS"
2044 # etip.h includes ncurses.h which includes ncurses_dll.h
2045 # But ncurses_dll.h is generated - fix here.
2046 test -d include || mkdir include
2047 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
2049 for cf_math in "" MATH_H
2051 for cf_excp in "" MATH_EXCEPTION
2053 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include"
2054 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}"
2055 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}"
2057 #include <etip.h.in>
2059 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math})
2060 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp})
2061 cf_result="$cf_math $cf_excp"
2066 AC_MSG_RESULT($cf_result)
2067 CXXFLAGS="$cf_save_CXXFLAGS"
2069 dnl ---------------------------------------------------------------------------
2070 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
2072 dnl Find a library (specifically the linkage used in the code fragment),
2073 dnl searching for it if it is not already in the library path.
2074 dnl See also CF_ADD_SEARCHPATH.
2076 dnl Parameters (4-on are optional):
2077 dnl $1 = headers for library entrypoint
2078 dnl $2 = code fragment for library entrypoint
2079 dnl $3 = the library name without the "-l" option or ".so" suffix.
2080 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
2081 dnl $5 = action to perform if not successful
2082 dnl $6 = module name, if not the same as the library name
2083 dnl $7 = extra libraries
2085 dnl Sets these variables:
2086 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
2087 dnl $cf_cv_header_path_$3 - include-directory if needed
2088 dnl $cf_cv_library_path_$3 - library-directory if needed
2089 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
2090 AC_DEFUN([CF_FIND_LINKAGE],[
2092 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
2093 # will be set on completion of the AC_TRY_LINK below.
2094 cf_cv_header_path_$3=
2095 cf_cv_library_path_$3=
2097 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
2099 cf_save_LIBS="$LIBS"
2101 AC_TRY_LINK([$1],[$2],[
2102 cf_cv_find_linkage_$3=yes
2103 cf_cv_header_path_$3=/usr/include
2104 cf_cv_library_path_$3=/usr/lib
2107 LIBS="-l$3 $7 $cf_save_LIBS"
2109 AC_TRY_LINK([$1],[$2],[
2110 cf_cv_find_linkage_$3=yes
2111 cf_cv_header_path_$3=/usr/include
2112 cf_cv_library_path_$3=/usr/lib
2113 cf_cv_library_file_$3="-l$3"
2115 cf_cv_find_linkage_$3=no
2116 LIBS="$cf_save_LIBS"
2118 CF_VERBOSE(find linkage for $3 library)
2119 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
2121 cf_save_CPPFLAGS="$CPPFLAGS"
2122 cf_test_CPPFLAGS="$CPPFLAGS"
2124 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
2125 for cf_cv_header_path_$3 in $cf_search
2127 if test -d $cf_cv_header_path_$3 ; then
2128 CF_VERBOSE(... testing $cf_cv_header_path_$3)
2129 CPPFLAGS="$cf_save_CPPFLAGS"
2130 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
2131 AC_TRY_COMPILE([$1],[$2],[
2132 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
2133 cf_cv_find_linkage_$3=maybe
2134 cf_test_CPPFLAGS="$CPPFLAGS"
2136 CPPFLAGS="$cf_save_CPPFLAGS"
2141 if test "$cf_cv_find_linkage_$3" = maybe ; then
2143 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
2145 cf_save_LIBS="$LIBS"
2146 cf_save_LDFLAGS="$LDFLAGS"
2149 CPPFLAGS="$cf_test_CPPFLAGS"
2150 LIBS="-l$3 $7 $cf_save_LIBS"
2151 AC_TRY_LINK([$1],[$2],[
2152 CF_VERBOSE(... found $3 library in system)
2153 cf_cv_find_linkage_$3=yes])
2154 CPPFLAGS="$cf_save_CPPFLAGS"
2155 LIBS="$cf_save_LIBS"
2158 if test "$cf_cv_find_linkage_$3" != yes ; then
2159 CF_LIBRARY_PATH(cf_search,$3)
2160 for cf_cv_library_path_$3 in $cf_search
2162 if test -d $cf_cv_library_path_$3 ; then
2163 CF_VERBOSE(... testing $cf_cv_library_path_$3)
2164 CPPFLAGS="$cf_test_CPPFLAGS"
2165 LIBS="-l$3 $7 $cf_save_LIBS"
2166 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
2167 AC_TRY_LINK([$1],[$2],[
2168 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
2169 cf_cv_find_linkage_$3=yes
2170 cf_cv_library_file_$3="-l$3"
2172 CPPFLAGS="$cf_save_CPPFLAGS"
2173 LIBS="$cf_save_LIBS"
2174 LDFLAGS="$cf_save_LDFLAGS"
2178 CPPFLAGS="$cf_save_CPPFLAGS"
2179 LDFLAGS="$cf_save_LDFLAGS"
2183 cf_cv_find_linkage_$3=no
2188 LIBS="$cf_save_LIBS"
2190 if test "$cf_cv_find_linkage_$3" = yes ; then
2192 CF_ADD_INCDIR($cf_cv_header_path_$3)
2193 CF_ADD_LIBDIR($cf_cv_library_path_$3)
2197 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
2200 dnl ---------------------------------------------------------------------------
2201 dnl CF_FIND_SUB_INCDIR version: 2 updated: 2015/04/17 21:13:04
2202 dnl ------------------
2203 dnl Find an include-directory with the given leaf-name. This is useful for
2204 dnl example with FreeBSD ports, which use this convention to distinguish
2205 dnl different versions of the same port.
2206 AC_DEFUN([CF_FIND_SUB_INCDIR],[
2207 CF_SUBDIR_PATH(cf_search,$1,include)
2208 for cf_item in $cf_search
2212 CF_ADD_INCDIR($cf_item)
2217 dnl ---------------------------------------------------------------------------
2218 dnl CF_FIND_SUB_LIBDIR version: 2 updated: 2015/04/17 21:13:04
2219 dnl ------------------
2220 dnl Find a library-directory with the given leaf-name. This is useful for
2221 dnl example with FreeBSD ports, which use this convention to distinguish
2222 dnl different versions of the same port.
2223 AC_DEFUN([CF_FIND_SUB_LIBDIR],[
2224 CF_SUBDIR_PATH(cf_search,$1,lib)
2225 for cf_item in $cf_search
2229 CF_ADD_LIBDIR($cf_item)
2234 dnl ---------------------------------------------------------------------------
2235 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
2236 dnl -----------------
2237 dnl make ADAFLAGS consistent with CFLAGS
2238 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
2239 AC_MSG_CHECKING(optimization options for ADAFLAGS)
2247 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
2248 CF_ADD_ADAFLAGS($cf_O_flag)
2251 AC_MSG_RESULT($ADAFLAGS)
2253 dnl ---------------------------------------------------------------------------
2254 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
2256 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
2257 dnl "-Werror" flags can interfere with configure-checks. Those go into
2260 dnl $1 = variable name to repair
2261 define([CF_FIX_WARNINGS],[
2262 if ( test "$GCC" = yes || test "$GXX" = yes )
2266 CF_VERBOSE(repairing $1: [$]$1)
2268 for cf_temp_scan in [$]$1
2270 case "x$cf_temp_scan" in
2272 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
2275 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
2280 CF_VERBOSE(... fixed [$]$1)
2281 CF_VERBOSE(... extra $EXTRA_CFLAGS)
2285 AC_SUBST(EXTRA_CFLAGS)
2287 dnl ---------------------------------------------------------------------------
2288 dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54
2290 dnl Check if fopen works when the "b" (binary) flag is added to the mode
2291 dnl parameter. POSIX ignores the "b", which c89 specified. Some very old
2292 dnl systems do not accept it.
2293 AC_DEFUN([CF_FOPEN_BIN_R],[
2294 AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[
2298 FILE *fp = fopen("conftest.tmp", "wb");
2302 for (p = 0; p < 256; ++p) {
2306 fp = fopen("conftest.tmp", "rb");
2308 for (p = 0; p < 256; ++p) {
2321 ${cf_cv_main_return:-return} (rc);
2324 [cf_cv_fopen_bin_r=yes],
2325 [cf_cv_fopen_bin_r=no],
2326 [cf_cv_fopen_bin_r=unknown])
2328 test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode])
2330 dnl ---------------------------------------------------------------------------
2331 dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09
2333 dnl Forget that we saw the given tool.
2334 AC_DEFUN([CF_FORGET_TOOL],[
2335 unset ac_cv_prog_ac_ct_$1
2339 dnl ---------------------------------------------------------------------------
2340 dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44
2342 dnl Test for dlsym() and related functions, as well as libdl.
2347 AC_DEFUN([CF_FUNC_DLSYM],[
2349 AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[
2352 AC_CHECK_LIB(dl,dlsym,[
2354 cf_have_libdl=yes])])
2356 if test "$cf_have_dlsym" = yes ; then
2357 test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) }
2359 AC_MSG_CHECKING(whether able to link to dl*() functions)
2360 AC_TRY_LINK([#include <dlfcn.h>],[
2362 if ((obj = dlopen("filename", 0)) != 0) {
2363 if (dlsym(obj, "symbolname") == 0) {
2367 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[
2368 AC_MSG_ERROR(Cannot link test program for libdl)])
2371 AC_MSG_ERROR(Cannot find dlsym function)
2374 dnl ---------------------------------------------------------------------------
2375 dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25
2377 dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither
2378 dnl is found, add our own version of memmove to the list of objects.
2379 AC_DEFUN([CF_FUNC_MEMMOVE],
2381 AC_CHECK_FUNC(memmove,,[
2382 AC_CHECK_FUNC(bcopy,[
2383 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[
2386 static char data[] = "abcdefghijklmnopqrstuwwxyz";
2388 bcopy(data, temp, sizeof(data));
2389 bcopy(temp+10, temp, 15);
2390 bcopy(temp+5, temp+15, 10);
2391 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz"));
2394 [cf_cv_good_bcopy=yes],
2395 [cf_cv_good_bcopy=no],
2396 [cf_cv_good_bcopy=unknown])
2398 ],[cf_cv_good_bcopy=no])
2399 if test "$cf_cv_good_bcopy" = yes ; then
2400 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable])
2402 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable])
2405 dnl ---------------------------------------------------------------------------
2406 dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25
2407 dnl -----------------
2408 dnl Check for existence of workable nanosleep() function. Some systems, e.g.,
2409 dnl AIX 4.x, provide a non-working version.
2410 AC_DEFUN([CF_FUNC_NANOSLEEP],[
2411 AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[
2417 #ifdef HAVE_SYS_TIME_H
2418 #include <sys/time.h>
2422 struct timespec ts1, ts2;
2425 ts1.tv_nsec = 750000000;
2429 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */
2430 ${cf_cv_main_return:-return}(code != 0);
2433 [cf_cv_func_nanosleep=yes],
2434 [cf_cv_func_nanosleep=no],
2435 [cf_cv_func_nanosleep=unknown])])
2437 test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()])
2439 dnl ---------------------------------------------------------------------------
2440 dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50
2442 dnl Check for openpty() function, along with <pty.h> header. It may need the
2443 dnl "util" library as well.
2444 AC_DEFUN([CF_FUNC_OPENPTY],
2446 AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no)
2447 AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[
2448 cf_save_LIBS="$LIBS"
2449 test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) }
2450 for cf_header in pty.h libutil.h util.h
2453 #include <$cf_header>
2455 int x = openpty((int *)0, (int *)0, (char *)0,
2456 (struct termios *)0, (struct winsize *)0);
2458 cf_cv_func_openpty=$cf_header
2461 cf_cv_func_openpty=no
2464 LIBS="$cf_save_LIBS"
2467 dnl ---------------------------------------------------------------------------
2468 dnl CF_FUNC_POLL version: 9 updated: 2015/10/10 13:27:32
2470 dnl See if the poll function really works. Some platforms have poll(), but
2471 dnl it does not work for terminals or files.
2472 AC_DEFUN([CF_FUNC_POLL],[
2473 tty 2>&1 >/dev/null || { AC_CHECK_FUNCS(posix_openpt) }
2474 AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[
2483 #include <sys/poll.h>
2486 struct pollfd myfds;
2489 /* check for Darwin bug with respect to "devices" */
2490 myfds.fd = open("/dev/null", 1); /* O_WRONLY */
2493 myfds.events = POLLIN;
2496 ret = poll(&myfds, 1, 100);
2498 if (ret < 0 || (myfds.revents & POLLNVAL)) {
2503 fd = open("/dev/tty", 2); /* O_RDWR */
2505 #ifdef HAVE_POSIX_OPENPT
2507 fd = posix_openpt(O_RDWR);
2512 /* also check with standard input */
2514 myfds.events = POLLIN;
2516 ret = poll(&myfds, 1, 100);
2521 ${cf_cv_main_return:-return}(ret < 0);
2523 [cf_cv_working_poll=yes],
2524 [cf_cv_working_poll=no],
2525 [cf_cv_working_poll=unknown])])
2526 test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work])
2528 dnl ---------------------------------------------------------------------------
2529 dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13
2531 dnl Some old/broken variations define tcgetattr() only as a macro in
2533 AC_DEFUN([CF_FUNC_TERMIOS],[
2534 AC_REQUIRE([CF_STRUCT_TERMIOS])
2535 AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[
2537 #include <sys/types.h>
2538 #ifdef HAVE_UNISTD_H
2541 #ifdef HAVE_TERMIOS_H
2542 #include <termios.h>
2543 #define TTY struct termios
2545 #ifdef HAVE_TERMIO_H
2547 #define TTY struct termio
2552 tcgetattr(1, &foo);],
2553 [cf_cv_have_tcgetattr=yes],
2554 [cf_cv_have_tcgetattr=no])])
2555 test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr])
2557 dnl ---------------------------------------------------------------------------
2558 dnl CF_FUNC_VSSCANF version: 6 updated: 2015/04/18 08:56:57
2560 dnl Check for vsscanf() function, which is in c9x but generally not in earlier
2561 dnl versions of C. It is in the GNU C library, and can often be simulated by
2562 dnl other functions.
2563 AC_DEFUN([CF_FUNC_VSSCANF],
2565 AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[
2568 #include <stdio.h>],[
2570 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[
2573 #include <stdio.h>],[
2577 strbuf._flag = _IOREAD;
2578 strbuf._ptr = strbuf._base = (unsigned char *) str;
2579 strbuf._cnt = strlen(str);
2580 strbuf._file = _NFILE;
2581 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[
2584 #include <stdio.h>],[
2588 strbuf._flag = _IOREAD;
2589 strbuf._ptr = strbuf._base = (unsigned char *) str;
2590 strbuf._cnt = strlen(str);
2591 strbuf._file = _NFILE;
2592 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[
2593 cf_cv_func_vsscanf=no])])])])
2595 case $cf_cv_func_vsscanf in
2596 (vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);;
2597 (vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);;
2598 (_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);;
2602 dnl ---------------------------------------------------------------------------
2603 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
2604 dnl -----------------
2605 dnl Test for availability of useful gcc __attribute__ directives to quiet
2606 dnl compiler warnings. Though useful, not all are supported -- and contrary
2607 dnl to documentation, unrecognized directives cause older compilers to barf.
2608 AC_DEFUN([CF_GCC_ATTRIBUTES],
2610 if ( test "$GCC" = yes || test "$GXX" = yes )
2612 cat > conftest.i <<EOF
2614 #define GCC_PRINTF 0
2619 #ifndef GCC_NORETURN
2620 #define GCC_NORETURN /* nothing */
2623 #define GCC_UNUSED /* nothing */
2626 if test "$GCC" = yes
2628 AC_CHECKING([for $CC __attribute__ directives])
2629 cat > conftest.$ac_ext <<EOF
2630 #line __oline__ "${as_me:-configure}"
2631 #include "confdefs.h"
2632 #include "conftest.h"
2633 #include "conftest.i"
2635 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
2637 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
2640 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
2642 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
2644 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
2645 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
2646 extern void foo(void) GCC_NORETURN;
2647 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
2649 cf_printf_attribute=no
2650 cf_scanf_attribute=no
2651 for cf_attribute in scanf printf unused noreturn
2653 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
2654 cf_directive="__attribute__(($cf_attribute))"
2655 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
2657 case $cf_attribute in
2659 cf_printf_attribute=yes
2660 cat >conftest.h <<EOF
2661 #define GCC_$cf_ATTRIBUTE 1
2665 cf_scanf_attribute=yes
2666 cat >conftest.h <<EOF
2667 #define GCC_$cf_ATTRIBUTE 1
2671 cat >conftest.h <<EOF
2672 #define GCC_$cf_ATTRIBUTE $cf_directive
2677 if AC_TRY_EVAL(ac_compile); then
2678 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
2679 cat conftest.h >>confdefs.h
2680 case $cf_attribute in
2682 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
2685 cf_value='/* nothing */'
2686 if test "$cf_printf_attribute" != no ; then
2687 cf_value='__attribute__((format(printf,fmt,var)))'
2688 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
2690 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
2693 cf_value='/* nothing */'
2694 if test "$cf_scanf_attribute" != no ; then
2695 cf_value='__attribute__((format(scanf,fmt,var)))'
2696 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
2698 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
2701 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
2707 fgrep define conftest.i >>confdefs.h
2712 dnl ---------------------------------------------------------------------------
2713 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
2715 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
2716 dnl compatible), attempt to determine if icc/clang is actually used.
2717 AC_DEFUN([CF_GCC_VERSION],[
2718 AC_REQUIRE([AC_PROG_CC])
2720 if test "$GCC" = yes ; then
2721 AC_MSG_CHECKING(version of $CC)
2722 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.]].*//'`"
2723 test -z "$GCC_VERSION" && GCC_VERSION=unknown
2724 AC_MSG_RESULT($GCC_VERSION)
2726 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
2727 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
2729 dnl ---------------------------------------------------------------------------
2730 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
2732 dnl Check if the compiler supports useful warning options. There's a few that
2733 dnl we don't use, simply because they're too noisy:
2735 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
2736 dnl -Winline (usually not worthwhile)
2737 dnl -Wredundant-decls (system headers make this too noisy)
2738 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
2739 dnl -Wwrite-strings (too noisy, but should review occasionally). This
2740 dnl is enabled for ncurses using "--enable-const".
2744 dnl $1 is an optional list of gcc warning flags that a particular
2745 dnl application might want to use, e.g., "no-unused" for
2748 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
2750 AC_DEFUN([CF_GCC_WARNINGS],
2752 AC_REQUIRE([CF_GCC_VERSION])
2753 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
2754 cat > conftest.$ac_ext <<EOF
2755 #line __oline__ "${as_me:-configure}"
2756 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
2758 if test "$INTEL_COMPILER" = yes
2760 # The "-wdXXX" options suppress warnings:
2761 # remark #1419: external declaration in primary source file
2762 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2763 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
2764 # remark #193: zero used for undefined preprocessing identifier
2765 # remark #593: variable "curs_sb_left_arrow" was set but never used
2766 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
2767 # remark #869: parameter "tw" was never referenced
2768 # remark #981: operands are evaluated in unspecified order
2769 # warning #279: controlling expression is constant
2771 AC_CHECKING([for $CC warning options])
2772 cf_save_CFLAGS="$CFLAGS"
2773 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
2785 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2786 if AC_TRY_EVAL(ac_compile); then
2787 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2788 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2791 CFLAGS="$cf_save_CFLAGS"
2792 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
2794 AC_CHECKING([for $CC warning options])
2795 cf_save_CFLAGS="$CFLAGS"
2797 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
2798 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
2799 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
2800 for cf_opt in W Wall \
2801 Wbad-function-cast \
2804 Wdeclaration-after-statement \
2807 Wmissing-declarations \
2808 Wmissing-prototypes \
2812 Wstrict-prototypes \
2813 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
2815 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
2816 if AC_TRY_EVAL(ac_compile); then
2817 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
2820 case $GCC_VERSION in
2822 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2827 case $GCC_VERSION in
2829 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
2834 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
2837 CFLAGS="$cf_save_CFLAGS"
2841 AC_SUBST(EXTRA_CFLAGS)
2843 dnl ---------------------------------------------------------------------------
2844 dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54
2845 dnl ----------------
2846 dnl Check for getopt's variables which are commonly defined in stdlib.h,
2847 dnl unistd.h or (nonstandard) in getopt.h
2848 AC_DEFUN([CF_GETOPT_HEADER],
2850 AC_HAVE_HEADERS(unistd.h getopt.h)
2851 AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[
2852 cf_cv_getopt_header=none
2853 for cf_header in stdio.h stdlib.h unistd.h getopt.h
2856 #include <$cf_header>],
2857 [int x = optind; char *y = optarg],
2858 [cf_cv_getopt_header=$cf_header
2862 if test $cf_cv_getopt_header != none ; then
2863 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header])
2865 if test $cf_cv_getopt_header = getopt.h ; then
2866 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h])
2869 dnl ---------------------------------------------------------------------------
2870 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
2871 dnl -----------------
2872 AC_DEFUN([CF_GNATPREP_OPT_T],[
2873 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
2874 cf_cv_gnatprep_opt_t=no
2875 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
2877 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
2878 AC_SUBST(GNATPREP_OPTS)
2880 dnl ---------------------------------------------------------------------------
2881 dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
2882 dnl ----------------
2883 AC_DEFUN([CF_GNAT_GENERICS],
2885 AC_REQUIRE([CF_GNAT_VERSION])
2887 AC_MSG_CHECKING(if GNAT supports generics)
2888 case $cf_cv_gnat_version in
2889 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
2890 cf_gnat_generics=yes
2896 AC_MSG_RESULT($cf_gnat_generics)
2898 if test "$cf_gnat_generics" = yes
2900 cf_compile_generics=generics
2901 cf_generic_objects="\${GENOBJS}"
2903 cf_compile_generics=
2907 AC_SUBST(cf_compile_generics)
2908 AC_SUBST(cf_generic_objects)
2910 dnl ---------------------------------------------------------------------------
2911 dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54
2912 dnl ----------------
2913 dnl GNAT projects are configured with ".gpr" project files.
2914 dnl GNAT libraries are a further development, using the project feature.
2915 AC_DEFUN([CF_GNAT_PROJECTS],
2917 AC_REQUIRE([CF_GNAT_VERSION])
2918 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
2920 cf_gnat_libraries=no
2923 if test "$enable_gnat_projects" != no ; then
2924 AC_MSG_CHECKING(if GNAT supports project files)
2925 case $cf_cv_gnat_version in
2929 case $cf_cv_system_name in
2933 rm -rf conftest* *~conftest*
2934 if mkdir conftest.src conftest.bin conftest.lib
2937 rm -rf conftest* *~conftest*
2938 cat >>library.gpr <<CF_EOF
2940 Kind := External ("LIB_KIND");
2941 for Library_Name use "ConfTest";
2942 for Object_Dir use ".";
2943 for Library_ALI_Dir use External("LIBRARY_DIR");
2944 for Library_Version use External ("SONAME");
2945 for Library_Kind use Kind;
2946 for Library_Dir use External("BUILD_DIR");
2947 Source_Dir := External ("SOURCE_DIR");
2948 for Source_Dirs use (Source_Dir);
2951 cat >>confpackage.ads <<CF_EOF
2952 package ConfPackage is
2956 cat >>confpackage.adb <<CF_EOF
2958 package body ConfPackage is
2959 procedure conftest is
2961 Text_IO.Put ("Hello World");
2966 if ( $cf_ada_make $ADAFLAGS \
2968 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
2969 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
2970 -XSOURCE_DIR=`pwd` \
2971 -XSONAME=libConfTest.so.1 \
2972 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
2973 cf_gnat_projects=yes
2977 if test -f conftest.lib/confpackage.ali
2979 cf_gnat_libraries=yes
2981 rm -rf conftest* *~conftest*
2986 AC_MSG_RESULT($cf_gnat_projects)
2987 fi # enable_gnat_projects
2989 if test $cf_gnat_projects = yes
2991 AC_MSG_CHECKING(if GNAT supports libraries)
2992 AC_MSG_RESULT($cf_gnat_libraries)
2995 if test "$cf_gnat_projects" = yes
2997 USE_OLD_MAKERULES="#"
2998 USE_GNAT_PROJECTS=""
3000 USE_OLD_MAKERULES=""
3001 USE_GNAT_PROJECTS="#"
3004 if test "$cf_gnat_libraries" = yes
3006 USE_GNAT_LIBRARIES=""
3008 USE_GNAT_LIBRARIES="#"
3011 AC_SUBST(USE_OLD_MAKERULES)
3012 AC_SUBST(USE_GNAT_PROJECTS)
3013 AC_SUBST(USE_GNAT_LIBRARIES)
3015 dnl ---------------------------------------------------------------------------
3016 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
3018 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
3019 dnl is noted that gnat may compile a tasking unit even for configurations which
3020 dnl fail at runtime.
3021 AC_DEFUN([CF_GNAT_SIGINT],[
3022 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
3023 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
3027 pragma Warnings (Off); -- the next pragma exists since 3.11p
3028 pragma Unreserve_All_Interrupts;
3029 pragma Warnings (On);
3031 protected Process is
3033 function Continue return Boolean;
3034 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
3036 Done : Boolean := False;
3040 [package body ConfTest is
3041 protected body Process is
3046 function Continue return Boolean is
3052 [cf_cv_gnat_sigint=yes],
3053 [cf_cv_gnat_sigint=no])])
3055 if test $cf_cv_gnat_sigint = yes ; then
3060 AC_SUBST(USE_GNAT_SIGINT)
3062 dnl ---------------------------------------------------------------------------
3063 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
3064 dnl ----------------
3065 dnl Verify that a test program compiles/links with GNAT.
3066 dnl $cf_ada_make is set to the program that compiles/links
3067 dnl $ADAFLAGS may be set to the GNAT flags.
3069 dnl $1 is the text of the spec
3070 dnl $2 is the text of the body
3071 dnl $3 is the shell command to execute if successful
3072 dnl $4 is the shell command to execute if not successful
3073 AC_DEFUN([CF_GNAT_TRY_LINK],
3075 rm -rf conftest* *~conftest*
3076 cat >>conftest.ads <<CF_EOF
3079 cat >>conftest.adb <<CF_EOF
3082 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3083 ifelse($3,, :,[ $3])
3087 rm -rf conftest* *~conftest*
3089 dnl ---------------------------------------------------------------------------
3090 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
3092 dnl Verify that a test program compiles and runs with GNAT
3093 dnl $cf_ada_make is set to the program that compiles/links
3094 dnl $ADAFLAGS may be set to the GNAT flags.
3096 dnl $1 is the text of the spec
3097 dnl $2 is the text of the body
3098 dnl $3 is the shell command to execute if successful
3099 dnl $4 is the shell command to execute if not successful
3100 AC_DEFUN([CF_GNAT_TRY_RUN],
3102 rm -rf conftest* *~conftest*
3103 cat >>conftest.ads <<CF_EOF
3106 cat >>conftest.adb <<CF_EOF
3109 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
3110 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
3111 ifelse($3,, :,[ $3])
3118 rm -rf conftest* *~conftest*
3120 dnl ---------------------------------------------------------------------------
3121 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
3123 dnl $1 = cache variable to update
3124 dnl $2 = program name
3125 dnl Verify version of GNAT or related tool
3126 AC_DEFUN([CF_GNAT_VERSION],
3128 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
3129 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
3130 grep '[[0-9]].[[0-9]][[0-9]]*' |\
3131 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
3133 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
3134 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
3136 dnl ---------------------------------------------------------------------------
3137 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
3139 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
3140 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
3141 dnl (or misfeature) of glibc2, which breaks portability of many applications,
3142 dnl since it is interwoven with GNU extensions.
3144 dnl Well, yes we could work around it...
3147 dnl $1 is the nominal value for _XOPEN_SOURCE
3148 AC_DEFUN([CF_GNU_SOURCE],
3150 cf_gnu_xopen_source=ifelse($1,,500,$1)
3152 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
3153 AC_TRY_COMPILE([#include <sys/types.h>],[
3154 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
3156 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
3159 # error not GNU C library
3161 [cf_cv_gnu_library=yes],
3162 [cf_cv_gnu_library=no])
3165 if test x$cf_cv_gnu_library = xyes; then
3167 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
3168 # was changed to help a little. newlib incorporated the change about 4
3170 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
3172 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3173 AC_TRY_COMPILE([#include <sys/types.h>],[
3174 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
3176 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
3179 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
3181 [cf_cv_gnu_library_219=yes],
3182 [cf_cv_gnu_library_219=no])
3186 if test "x$cf_cv_gnu_library_219" = xyes; then
3188 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
3189 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
3192 #include <sys/types.h>
3194 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
3197 # error GNU C library is too old
3199 [cf_cv_gnu_dftsrc_219=yes],
3200 [cf_cv_gnu_dftsrc_219=no])
3202 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
3204 cf_cv_gnu_dftsrc_219=maybe
3207 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
3209 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
3210 AC_TRY_COMPILE([#include <sys/types.h>],[
3211 #ifndef _XOPEN_SOURCE
3212 #error expected _XOPEN_SOURCE to be defined
3214 [cf_cv_gnu_source=no],
3215 [cf_save="$CPPFLAGS"
3216 CF_ADD_CFLAGS(-D_GNU_SOURCE)
3217 AC_TRY_COMPILE([#include <sys/types.h>],[
3218 #ifdef _XOPEN_SOURCE
3219 #error expected _XOPEN_SOURCE to be undefined
3221 [cf_cv_gnu_source=no],
3222 [cf_cv_gnu_source=yes])
3227 if test "$cf_cv_gnu_source" = yes
3229 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
3230 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
3231 AC_TRY_COMPILE([#include <sys/types.h>],[
3232 #ifdef _DEFAULT_SOURCE
3233 #error expected _DEFAULT_SOURCE to be undefined
3235 [cf_cv_default_source=no],
3236 [cf_cv_default_source=yes])
3238 if test "$cf_cv_default_source" = yes
3240 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
3247 dnl ---------------------------------------------------------------------------
3248 dnl CF_GPP_LIBRARY version: 12 updated: 2015/04/17 21:13:04
3250 dnl If we're trying to use g++, test if libg++ is installed (a rather common
3251 dnl problem :-). If we have the compiler but no library, we'll be able to
3252 dnl configure, but won't be able to build the c++ demo program.
3253 AC_DEFUN([CF_GPP_LIBRARY],
3255 cf_cxx_library=unknown
3256 case $cf_cv_system_name in
3264 if test "$GXX" = yes; then
3265 AC_MSG_CHECKING([for lib$cf_gpp_libname])
3267 CF_ADD_LIB($cf_gpp_libname)
3269 #include <$cf_gpp_libname/builtin.h>
3271 [two_arg_error_handler_t foo2 = lib_error_handler],
3273 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3274 if test "$cf_gpp_libname" = cpp ; then
3275 AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h])
3277 AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h])
3280 #include <builtin.h>
3282 [two_arg_error_handler_t foo2 = lib_error_handler],
3284 CF_ADD_LIB($cf_gpp_libname,CXXLIBS)
3285 AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])],
3286 [cf_cxx_library=no])])
3288 AC_MSG_RESULT($cf_cxx_library)
3291 dnl ---------------------------------------------------------------------------
3292 dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57
3294 dnl Check for version of g++
3295 AC_DEFUN([CF_GXX_VERSION],[
3296 AC_REQUIRE([AC_PROG_CPP])
3298 if test "$GXX" = yes; then
3299 AC_MSG_CHECKING(version of ${CXX:-g++})
3300 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
3301 if test -z "$GXX_VERSION"
3306 AC_MSG_RESULT($GXX_VERSION)
3309 dnl ---------------------------------------------------------------------------
3310 dnl CF_GXX_WARNINGS version: 9 updated: 2015/04/17 21:13:04
3312 dnl Check if the compiler supports useful warning options.
3314 dnl Most of gcc's options apply to g++, except:
3315 dnl -Wbad-function-cast
3316 dnl -Wmissing-declarations
3317 dnl -Wnested-externs
3319 dnl Omit a few (for now):
3323 dnl $1 is an optional list of g++ warning flags that a particular
3324 dnl application might want to use, e.g., "no-unused" for
3327 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
3329 AC_DEFUN([CF_GXX_WARNINGS],
3332 CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS)
3333 CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS)
3335 AC_REQUIRE([CF_GXX_VERSION])
3340 cat > conftest.$ac_ext <<EOF
3341 #line __oline__ "configure"
3342 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
3345 if test "$INTEL_CPLUSPLUS" = yes
3347 # The "-wdXXX" options suppress warnings:
3348 # remark #1419: external declaration in primary source file
3349 # remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3350 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
3351 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
3352 # remark #193: zero used for undefined preprocessing identifier
3353 # remark #593: variable "curs_sb_left_arrow" was set but never used
3354 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
3355 # remark #869: parameter "tw" was never referenced
3356 # remark #981: operands are evaluated in unspecified order
3357 # warning #269: invalid format string conversion
3359 AC_CHECKING([for $CC warning options])
3360 cf_save_CXXFLAGS="$CXXFLAGS"
3361 EXTRA_CXXFLAGS="-Wall"
3374 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt"
3375 if AC_TRY_EVAL(ac_compile); then
3376 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3377 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3380 CXXFLAGS="$cf_save_CXXFLAGS"
3382 elif test "$GXX" = yes
3384 AC_CHECKING([for $CXX warning options])
3385 cf_save_CXXFLAGS="$CXXFLAGS"
3386 EXTRA_CXXFLAGS="-W -Wall"
3387 cf_gxx_extra_warnings=""
3388 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings"
3389 case "$GCC_VERSION" in
3393 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++"
3400 Wignored-qualifiers \
3402 Woverloaded-virtual \
3410 Wundef $cf_gxx_extra_warnings $1
3412 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt"
3413 if AC_TRY_EVAL(ac_compile); then
3414 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
3415 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt"
3417 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt)
3420 CXXFLAGS="$cf_save_CXXFLAGS"
3425 AC_SUBST(EXTRA_CXXFLAGS)
3427 dnl ---------------------------------------------------------------------------
3428 dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57
3430 dnl Look for an instance of the Berkeley hashed database.
3432 dnl $1 = optional parameter, to specify install-prefix for the database.
3433 AC_DEFUN([CF_HASHED_DB],
3440 if test -d "$1" ; then
3441 CF_ADD_INCDIR($1/include)
3442 CF_ADD_LIBDIR($1/lib)
3446 AC_MSG_WARN(no such directory $1)
3449 CF_FIND_SUB_INCDIR($1)
3450 CF_FIND_SUB_LIBDIR($1)
3456 AC_CHECK_HEADER(db.h,[
3457 CF_HASHED_DB_VERSION
3458 if test "$cf_cv_hashed_db_version" = unknown ; then
3459 AC_MSG_ERROR(Cannot determine version of db)
3462 if test "$cf_cv_hashed_db_libs" = unknown ; then
3463 AC_MSG_ERROR(Cannot determine library for db)
3464 elif test "$cf_cv_hashed_db_libs" != default ; then
3465 CF_ADD_LIB($cf_cv_hashed_db_libs)
3469 AC_MSG_ERROR(Cannot find db.h)
3472 dnl ---------------------------------------------------------------------------
3473 dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02
3474 dnl -----------------
3475 dnl Given that we have the header and version for hashed database, find the
3476 dnl library information.
3477 AC_DEFUN([CF_HASHED_DB_LIBS],
3479 AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[
3480 cf_cv_hashed_db_libs=unknown
3481 for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db ''
3483 cf_save_libs="$LIBS"
3484 if test -n "$cf_db_libs"; then
3485 CF_ADD_LIB($cf_db_libs)
3487 CF_MSG_LOG(checking for library "$cf_db_libs")
3489 $ac_includes_default
3492 char *path = "/tmp/foo";
3493 #ifdef DB_VERSION_MAJOR
3494 #if DB_VERSION_MAJOR >= 4
3496 db_create(&result, NULL, 0);
3497 result->open(result,
3504 #elif DB_VERSION_MAJOR >= 3
3506 db_create(&result, NULL, 0);
3507 result->open(result,
3513 #elif DB_VERSION_MAJOR >= 2
3522 #endif /* DB_VERSION_MAJOR */
3524 DB *result = dbopen(path,
3530 ${cf_cv_main_return:-return}(result != 0)
3532 if test -n "$cf_db_libs" ; then
3533 cf_cv_hashed_db_libs=$cf_db_libs
3535 cf_cv_hashed_db_libs=default
3537 LIBS="$cf_save_libs"
3540 LIBS="$cf_save_libs"
3544 dnl ---------------------------------------------------------------------------
3545 dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01
3546 dnl --------------------
3547 dnl Given that we have the header file for hashed database, find the version
3549 AC_DEFUN([CF_HASHED_DB_VERSION],
3551 AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[
3552 cf_cv_hashed_db_version=unknown
3554 for cf_db_version in 1 2 3 4 5 6
3556 CF_MSG_LOG(checking for db version $cf_db_version)
3558 $ac_includes_default
3561 #ifdef DB_VERSION_MAJOR
3562 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */
3563 #if $cf_db_version == DB_VERSION_MAJOR
3569 #if $cf_db_version == 1
3570 /* ok: assuming this is DB 1.8.5 */
3576 cf_cv_hashed_db_version=$cf_db_version
3582 dnl ---------------------------------------------------------------------------
3583 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
3585 dnl Construct a search-list of directories for a nonstandard header-file
3588 dnl $1 = the variable to return as result
3589 dnl $2 = the package name
3590 AC_DEFUN([CF_HEADER_PATH],
3594 # collect the current set of include-directories from compiler flags
3595 cf_header_path_list=""
3596 if test -n "${CFLAGS}${CPPFLAGS}" ; then
3597 for cf_header_path in $CPPFLAGS $CFLAGS
3599 case $cf_header_path in
3601 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
3602 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
3603 cf_header_path_list="$cf_header_path_list [$]$1"
3609 # add the variations for the package we are looking for
3610 CF_SUBDIR_PATH($1,$2,include)
3612 test "$includedir" != NONE && \
3613 test "$includedir" != "/usr/include" && \
3614 test -d "$includedir" && {
3615 test -d $includedir && $1="[$]$1 $includedir"
3616 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
3619 test "$oldincludedir" != NONE && \
3620 test "$oldincludedir" != "/usr/include" && \
3621 test -d "$oldincludedir" && {
3622 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
3623 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
3626 $1="[$]$1 $cf_header_path_list"
3628 dnl ---------------------------------------------------------------------------
3629 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
3631 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
3632 AC_DEFUN([CF_HELP_MESSAGE],
3633 [CF_ACVERSION_CHECK(2.53,[],[
3634 AC_DIVERT_HELP($1)])dnl
3636 dnl ---------------------------------------------------------------------------
3637 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
3639 dnl Construct the list of include-options according to whether we're building
3640 dnl in the source directory or using '--srcdir=DIR' option.
3641 AC_DEFUN([CF_INCLUDE_DIRS],
3643 if test "$srcdir" != "."; then
3644 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
3646 CPPFLAGS="-I../include $CPPFLAGS"
3647 if test "$srcdir" != "."; then
3648 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
3650 CPPFLAGS="-I. $CPPFLAGS"
3653 dnl ---------------------------------------------------------------------------
3654 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
3656 dnl prompt for/fill-in useful install-program options
3657 AC_DEFUN([CF_INSTALL_OPTS],
3663 dnl ---------------------------------------------------------------------------
3664 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
3665 dnl ----------------
3666 dnl Almost all "install" programs default to the current user's ownership.
3667 dnl Almost - MINIX is an exception.
3668 AC_DEFUN([CF_INSTALL_OPT_O],
3670 AC_MSG_CHECKING(if install needs to be told about ownership)
3671 case `$ac_config_guess` in
3680 AC_MSG_RESULT($with_install_o)
3681 if test "x$with_install_o" = xyes
3683 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'`
3688 AC_SUBST(INSTALL_OPT_O)
3690 dnl ---------------------------------------------------------------------------
3691 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
3692 dnl ----------------
3693 dnl Some install-programs accept a "-p" option to preserve file modification
3694 dnl timestamps. That can be useful as an install option, as well as a way to
3695 dnl avoid the need for ranlib after copying a static archive.
3696 AC_DEFUN([CF_INSTALL_OPT_P],
3698 : ${INSTALL:=install}
3699 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
3704 if $INSTALL -p conftest.in conftest.out 2>/dev/null
3706 if test -f conftest.out/conftest.in
3708 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
3709 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
3710 if test -s conftest.err
3725 dnl ---------------------------------------------------------------------------
3726 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
3727 dnl ----------------
3728 dnl By default, we should strip executables which are installed, but leave the
3729 dnl ability to suppress that for unit-testing.
3730 AC_DEFUN([CF_INSTALL_OPT_S],
3732 AC_MSG_CHECKING(if you want to install stripped executables)
3733 CF_ARG_DISABLE(stripping,
3734 [ --disable-stripping do not strip (debug info) installed executables],
3735 [with_stripping=no],
3736 [with_stripping=yes])
3737 AC_MSG_RESULT($with_stripping)
3739 if test "$with_stripping" = yes
3745 AC_SUBST(INSTALL_OPT_S)
3747 dnl ---------------------------------------------------------------------------
3748 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
3749 dnl -----------------
3750 dnl Check if the given compiler is really the Intel compiler for Linux. It
3751 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
3752 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
3754 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
3755 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
3756 dnl the wrappers for gcc and g++ warnings.
3758 dnl $1 = GCC (default) or GXX
3759 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
3760 dnl $3 = CFLAGS (default) or CXXFLAGS
3761 AC_DEFUN([CF_INTEL_COMPILER],[
3762 AC_REQUIRE([AC_CANONICAL_HOST])
3763 ifelse([$2],,INTEL_COMPILER,[$2])=no