1 dnl***************************************************************************
2 dnl Copyright 2018-2020,2021 Thomas E. Dickey *
3 dnl Copyright 2010-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
32 dnl $Id: aclocal.m4,v 1.171 2021/01/06 01:29:44 tom Exp $
33 dnl Macros used in NCURSES Ada95 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 CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49
46 dnl ------------------
47 dnl Conditionally generate script according to whether we're using a given autoconf.
49 dnl $1 = version to compare against
50 dnl $2 = code to use if AC_ACVERSION is at least as high as $1.
51 dnl $3 = code to use if AC_ACVERSION is older than $1.
52 define([CF_ACVERSION_CHECK],
54 ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl
55 ifdef([m4_version_compare],
56 [m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])],
57 [CF_ACVERSION_COMPARE(
58 AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])),
59 AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl
60 dnl ---------------------------------------------------------------------------
61 dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53
62 dnl --------------------
63 dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1,
64 dnl MAJOR2, MINOR2, TERNARY2,
65 dnl PRINTABLE2, not FOUND, FOUND)
66 define([CF_ACVERSION_COMPARE],
67 [ifelse(builtin([eval], [$2 < $5]), 1,
68 [ifelse([$8], , ,[$8])],
69 [ifelse([$9], , ,[$9])])])dnl
70 dnl ---------------------------------------------------------------------------
71 dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07
72 dnl -------------------
73 dnl Construct the list of include-options for the C programs in the Ada95
75 AC_DEFUN([CF_ADA_INCLUDE_DIRS],
77 ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS"
78 if test "$srcdir" != "."; then
79 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS"
81 if test "$GCC" != yes; then
82 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
83 elif test "$includedir" != "/usr/include"; then
84 if test "$includedir" = '${prefix}/include' ; then
85 if test x$prefix != x/usr ; then
86 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
89 ACPPFLAGS="$ACPPFLAGS -I\${includedir}"
94 dnl ---------------------------------------------------------------------------
95 dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18
97 dnl Add to $ADAFLAGS, which is substituted into makefile and scripts.
98 AC_DEFUN([CF_ADD_ADAFLAGS],[
99 ADAFLAGS="$ADAFLAGS $1"
102 dnl ---------------------------------------------------------------------------
103 dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15
105 dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS
106 dnl $1 = flags to add
107 dnl $2 = if given makes this macro verbose.
109 dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS,
110 dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily
111 dnl confused by the quotes (which require backslashes to keep them usable).
112 AC_DEFUN([CF_ADD_CFLAGS],
117 cf_new_extra_cppflags=
119 for cf_add_cflags in $1
121 case "$cf_fix_cppflags" in
123 case "$cf_add_cflags" in
124 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C)
125 case "$cf_add_cflags" in
127 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'`
129 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
130 && test -z "${cf_tst_cflags}" \
131 && cf_fix_cppflags=yes
133 if test "$cf_fix_cppflags" = yes ; then
134 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
136 elif test "${cf_tst_cflags}" = "\"'" ; then
137 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
146 case "$cf_add_cflags" in
148 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'`
149 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags)
152 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags)
157 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags)
162 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags)
164 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'`
166 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \
167 && test -z "${cf_tst_cflags}" \
168 && cf_fix_cppflags=no
173 if test -n "$cf_new_cflags" ; then
174 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)])
175 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags)
178 if test -n "$cf_new_cppflags" ; then
179 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)])
180 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags)
183 if test -n "$cf_new_extra_cppflags" ; then
184 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)])
185 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags)
188 AC_SUBST(EXTRA_CPPFLAGS)
191 dnl ---------------------------------------------------------------------------
192 dnl CF_ADD_INCDIR version: 16 updated: 2020/12/31 20:19:42
194 dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's
195 dnl redundant. We don't normally need to add -I/usr/local/include for gcc,
196 dnl but old versions (and some misinstalled ones) need that. To make things
197 dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to
198 dnl the include-path).
199 AC_DEFUN([CF_ADD_INCDIR],
201 if test -n "$1" ; then
202 for cf_add_incdir in $1
204 while test "$cf_add_incdir" != /usr/include
206 if test -d "$cf_add_incdir"
209 if test -n "$CFLAGS$CPPFLAGS" ; then
210 # a loop is needed to ensure we can add subdirs of existing dirs
211 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do
212 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then
213 cf_have_incdir=yes; break
218 if test "$cf_have_incdir" = no ; then
219 if test "$cf_add_incdir" = /usr/local/include ; then
222 cf_save_CPPFLAGS=$CPPFLAGS
223 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir)
224 AC_TRY_COMPILE([#include <stdio.h>],
227 [cf_have_incdir=yes])
228 CPPFLAGS=$cf_save_CPPFLAGS
233 if test "$cf_have_incdir" = no ; then
234 CF_VERBOSE(adding $cf_add_incdir to include-path)
235 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir"
237 cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'`
238 test "$cf_top_incdir" = "$cf_add_incdir" && break
239 cf_add_incdir="$cf_top_incdir"
250 dnl ---------------------------------------------------------------------------
251 dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05
253 dnl Add a library, used to enforce consistency.
255 dnl $1 = library to add, without the "-l"
256 dnl $2 = variable to update (default $LIBS)
257 AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl
258 dnl ---------------------------------------------------------------------------
259 dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42
261 dnl Adds to the library-path
263 dnl Some machines have trouble with multiple -L options.
265 dnl $1 is the (list of) directory(s) to add
266 dnl $2 is the optional name of the variable to update (default LDFLAGS)
268 AC_DEFUN([CF_ADD_LIBDIR],
270 if test -n "$1" ; then
271 for cf_add_libdir in $1
273 if test "$cf_add_libdir" = /usr/lib ; then
275 elif test -d "$cf_add_libdir"
278 if test -n "$LDFLAGS$LIBS" ; then
279 # a loop is needed to ensure we can add subdirs of existing dirs
280 for cf_test_libdir in $LDFLAGS $LIBS ; do
281 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then
282 cf_have_libdir=yes; break
286 if test "$cf_have_libdir" = no ; then
287 CF_VERBOSE(adding $cf_add_libdir to library-path)
288 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])"
294 dnl ---------------------------------------------------------------------------
295 dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33
297 dnl Add one or more libraries, used to enforce consistency. Libraries are
298 dnl prepended to an existing list, since their dependencies are assumed to
299 dnl already exist in the list.
301 dnl $1 = libraries to add, with the "-l", etc.
302 dnl $2 = variable to update (default $LIBS)
303 AC_DEFUN([CF_ADD_LIBS],[
304 cf_add_libs="[$]ifelse($2,,LIBS,[$2])"
307 for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done
309 for cf_add_1lib in $cf_add_0lib; do
310 for cf_add_2lib in $cf_add_libs; do
311 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then
316 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs"
318 ifelse($2,,LIBS,[$2])="$cf_add_libs"
320 dnl ---------------------------------------------------------------------------
321 dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42
322 dnl ------------------
323 dnl Append to a search-list for a nonstandard header/lib-file
324 dnl $1 = the variable to return as result
325 dnl $2 = the package name
326 dnl $3 = the subdirectory, e.g., bin, include or lib
327 dnl $4 = the directory under which we will test for subdirectories
328 dnl $5 = a directory that we do not want $4 to match
329 AC_DEFUN([CF_ADD_SUBDIR_PATH],
331 test "x$4" != "x$5" && \
333 ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) {
334 test -n "$verbose" && echo " ... testing for $3-directories under $4"
335 test -d "$4/$3" && $1="[$]$1 $4/$3"
336 test -d "$4/$3/$2" && $1="[$]$1 $4/$3/$2"
337 test -d "$4/$3/$2/$3" && $1="[$]$1 $4/$3/$2/$3"
338 test -d "$4/$2/$3" && $1="[$]$1 $4/$2/$3"
339 test -d "$4/$2/$3/$2" && $1="[$]$1 $4/$2/$3/$2"
342 dnl ---------------------------------------------------------------------------
343 dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55
345 dnl use this macro for appending text without introducing an extra blank at
347 define([CF_APPEND_TEXT],
349 test -n "[$]$1" && $1="[$]$1 "
352 dnl ---------------------------------------------------------------------------
353 dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31
355 dnl Allow user to disable a normally-on option.
356 AC_DEFUN([CF_ARG_DISABLE],
357 [CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl
358 dnl ---------------------------------------------------------------------------
359 dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31
361 dnl Allow user to enable a normally-off option.
362 AC_DEFUN([CF_ARG_ENABLE],
363 [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl
364 dnl ---------------------------------------------------------------------------
365 dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14
367 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
373 dnl $3 = action to perform if option is not default
374 dnl $4 = action if perform if option is default
375 dnl $5 = default option value (either 'yes' or 'no')
376 AC_DEFUN([CF_ARG_OPTION],
377 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
378 if test "$enableval" != "$5" ; then
380 ,[ $3]) ifelse([$4],,,[
383 fi],[enableval=$5 ifelse([$4],,,[
387 dnl ---------------------------------------------------------------------------
388 dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04
390 dnl Check for suitable "ar" (archiver) options for updating an archive.
392 dnl In particular, handle some obsolete cases where the "-" might be omitted,
393 dnl as well as a workaround for breakage of make's archive rules by the GNU
394 dnl binutils "ar" program.
395 AC_DEFUN([CF_AR_FLAGS],[
396 AC_REQUIRE([CF_PROG_AR])
398 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
399 case "$cf_cv_system_name" in
402 cat >mk_static_lib.sh <<-EOF
407 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
409 chmod +x mk_static_lib.sh
410 AR=`pwd`/mk_static_lib.sh
413 cf_cv_ar_flags=unknown
414 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
417 # check if $ARFLAGS already contains this choice
418 if test "x$ARFLAGS" != "x" ; then
419 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
420 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
426 rm -f "conftest.$ac_cv_objext"
429 cat >"conftest.$ac_ext" <<EOF
430 #line __oline__ "configure"
431 int testdata[[3]] = { 123, 456, 789 };
433 if AC_TRY_EVAL(ac_compile) ; then
434 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
435 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null
436 if test -f conftest.a ; then
437 cf_cv_ar_flags="$cf_ar_flags"
441 CF_VERBOSE(cannot compile test-program)
445 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext"
450 if test -n "$ARFLAGS" ; then
451 if test -n "$cf_cv_ar_flags" ; then
452 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
455 ARFLAGS=$cf_cv_ar_flags
460 dnl ---------------------------------------------------------------------------
461 dnl CF_BUILD_CC version: 9 updated: 2021/01/02 09:31:20
463 dnl If we're cross-compiling, allow the user to override the tools and their
464 dnl options. The configure script is oriented toward identifying the host
465 dnl compiler, etc., but we need a build compiler to generate parts of the
468 dnl $1 = default for $CPPFLAGS
469 dnl $2 = default for $LIBS
470 AC_DEFUN([CF_BUILD_CC],[
471 CF_ACVERSION_CHECK(2.52,,
472 [AC_REQUIRE([CF_PROG_EXT])])
473 if test "$cross_compiling" = yes ; then
475 # defaults that we might want to override
476 : ${BUILD_CFLAGS:=''}
477 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
478 : ${BUILD_LDFLAGS:=''}
479 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
480 : ${BUILD_EXEEXT:='$x'}
481 : ${BUILD_OBJEXT:='o'}
483 AC_ARG_WITH(build-cc,
484 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
485 [BUILD_CC="$withval"],
486 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
487 AC_MSG_CHECKING(for native build C compiler)
488 AC_MSG_RESULT($BUILD_CC)
490 AC_MSG_CHECKING(for native build C preprocessor)
491 AC_ARG_WITH(build-cpp,
492 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
493 [BUILD_CPP="$withval"],
494 [BUILD_CPP='${BUILD_CC} -E'])
495 AC_MSG_RESULT($BUILD_CPP)
497 AC_MSG_CHECKING(for native build C flags)
498 AC_ARG_WITH(build-cflags,
499 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
500 [BUILD_CFLAGS="$withval"])
501 AC_MSG_RESULT($BUILD_CFLAGS)
503 AC_MSG_CHECKING(for native build C preprocessor-flags)
504 AC_ARG_WITH(build-cppflags,
505 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
506 [BUILD_CPPFLAGS="$withval"])
507 AC_MSG_RESULT($BUILD_CPPFLAGS)
509 AC_MSG_CHECKING(for native build linker-flags)
510 AC_ARG_WITH(build-ldflags,
511 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
512 [BUILD_LDFLAGS="$withval"])
513 AC_MSG_RESULT($BUILD_LDFLAGS)
515 AC_MSG_CHECKING(for native build linker-libraries)
516 AC_ARG_WITH(build-libs,
517 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
518 [BUILD_LIBS="$withval"])
519 AC_MSG_RESULT($BUILD_LIBS)
521 # this assumes we're on Unix.
525 : ${BUILD_CC:='${CC}'}
527 if { test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}'; } ; then
528 AC_MSG_ERROR([Cross-build requires two compilers.
529 Use --with-build-cc to specify the native compiler.])
533 : ${BUILD_CC:='${CC}'}
534 : ${BUILD_CPP:='${CPP}'}
535 : ${BUILD_CFLAGS:='${CFLAGS}'}
536 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
537 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
538 : ${BUILD_LIBS:='${LIBS}'}
539 : ${BUILD_EXEEXT:='$x'}
540 : ${BUILD_OBJEXT:='o'}
545 AC_SUBST(BUILD_CFLAGS)
546 AC_SUBST(BUILD_CPPFLAGS)
547 AC_SUBST(BUILD_LDFLAGS)
549 AC_SUBST(BUILD_EXEEXT)
550 AC_SUBST(BUILD_OBJEXT)
552 dnl ---------------------------------------------------------------------------
553 dnl CF_CC_ENV_FLAGS version: 10 updated: 2020/12/31 18:40:20
555 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
556 dnl into CC. This will not help with broken scripts that wrap the compiler
557 dnl with options, but eliminates a more common category of user confusion.
559 dnl In particular, it addresses the problem of being able to run the C
560 dnl preprocessor in a consistent manner.
562 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
563 dnl the nuisance of having inconsistent settings for compiler and preprocessor
564 dnl outweighs that limitation.
565 AC_DEFUN([CF_CC_ENV_FLAGS],
567 # This should have been defined by AC_PROG_CC
570 AC_MSG_CHECKING(\$CFLAGS variable)
573 AC_MSG_RESULT(broken)
574 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
577 for cf_arg in $cf_flags
579 CF_ADD_CFLAGS($cf_arg)
587 AC_MSG_CHECKING(\$CC variable)
590 AC_MSG_RESULT(broken)
591 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
593 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
594 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
596 for cf_arg in $cf_flags
600 CF_ADD_CFLAGS($cf_arg)
607 CF_VERBOSE(resulting CC: '$CC')
608 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
609 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
616 dnl ---------------------------------------------------------------------------
617 dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05
619 dnl Determine the default configuration into which we'll install ncurses. This
620 dnl can be overridden by the user's command-line options. There's two items to
622 dnl 1. the prefix (e.g., /usr)
623 dnl 2. the header files (e.g., /usr/include/ncurses)
624 dnl We'll look for a previous installation of ncurses and use the same defaults.
626 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
627 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
628 dnl programs from a vendor's.
629 AC_DEFUN([CF_CFG_DEFAULTS],
630 [AC_REQUIRE([AC_PROG_FGREP])dnl
632 AC_MSG_CHECKING(for prefix)
633 if test "x$prefix" = "xNONE" ; then
634 case "$cf_cv_system_name" in
635 # non-vendor systems don't have a conflict
636 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
639 (*) prefix=$ac_default_prefix
643 AC_MSG_RESULT($prefix)
645 if test "x$prefix" = "xNONE" ; then
646 AC_MSG_CHECKING(for default include-directory)
647 test -n "$verbose" && echo 1>&AC_FD_MSG
650 "$includedir/ncurses" \
652 "$prefix/include/ncurses" \
654 /usr/local/include/ncurses \
658 cf_dir=`eval echo "$cf_symbol"`
659 if test -f "$cf_dir/curses.h" ; then
660 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then
661 includedir="$cf_symbol"
662 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG
666 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
668 AC_MSG_RESULT($includedir)
671 dnl ---------------------------------------------------------------------------
672 dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15
674 dnl Check if we're accidentally using a cache from a different machine.
675 dnl Derive the system name, as a check for reusing the autoconf cache.
677 dnl If we've packaged config.guess and config.sub, run that (since it does a
678 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
679 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
680 dnl which is useful in cross-compiles.
682 dnl Note: we would use $ac_config_sub, but that is one of the places where
683 dnl autoconf 2.5x broke compatibility with autoconf 2.13
684 AC_DEFUN([CF_CHECK_CACHE],
686 if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then
687 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
688 system_name="$host_os"
690 system_name="`(uname -s -r) 2>/dev/null`"
691 if test -z "$system_name" ; then
692 system_name="`(hostname) 2>/dev/null`"
695 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
696 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
698 test -z "$system_name" && system_name="$cf_cv_system_name"
699 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
701 if test ".$system_name" != ".$cf_cv_system_name" ; then
702 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
703 AC_MSG_ERROR("Please remove config.cache and try again.")
706 dnl ---------------------------------------------------------------------------
707 dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04
708 dnl ---------------------
709 AC_DEFUN([CF_CHECK_GNAT_VERSION],
711 AC_REQUIRE([CF_GNAT_VERSION])
712 case "$cf_cv_gnat_version" in
713 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
714 cf_cv_prog_gnat_correct=yes
717 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
718 cf_cv_prog_gnat_correct=no
722 dnl ---------------------------------------------------------------------------
723 dnl CF_CLANG_COMPILER version: 8 updated: 2021/01/01 13:31:04
724 dnl -----------------
725 dnl Check if the given compiler is really clang. clang's C driver defines
726 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
727 dnl not ignore some gcc options.
729 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
730 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
731 dnl the wrappers for gcc and g++ warnings.
733 dnl $1 = GCC (default) or GXX
734 dnl $2 = CLANG_COMPILER (default)
735 dnl $3 = CFLAGS (default) or CXXFLAGS
736 AC_DEFUN([CF_CLANG_COMPILER],[
737 ifelse([$2],,CLANG_COMPILER,[$2])=no
739 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
740 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
741 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
747 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
749 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
750 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
755 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
757 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]])
758 AC_MSG_WARN(replacing broken compiler alias $CC)
759 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`"
764 AC_MSG_CHECKING(version of $CC)
765 CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`"
766 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown
767 AC_MSG_RESULT($CLANG_VERSION)
769 for cf_clang_opt in \
771 -Wno-error=implicit-function-declaration
773 AC_MSG_CHECKING(if option $cf_clang_opt works)
774 cf_save_CFLAGS="$CFLAGS"
775 CFLAGS="$CFLAGS $cf_clang_opt"
777 #include <stdio.h>],[
778 printf("hello!\\n");],[
779 cf_clang_optok=yes],[
781 AC_MSG_RESULT($cf_clang_optok)
782 CFLAGS="$cf_save_CFLAGS"
783 if test "$cf_clang_optok" = yes; then
784 CF_VERBOSE(adding option $cf_clang_opt)
785 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
790 dnl ---------------------------------------------------------------------------
791 dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
792 dnl -----------------
793 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
794 dnl character-strings.
796 dnl It is ambiguous because the specification accommodated the pre-ANSI
797 dnl compilers bundled by more than one vendor in lieu of providing a standard C
798 dnl compiler other than by costly add-ons. Because of this, the specification
799 dnl did not take into account the use of const for telling the compiler that
800 dnl string literals would be in readonly memory.
802 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
803 dnl let the compiler decide how to represent Xt's strings which were #define'd.
804 dnl That does not solve the problem of using the block of Xt's strings which
805 dnl are compiled into the library (and is less efficient than one might want).
807 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
808 dnl when compiling the library and compiling using the library, to tell the
809 dnl compiler that String is const.
810 AC_DEFUN([CF_CONST_X_STRING],
812 AC_REQUIRE([AC_PATH_XTRA])
814 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
819 #include <X11/Intrinsic.h>
821 [String foo = malloc(1); (void)foo],[
823 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
826 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
827 #undef XTSTRINGDEFINES /* X11R5 and later */
829 #include <X11/Intrinsic.h>
830 ],[String foo = malloc(1); *foo = 0],[
831 cf_cv_const_x_string=no
833 cf_cv_const_x_string=yes
837 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
839 case "$cf_cv_const_x_string" in
841 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
844 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
850 dnl ---------------------------------------------------------------------------
851 dnl CF_CONST_X_STRING version: 6 updated: 2021/01/01 13:31:04
852 dnl -----------------
853 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
854 dnl character-strings.
856 dnl It is ambiguous because the specification accommodated the pre-ANSI
857 dnl compilers bundled by more than one vendor in lieu of providing a standard C
858 dnl compiler other than by costly add-ons. Because of this, the specification
859 dnl did not take into account the use of const for telling the compiler that
860 dnl string literals would be in readonly memory.
862 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
863 dnl let the compiler decide how to represent Xt's strings which were #define'd.
864 dnl That does not solve the problem of using the block of Xt's strings which
865 dnl are compiled into the library (and is less efficient than one might want).
867 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
868 dnl when compiling the library and compiling using the library, to tell the
869 dnl compiler that String is const.
870 AC_DEFUN([CF_CONST_X_STRING],
872 AC_REQUIRE([AC_PATH_XTRA])
874 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
879 #include <X11/Intrinsic.h>
881 [String foo = malloc(1); (void)foo],[
883 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
886 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
887 #undef XTSTRINGDEFINES /* X11R5 and later */
889 #include <X11/Intrinsic.h>
890 ],[String foo = malloc(1); *foo = 0],[
891 cf_cv_const_x_string=no
893 cf_cv_const_x_string=yes
897 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
899 case "$cf_cv_const_x_string" in
901 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
904 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
910 dnl ---------------------------------------------------------------------------
911 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
913 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
914 dnl variations of ncurses' installs.
916 dnl $1 = ncurses when looking for ncurses, or is empty
917 AC_DEFUN([CF_CURSES_HEADER],[
918 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
919 cf_cv_ncurses_header=none
921 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
922 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
924 AC_TRY_COMPILE([#include <${cf_header}>],
925 [initscr(); tgoto("?", 0,0)],
926 [cf_cv_ncurses_header=$cf_header; break],[])
930 if test "$cf_cv_ncurses_header" = none ; then
931 AC_MSG_ERROR(No curses header-files found)
934 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
935 AC_CHECK_HEADERS($cf_cv_ncurses_header)
937 dnl ---------------------------------------------------------------------------
938 dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42
940 dnl "dirname" is not portable, so we fake it with a shell script.
941 AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl
942 dnl ---------------------------------------------------------------------------
943 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
945 dnl You can always use "make -n" to see the actual options, but it's hard to
946 dnl pick out/analyze warning messages when the compile-line is long.
949 dnl ECHO_LT - symbol to control if libtool is verbose
950 dnl ECHO_LD - symbol to prefix "cc -o" lines
951 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
952 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
953 dnl ECHO_CC - symbol to put before any "cc" line
955 AC_DEFUN([CF_DISABLE_ECHO],[
956 AC_MSG_CHECKING(if you want to see long compiling messages)
958 [ --disable-echo do not display "compiling" commands],
961 ECHO_LD='@echo linking [$]@;'
962 RULE_CC='@echo compiling [$]<'
963 SHOW_CC='@echo compiling [$]@'
972 AC_MSG_RESULT($enableval)
979 dnl ---------------------------------------------------------------------------
980 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
981 dnl ------------------------
982 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
983 AC_MSG_CHECKING(if we want to use GNAT projects)
984 CF_ARG_DISABLE(gnat-projects,
985 [ --disable-gnat-projects test: disable GNAT projects even if usable],
986 [enable_gnat_projects=no],
987 [enable_gnat_projects=yes])
988 AC_MSG_RESULT($enable_gnat_projects)
990 dnl ---------------------------------------------------------------------------
991 dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14
992 dnl -----------------------
993 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
994 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
995 dnl an unconditional feature.
996 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
998 AC_MSG_CHECKING(if you want broken-linker support code)
999 AC_ARG_ENABLE(broken_linker,
1000 [ --enable-broken_linker compile with broken-linker support code],
1001 [with_broken_linker=$enableval],
1002 [with_broken_linker=no])
1003 AC_MSG_RESULT($with_broken_linker)
1005 : "${BROKEN_LINKER:=0}"
1006 if test "x$with_broken_linker" = xyes ; then
1007 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
1010 AC_SUBST(BROKEN_LINKER)
1012 dnl ---------------------------------------------------------------------------
1013 dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50
1014 dnl ------------------
1015 dnl Configure-option to enable gcc warnings
1017 dnl $1 = extra options to add, if supported
1018 dnl $2 = option for checking attributes. By default, this is done when
1019 dnl warnings are enabled. For other values:
1020 dnl yes: always do this, e.g., to use in generated library-headers
1021 dnl no: never do this
1022 AC_DEFUN([CF_ENABLE_WARNINGS],[
1023 if test "$GCC" = yes || test "$GXX" = yes
1025 CF_FIX_WARNINGS(CFLAGS)
1026 CF_FIX_WARNINGS(CPPFLAGS)
1027 CF_FIX_WARNINGS(LDFLAGS)
1028 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1029 CF_ARG_ENABLE(warnings,
1030 [ --enable-warnings test: turn on gcc compiler warnings],
1031 [enable_warnings=yes],
1032 [enable_warnings=no])
1033 AC_MSG_RESULT($enable_warnings)
1034 if test "$enable_warnings" = "yes"
1036 ifelse($2,,[CF_GCC_ATTRIBUTES])
1039 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1042 dnl ---------------------------------------------------------------------------
1043 dnl CF_FIND_LIBRARY version: 11 updated: 2021/01/02 09:31:20
1045 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1046 dnl prefer a standard location, and use -L options only if we do not find the
1047 dnl library in the standard library location(s).
1048 dnl $1 = library name
1049 dnl $2 = library class, usually the same as library name
1051 dnl $4 = code fragment to compile/link
1052 dnl $5 = corresponding function-name
1053 dnl $6 = flag, nonnull if failure should not cause an error-exit
1055 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1056 dnl to use a -L option.
1057 AC_DEFUN([CF_FIND_LIBRARY],
1059 eval 'cf_cv_have_lib_'"$1"'=no'
1062 eval 'cf_cv_have_lib_'"$1"'=yes',[
1063 cf_save_LIBS="$LIBS"
1064 AC_MSG_CHECKING(for $5 in -l$1)
1066 AC_TRY_LINK([$3],[$4],
1068 eval 'cf_cv_have_lib_'"$1"'=yes'
1071 CF_LIBRARY_PATH(cf_search,$2)
1072 for cf_libdir in $cf_search
1074 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1075 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1076 AC_TRY_LINK([$3],[$4],
1078 eval 'cf_cv_have_lib_'"$1"'=yes'
1081 LIBS="$cf_save_LIBS"])
1085 eval 'cf_found_library="[$]cf_cv_have_lib_'"$1"\"
1087 if test "$cf_found_library" = no ; then
1088 AC_MSG_ERROR(Cannot link $1 library)
1092 dnl ---------------------------------------------------------------------------
1093 dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42
1095 dnl Find a library (specifically the linkage used in the code fragment),
1096 dnl searching for it if it is not already in the library path.
1097 dnl See also CF_ADD_SEARCHPATH.
1099 dnl Parameters (4-on are optional):
1100 dnl $1 = headers for library entrypoint
1101 dnl $2 = code fragment for library entrypoint
1102 dnl $3 = the library name without the "-l" option or ".so" suffix.
1103 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1104 dnl $5 = action to perform if not successful
1105 dnl $6 = module name, if not the same as the library name
1106 dnl $7 = extra libraries
1108 dnl Sets these variables:
1109 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1110 dnl $cf_cv_header_path_$3 - include-directory if needed
1111 dnl $cf_cv_library_path_$3 - library-directory if needed
1112 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1113 AC_DEFUN([CF_FIND_LINKAGE],[
1115 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1116 # will be set on completion of the AC_TRY_LINK below.
1117 cf_cv_header_path_$3=
1118 cf_cv_library_path_$3=
1120 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1122 cf_save_LIBS="$LIBS"
1124 AC_TRY_LINK([$1],[$2],[
1125 cf_cv_find_linkage_$3=yes
1126 cf_cv_header_path_$3=/usr/include
1127 cf_cv_library_path_$3=/usr/lib
1130 LIBS="-l$3 $7 $cf_save_LIBS"
1132 AC_TRY_LINK([$1],[$2],[
1133 cf_cv_find_linkage_$3=yes
1134 cf_cv_header_path_$3=/usr/include
1135 cf_cv_library_path_$3=/usr/lib
1136 cf_cv_library_file_$3="-l$3"
1138 cf_cv_find_linkage_$3=no
1139 LIBS="$cf_save_LIBS"
1141 CF_VERBOSE(find linkage for $3 library)
1142 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1144 cf_save_CPPFLAGS="$CPPFLAGS"
1145 cf_test_CPPFLAGS="$CPPFLAGS"
1147 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1148 for cf_cv_header_path_$3 in $cf_search
1150 if test -d "$cf_cv_header_path_$3" ; then
1151 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1152 CPPFLAGS="$cf_save_CPPFLAGS"
1153 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1154 AC_TRY_COMPILE([$1],[$2],[
1155 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1156 cf_cv_find_linkage_$3=maybe
1157 cf_test_CPPFLAGS="$CPPFLAGS"
1159 CPPFLAGS="$cf_save_CPPFLAGS"
1164 if test "$cf_cv_find_linkage_$3" = maybe ; then
1166 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1168 cf_save_LIBS="$LIBS"
1169 cf_save_LDFLAGS="$LDFLAGS"
1172 CPPFLAGS="$cf_test_CPPFLAGS"
1173 LIBS="-l$3 $7 $cf_save_LIBS"
1174 AC_TRY_LINK([$1],[$2],[
1175 CF_VERBOSE(... found $3 library in system)
1176 cf_cv_find_linkage_$3=yes])
1177 CPPFLAGS="$cf_save_CPPFLAGS"
1178 LIBS="$cf_save_LIBS"
1181 if test "$cf_cv_find_linkage_$3" != yes ; then
1182 CF_LIBRARY_PATH(cf_search,$3)
1183 for cf_cv_library_path_$3 in $cf_search
1185 if test -d "$cf_cv_library_path_$3" ; then
1186 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1187 CPPFLAGS="$cf_test_CPPFLAGS"
1188 LIBS="-l$3 $7 $cf_save_LIBS"
1189 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1190 AC_TRY_LINK([$1],[$2],[
1191 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1192 cf_cv_find_linkage_$3=yes
1193 cf_cv_library_file_$3="-l$3"
1195 CPPFLAGS="$cf_save_CPPFLAGS"
1196 LIBS="$cf_save_LIBS"
1197 LDFLAGS="$cf_save_LDFLAGS"
1201 CPPFLAGS="$cf_save_CPPFLAGS"
1202 LDFLAGS="$cf_save_LDFLAGS"
1206 cf_cv_find_linkage_$3=no
1211 LIBS="$cf_save_LIBS"
1213 if test "$cf_cv_find_linkage_$3" = yes ; then
1215 CF_ADD_INCDIR($cf_cv_header_path_$3)
1216 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1220 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1223 dnl ---------------------------------------------------------------------------
1224 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1225 dnl -----------------
1226 dnl make ADAFLAGS consistent with CFLAGS
1227 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1228 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1236 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1237 CF_ADD_ADAFLAGS($cf_O_flag)
1240 AC_MSG_RESULT($ADAFLAGS)
1242 dnl ---------------------------------------------------------------------------
1243 dnl CF_FIX_WARNINGS version: 3 updated: 2020/12/31 18:40:20
1245 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1246 dnl "-Werror" flags can interfere with configure-checks. Those go into
1249 dnl $1 = variable name to repair
1250 define([CF_FIX_WARNINGS],[
1251 if test "$GCC" = yes || test "$GXX" = yes
1255 CF_VERBOSE(repairing $1: [$]$1)
1257 for cf_temp_scan in [$]$1
1259 case "x$cf_temp_scan" in
1261 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan)
1264 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan)
1269 CF_VERBOSE(... fixed [$]$1)
1270 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1274 AC_SUBST(EXTRA_CFLAGS)
1276 dnl ---------------------------------------------------------------------------
1277 dnl CF_GCC_ATTRIBUTES version: 23 updated: 2021/01/03 18:30:50
1278 dnl -----------------
1279 dnl Test for availability of useful gcc __attribute__ directives to quiet
1280 dnl compiler warnings. Though useful, not all are supported -- and contrary
1281 dnl to documentation, unrecognized directives cause older compilers to barf.
1282 AC_DEFUN([CF_GCC_ATTRIBUTES],
1283 [AC_REQUIRE([AC_PROG_FGREP])dnl
1285 if test "$GCC" = yes || test "$GXX" = yes
1287 cat > conftest.i <<EOF
1289 #define GCC_PRINTF 0
1294 #ifndef GCC_NORETURN
1295 #define GCC_NORETURN /* nothing */
1298 #define GCC_UNUSED /* nothing */
1301 if test "$GCC" = yes
1303 AC_CHECKING([for $CC __attribute__ directives])
1304 cat > "conftest.$ac_ext" <<EOF
1305 #line __oline__ "${as_me:-configure}"
1306 #include "confdefs.h"
1307 #include "conftest.h"
1308 #include "conftest.i"
1310 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1312 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1315 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1317 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1319 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1320 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1321 extern void foo(void) GCC_NORETURN;
1322 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1324 cf_printf_attribute=no
1325 cf_scanf_attribute=no
1326 for cf_attribute in scanf printf unused noreturn
1328 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1329 cf_directive="__attribute__(($cf_attribute))"
1330 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1332 case "$cf_attribute" in
1334 cf_printf_attribute=yes
1335 cat >conftest.h <<EOF
1336 #define GCC_$cf_ATTRIBUTE 1
1340 cf_scanf_attribute=yes
1341 cat >conftest.h <<EOF
1342 #define GCC_$cf_ATTRIBUTE 1
1346 cat >conftest.h <<EOF
1347 #define GCC_$cf_ATTRIBUTE $cf_directive
1352 if AC_TRY_EVAL(ac_compile); then
1353 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1354 cat conftest.h >>confdefs.h
1355 case "$cf_attribute" in
1357 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1360 cf_value='/* nothing */'
1361 if test "$cf_printf_attribute" != no ; then
1362 cf_value='__attribute__((format(printf,fmt,var)))'
1363 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1365 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1368 cf_value='/* nothing */'
1369 if test "$cf_scanf_attribute" != no ; then
1370 cf_value='__attribute__((format(scanf,fmt,var)))'
1371 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1373 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1376 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1382 ${FGREP-fgrep} define conftest.i >>confdefs.h
1387 dnl ---------------------------------------------------------------------------
1388 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1390 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1391 dnl compatible), attempt to determine if icc/clang is actually used.
1392 AC_DEFUN([CF_GCC_VERSION],[
1393 AC_REQUIRE([AC_PROG_CC])
1395 if test "$GCC" = yes ; then
1396 AC_MSG_CHECKING(version of $CC)
1397 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.]].*//'`"
1398 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1399 AC_MSG_RESULT($GCC_VERSION)
1401 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1402 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1404 dnl ---------------------------------------------------------------------------
1405 dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59
1407 dnl Check if the compiler supports useful warning options. There's a few that
1408 dnl we don't use, simply because they're too noisy:
1410 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1411 dnl -Winline (usually not worthwhile)
1412 dnl -Wredundant-decls (system headers make this too noisy)
1413 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1414 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1415 dnl is enabled for ncurses using "--enable-const".
1419 dnl $1 is an optional list of gcc warning flags that a particular
1420 dnl application might want to use, e.g., "no-unused" for
1423 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1425 AC_DEFUN([CF_GCC_WARNINGS],
1427 AC_REQUIRE([CF_GCC_VERSION])
1428 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1429 cat > "conftest.$ac_ext" <<EOF
1430 #line __oline__ "${as_me:-configure}"
1431 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1433 if test "$INTEL_COMPILER" = yes
1435 # The "-wdXXX" options suppress warnings:
1436 # remark #1419: external declaration in primary source file
1437 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1438 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1439 # remark #193: zero used for undefined preprocessing identifier
1440 # remark #593: variable "curs_sb_left_arrow" was set but never used
1441 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1442 # remark #869: parameter "tw" was never referenced
1443 # remark #981: operands are evaluated in unspecified order
1444 # warning #279: controlling expression is constant
1446 AC_CHECKING([for $CC warning options])
1447 cf_save_CFLAGS="$CFLAGS"
1448 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1460 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1461 if AC_TRY_EVAL(ac_compile); then
1462 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1463 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1466 CFLAGS="$cf_save_CFLAGS"
1467 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1469 AC_CHECKING([for $CC warning options])
1470 cf_save_CFLAGS="$CFLAGS"
1472 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1473 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1474 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1475 for cf_opt in W Wall \
1476 Wbad-function-cast \
1479 Wdeclaration-after-statement \
1482 Wmissing-declarations \
1483 Wmissing-prototypes \
1487 Wstrict-prototypes \
1488 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1490 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1491 if AC_TRY_EVAL(ac_compile); then
1492 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1495 case "$GCC_VERSION" in
1497 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1502 case "$GCC_VERSION" in
1504 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1509 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1512 CFLAGS="$cf_save_CFLAGS"
1516 AC_SUBST(EXTRA_CFLAGS)
1518 dnl ---------------------------------------------------------------------------
1519 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1520 dnl -----------------
1521 AC_DEFUN([CF_GNATPREP_OPT_T],[
1522 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1523 cf_cv_gnatprep_opt_t=no
1524 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1526 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1527 AC_SUBST(GNATPREP_OPTS)
1529 dnl ---------------------------------------------------------------------------
1530 dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04
1531 dnl ----------------
1532 AC_DEFUN([CF_GNAT_GENERICS],
1534 AC_REQUIRE([CF_GNAT_VERSION])
1536 AC_MSG_CHECKING(if GNAT supports generics)
1537 case "$cf_cv_gnat_version" in
1538 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1539 cf_gnat_generics=yes
1545 AC_MSG_RESULT($cf_gnat_generics)
1547 if test "$cf_gnat_generics" = yes
1549 cf_compile_generics=generics
1550 cf_generic_objects="\${GENOBJS}"
1552 cf_compile_generics=
1556 AC_SUBST(cf_compile_generics)
1557 AC_SUBST(cf_generic_objects)
1559 dnl ---------------------------------------------------------------------------
1560 dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14
1561 dnl ----------------
1562 dnl GNAT projects are configured with ".gpr" project files.
1563 dnl GNAT libraries are a further development, using the project feature.
1564 AC_DEFUN([CF_GNAT_PROJECTS],
1566 AC_REQUIRE([CF_GNAT_VERSION])
1567 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1569 cf_gnat_libraries=no
1572 if test "$enable_gnat_projects" != no ; then
1573 AC_MSG_CHECKING(if GNAT supports project files)
1574 case "$cf_cv_gnat_version" in
1578 case "$cf_cv_system_name" in
1582 rm -rf ./conftest* ./*~conftest*
1583 if mkdir conftest.src conftest.bin conftest.lib
1586 rm -rf ./conftest* ./*~conftest*
1587 cat >>library.gpr <<CF_EOF
1589 Kind := External ("LIB_KIND");
1590 for Library_Name use "ConfTest";
1591 for Object_Dir use ".";
1592 for Library_ALI_Dir use External("LIBRARY_DIR");
1593 for Library_Version use External ("SONAME");
1594 for Library_Kind use Kind;
1595 for Library_Dir use External("BUILD_DIR");
1596 Source_Dir := External ("SOURCE_DIR");
1597 for Source_Dirs use (Source_Dir);
1600 cat >>confpackage.ads <<CF_EOF
1601 package ConfPackage is
1605 cat >>confpackage.adb <<CF_EOF
1607 package body ConfPackage is
1608 procedure conftest is
1610 Text_IO.Put ("Hello World");
1615 if ( "$cf_ada_make" $ADAFLAGS \
1617 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \
1618 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \
1619 -XSOURCE_DIR="`pwd`" \
1620 -XSONAME=libConfTest.so.1 \
1621 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1622 cf_gnat_projects=yes
1626 if test -f conftest.lib/confpackage.ali
1628 cf_gnat_libraries=yes
1630 rm -rf ./conftest* ./*~conftest*
1635 AC_MSG_RESULT($cf_gnat_projects)
1636 fi # enable_gnat_projects
1638 if test "$cf_gnat_projects" = yes
1640 AC_MSG_CHECKING(if GNAT supports libraries)
1641 AC_MSG_RESULT($cf_gnat_libraries)
1644 USE_OLD_MAKERULES=""
1645 USE_GNAT_PROJECTS="#"
1646 USE_GNAT_MAKE_GPR="#"
1647 USE_GNAT_GPRBUILD="#"
1649 if test "$cf_gnat_projects" = yes
1651 USE_OLD_MAKERULES="#"
1652 USE_GNAT_PROJECTS=""
1653 if test "$cf_cv_VERSION_GPRBUILD" != no
1655 USE_GNAT_GPRBUILD=""
1656 elif test "$cf_cv_VERSION_GNATMAKE" != no
1658 USE_GNAT_MAKE_GPR=""
1660 AC_MSG_WARN(use old makefile rules since tools are missing)
1664 if test "$cf_gnat_libraries" = yes
1666 USE_GNAT_LIBRARIES=""
1668 USE_GNAT_LIBRARIES="#"
1671 AC_SUBST(USE_OLD_MAKERULES)
1672 AC_SUBST(USE_GNAT_PROJECTS)
1673 AC_SUBST(USE_GNAT_LIBRARIES)
1674 AC_SUBST(USE_GNAT_MAKE_GPR)
1675 AC_SUBST(USE_GNAT_GPRBUILD)
1677 dnl ---------------------------------------------------------------------------
1678 dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04
1680 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1681 dnl is noted that gnat may compile a tasking unit even for configurations which
1682 dnl fail at runtime.
1683 AC_DEFUN([CF_GNAT_SIGINT],[
1684 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1685 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1689 pragma Warnings (Off); -- the next pragma exists since 3.11p
1690 pragma Unreserve_All_Interrupts;
1691 pragma Warnings (On);
1693 protected Process is
1695 function Continue return Boolean;
1696 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1698 Done : Boolean := False;
1702 [package body ConfTest is
1703 protected body Process is
1708 function Continue return Boolean is
1714 [cf_cv_gnat_sigint=yes],
1715 [cf_cv_gnat_sigint=no])])
1717 if test "$cf_cv_gnat_sigint" = yes ; then
1722 AC_SUBST(USE_GNAT_SIGINT)
1724 dnl ---------------------------------------------------------------------------
1725 dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04
1726 dnl ----------------
1727 dnl Verify that a test program compiles/links with GNAT.
1728 dnl $cf_ada_make is set to the program that compiles/links
1729 dnl $ADAFLAGS may be set to the GNAT flags.
1731 dnl $1 is the text of the spec
1732 dnl $2 is the text of the body
1733 dnl $3 is the shell command to execute if successful
1734 dnl $4 is the shell command to execute if not successful
1735 AC_DEFUN([CF_GNAT_TRY_LINK],
1737 rm -rf ./conftest* ./*~conftest*
1738 cat >>conftest.ads <<CF_EOF
1741 cat >>conftest.adb <<CF_EOF
1744 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1745 ifelse($3,, :,[ $3])
1749 rm -rf ./conftest* ./*~conftest*
1751 dnl ---------------------------------------------------------------------------
1752 dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04
1754 dnl Verify that a test program compiles and runs with GNAT
1755 dnl $cf_ada_make is set to the program that compiles/links
1756 dnl $ADAFLAGS may be set to the GNAT flags.
1758 dnl $1 is the text of the spec
1759 dnl $2 is the text of the body
1760 dnl $3 is the shell command to execute if successful
1761 dnl $4 is the shell command to execute if not successful
1762 AC_DEFUN([CF_GNAT_TRY_RUN],
1764 rm -rf ./conftest* ./*~conftest*
1765 cat >>conftest.ads <<CF_EOF
1768 cat >>conftest.adb <<CF_EOF
1771 if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1772 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1773 ifelse($3,, :,[ $3])
1780 rm -rf ./conftest* ./*~conftest*
1782 dnl ---------------------------------------------------------------------------
1783 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1785 dnl $1 = cache variable to update
1786 dnl $2 = program name
1787 dnl Verify version of GNAT or related tool
1788 AC_DEFUN([CF_GNAT_VERSION],
1790 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1791 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1792 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1793 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1795 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1796 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1798 dnl ---------------------------------------------------------------------------
1799 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1801 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1802 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1803 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1804 dnl since it is interwoven with GNU extensions.
1806 dnl Well, yes we could work around it...
1809 dnl $1 is the nominal value for _XOPEN_SOURCE
1810 AC_DEFUN([CF_GNU_SOURCE],
1812 cf_gnu_xopen_source=ifelse($1,,500,$1)
1814 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1815 AC_TRY_COMPILE([#include <sys/types.h>],[
1816 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1818 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1821 # error not GNU C library
1823 [cf_cv_gnu_library=yes],
1824 [cf_cv_gnu_library=no])
1827 if test x$cf_cv_gnu_library = xyes; then
1829 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1830 # was changed to help a little. newlib incorporated the change about 4
1832 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1834 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1835 AC_TRY_COMPILE([#include <sys/types.h>],[
1836 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1838 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1841 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1843 [cf_cv_gnu_library_219=yes],
1844 [cf_cv_gnu_library_219=no])
1848 if test "x$cf_cv_gnu_library_219" = xyes; then
1850 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1851 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1854 #include <sys/types.h>
1856 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1859 # error GNU C library is too old
1861 [cf_cv_gnu_dftsrc_219=yes],
1862 [cf_cv_gnu_dftsrc_219=no])
1864 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1866 cf_cv_gnu_dftsrc_219=maybe
1869 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1871 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1872 AC_TRY_COMPILE([#include <sys/types.h>],[
1873 #ifndef _XOPEN_SOURCE
1874 #error expected _XOPEN_SOURCE to be defined
1876 [cf_cv_gnu_source=no],
1877 [cf_save="$CPPFLAGS"
1878 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1879 AC_TRY_COMPILE([#include <sys/types.h>],[
1880 #ifdef _XOPEN_SOURCE
1881 #error expected _XOPEN_SOURCE to be undefined
1883 [cf_cv_gnu_source=no],
1884 [cf_cv_gnu_source=yes])
1889 if test "$cf_cv_gnu_source" = yes
1891 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1892 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1893 AC_TRY_COMPILE([#include <sys/types.h>],[
1894 #ifdef _DEFAULT_SOURCE
1895 #error expected _DEFAULT_SOURCE to be undefined
1897 [cf_cv_default_source=no],
1898 [cf_cv_default_source=yes])
1900 if test "$cf_cv_default_source" = yes
1902 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1909 dnl ---------------------------------------------------------------------------
1910 dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04
1912 dnl Construct a search-list of directories for a nonstandard header-file
1915 dnl $1 = the variable to return as result
1916 dnl $2 = the package name
1917 AC_DEFUN([CF_HEADER_PATH],
1921 # collect the current set of include-directories from compiler flags
1922 cf_header_path_list=""
1923 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1924 for cf_header_path in $CPPFLAGS $CFLAGS
1926 case "$cf_header_path" in
1928 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1929 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1930 cf_header_path_list="$cf_header_path_list [$]$1"
1936 # add the variations for the package we are looking for
1937 CF_SUBDIR_PATH($1,$2,include)
1939 test "$includedir" != NONE && \
1940 test "$includedir" != "/usr/include" && \
1941 test -d "$includedir" && {
1942 test -d "$includedir" && $1="[$]$1 $includedir"
1943 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2"
1946 test "$oldincludedir" != NONE && \
1947 test "$oldincludedir" != "/usr/include" && \
1948 test -d "$oldincludedir" && {
1949 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir"
1950 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2"
1953 $1="[$]$1 $cf_header_path_list"
1955 dnl ---------------------------------------------------------------------------
1956 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
1958 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1959 AC_DEFUN([CF_HELP_MESSAGE],
1960 [CF_ACVERSION_CHECK(2.53,[],[
1961 AC_DIVERT_HELP($1)])dnl
1963 dnl ---------------------------------------------------------------------------
1964 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
1966 dnl Construct the list of include-options according to whether we're building
1967 dnl in the source directory or using '--srcdir=DIR' option.
1968 AC_DEFUN([CF_INCLUDE_DIRS],
1970 if test "$srcdir" != "."; then
1971 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1973 CPPFLAGS="-I../include $CPPFLAGS"
1974 if test "$srcdir" != "."; then
1975 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
1977 CPPFLAGS="-I. $CPPFLAGS"
1980 dnl ---------------------------------------------------------------------------
1981 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
1983 dnl prompt for/fill-in useful install-program options
1984 AC_DEFUN([CF_INSTALL_OPTS],
1990 dnl ---------------------------------------------------------------------------
1991 dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42
1992 dnl ----------------
1993 dnl Almost all "install" programs default to the current user's ownership.
1994 dnl Almost - MINIX is an exception.
1995 AC_DEFUN([CF_INSTALL_OPT_O],
1997 AC_MSG_CHECKING(if install needs to be told about ownership)
1998 case `$ac_config_guess` in
2007 AC_MSG_RESULT($with_install_o)
2008 if test "x$with_install_o" = xyes
2010 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'`"
2015 AC_SUBST(INSTALL_OPT_O)
2017 dnl ---------------------------------------------------------------------------
2018 dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04
2019 dnl ----------------
2020 dnl Some install-programs accept a "-p" option to preserve file modification
2021 dnl timestamps. That can be useful as an install option, as well as a way to
2022 dnl avoid the need for ranlib after copying a static archive.
2023 AC_DEFUN([CF_INSTALL_OPT_P],
2025 : "${INSTALL:=install}"
2026 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
2031 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2033 if test -f conftest.out/conftest.in
2035 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2036 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2037 if test -s conftest.err
2052 dnl ---------------------------------------------------------------------------
2053 dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48
2054 dnl ----------------
2055 dnl By default, we should strip executables which are installed, but leave the
2056 dnl ability to suppress that for unit-testing.
2057 AC_DEFUN([CF_INSTALL_OPT_S],
2059 AC_MSG_CHECKING(if you want to install stripped executables)
2060 CF_ARG_DISABLE(stripping,
2061 [ --disable-stripping do not strip (debug info) installed executables],
2062 [enable_stripping=no],
2063 [enable_stripping=yes])
2064 AC_MSG_RESULT($enable_stripping)
2066 if test "$enable_stripping" = yes
2072 AC_SUBST(INSTALL_OPT_S)
2074 dnl ---------------------------------------------------------------------------
2075 dnl CF_INTEL_COMPILER version: 8 updated: 2021/01/01 16:53:59
2076 dnl -----------------
2077 dnl Check if the given compiler is really the Intel compiler for Linux. It
2078 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2079 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2081 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2082 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2083 dnl the wrappers for gcc and g++ warnings.
2085 dnl $1 = GCC (default) or GXX
2086 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2087 dnl $3 = CFLAGS (default) or CXXFLAGS
2088 AC_DEFUN([CF_INTEL_COMPILER],[
2089 AC_REQUIRE([AC_CANONICAL_HOST])
2090 ifelse([$2],,INTEL_COMPILER,[$2])=no
2092 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2095 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2096 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2097 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2099 #ifdef __INTEL_COMPILER
2103 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2104 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2106 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2107 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2112 dnl ---------------------------------------------------------------------------
2113 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2115 dnl Add checks for large file support.
2116 AC_DEFUN([CF_LARGEFILE],[
2117 ifdef([AC_FUNC_FSEEKO],[
2119 if test "$enable_largefile" != no ; then
2122 # Normally we would collect these definitions in the config.h,
2123 # but (like _XOPEN_SOURCE), some environments rely on having these
2124 # defined before any of the system headers are included. Another
2125 # case comes up with C++, e.g., on AIX the compiler compiles the
2126 # header files by themselves before looking at the body files it is
2127 # told to compile. For ncurses, those header files do not include
2129 if test "$ac_cv_sys_large_files" != no
2131 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2133 if test "$ac_cv_sys_largefile_source" != no
2135 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2137 if test "$ac_cv_sys_file_offset_bits" != no
2139 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2142 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2144 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2145 #include <sys/types.h>
2148 /* if transitional largefile support is setup, this is true */
2149 extern struct dirent64 * readdir(DIR *);
2150 struct dirent64 *x = readdir((DIR *)0);
2151 struct dirent *y = readdir((DIR *)0);
2155 [cf_cv_struct_dirent64=yes],
2156 [cf_cv_struct_dirent64=no])
2158 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2162 dnl ---------------------------------------------------------------------------
2163 dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04
2165 dnl For the given system and compiler, find the compiler flags to pass to the
2166 dnl loader to use the "rpath" feature.
2167 AC_DEFUN([CF_LD_RPATH_OPT],
2169 AC_REQUIRE([CF_CHECK_CACHE])
2172 if test "x$cf_cv_enable_rpath" != xno
2174 AC_MSG_CHECKING(for an rpath option)
2175 case "$cf_cv_system_name" in
2177 if test "$GCC" = yes; then
2178 LD_RPATH_OPT="-Wl,-rpath,"
2180 LD_RPATH_OPT="-rpath "
2183 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2184 LD_RPATH_OPT="-Wl,-rpath,"
2186 (openbsd[[2-9]].*|mirbsd*)
2187 LD_RPATH_OPT="-Wl,-rpath,"
2190 LD_RPATH_OPT="-rpath "
2193 LD_RPATH_OPT="-Wl,-rpath,"
2196 LD_RPATH_OPT="-rpath "
2204 AC_MSG_RESULT($LD_RPATH_OPT)
2206 case "x$LD_RPATH_OPT" in
2208 AC_MSG_CHECKING(if we need a space after rpath option)
2209 cf_save_LIBS="$LIBS"
2210 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2211 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2212 LIBS="$cf_save_LIBS"
2213 AC_MSG_RESULT($cf_rpath_space)
2214 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2219 dnl ---------------------------------------------------------------------------
2220 dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04
2222 dnl Construct a search-list of directories for a nonstandard library-file
2225 dnl $1 = the variable to return as result
2226 dnl $2 = the package name
2227 AC_DEFUN([CF_LIBRARY_PATH],
2230 cf_library_path_list=""
2231 if test -n "${LDFLAGS}${LIBS}" ; then
2232 for cf_library_path in $LDFLAGS $LIBS
2234 case "$cf_library_path" in
2236 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2237 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2238 cf_library_path_list="$cf_library_path_list [$]$1"
2244 CF_SUBDIR_PATH($1,$2,lib)
2246 $1="$cf_library_path_list [$]$1"
2248 dnl ---------------------------------------------------------------------------
2249 dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04
2251 dnl Compute the library-prefix for the given host system
2252 dnl $1 = variable to set
2253 define([CF_LIB_PREFIX],
2255 case "$cf_cv_system_name" in
2257 if test "$DFT_LWR_MODEL" = libtool; then
2266 (*) LIB_PREFIX='lib'
2269 ifelse($1,,,[$1=$LIB_PREFIX])
2270 AC_SUBST(LIB_PREFIX)
2272 dnl ---------------------------------------------------------------------------
2273 dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59
2275 dnl Compute the library file-suffix from the given model name
2277 dnl $2 = variable to set (the nominal library suffix)
2278 dnl $3 = dependency variable to set (actual filename)
2279 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2280 AC_DEFUN([CF_LIB_SUFFIX],
2288 case "$cf_cv_system_name" in
2299 case "$cf_cv_system_name" in
2310 case "$cf_cv_system_name" in
2319 (cygwin*|msys*|mingw*)
2357 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2359 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2360 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2363 dnl ---------------------------------------------------------------------------
2364 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2366 dnl Compute the string to append to -library from the given model name
2368 dnl $2 = variable to set
2369 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2370 AC_DEFUN([CF_LIB_TYPE],
2376 (profile) $2='_p' ;;
2379 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2381 dnl ---------------------------------------------------------------------------
2382 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2383 dnl ----------------
2384 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2385 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2386 dnl have to provide wrappers for global tables to ensure they're linked
2388 AC_DEFUN([CF_LINK_DATAONLY],
2390 AC_MSG_CHECKING([if data-only library module links])
2391 AC_CACHE_VAL(cf_cv_link_dataonly,[
2393 cat >conftest.$ac_ext <<EOF
2394 #line __oline__ "configure"
2395 int testdata[[3]] = { 123, 456, 789 };
2397 if AC_TRY_EVAL(ac_compile) ; then
2398 mv conftest.o data.o && \
2399 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2401 rm -f conftest.$ac_ext data.o
2402 cat >conftest.$ac_ext <<EOF
2403 #line __oline__ "configure"
2407 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2409 extern int testdata[[3]];
2410 return testdata[[0]] == 123
2411 && testdata[[1]] == 456
2412 && testdata[[2]] == 789;
2416 if AC_TRY_EVAL(ac_compile); then
2417 mv conftest.o func.o && \
2418 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2420 rm -f conftest.$ac_ext func.o
2421 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2423 LIBS="conftest.a $LIBS"
2427 extern int testfunc();
2428 ${cf_cv_main_return:-return} (!testfunc());
2431 [cf_cv_link_dataonly=yes],
2432 [cf_cv_link_dataonly=no],
2433 [cf_cv_link_dataonly=unknown])
2436 AC_MSG_RESULT($cf_cv_link_dataonly)
2438 if test "$cf_cv_link_dataonly" = no ; then
2439 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2442 AC_SUBST(BROKEN_LINKER)
2445 dnl ---------------------------------------------------------------------------
2446 dnl CF_MAKEFLAGS version: 20 updated: 2021/01/03 19:29:49
2448 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2449 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2450 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2451 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2452 AC_DEFUN([CF_MAKEFLAGS],
2453 [AC_REQUIRE([AC_PROG_FGREP])dnl
2455 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2457 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2459 cat >cf_makeflags.tmp <<CF_EOF
2462 @ echo '.$cf_option'
2464 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2465 case "$cf_result" in
2467 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`"
2468 case "$cf_result" in
2469 (.*CC=*) cf_cv_makeflags=
2471 (*) cf_cv_makeflags=$cf_option
2479 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2483 rm -f cf_makeflags.tmp
2486 AC_SUBST(cf_cv_makeflags)
2488 dnl ---------------------------------------------------------------------------
2489 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2491 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2492 dnl a monocase filesystem.
2493 AC_DEFUN([CF_MAKE_TAGS],[
2494 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2496 AC_CHECK_PROGS(CTAGS, exctags ctags)
2497 AC_CHECK_PROGS(ETAGS, exetags etags)
2499 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2501 if test "$cf_cv_mixedcase" = yes ; then
2502 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2507 if test "$MAKE_UPPER_TAGS" = yes ; then
2513 if test "$MAKE_LOWER_TAGS" = yes ; then
2522 AC_SUBST(MAKE_UPPER_TAGS)
2523 AC_SUBST(MAKE_LOWER_TAGS)
2525 dnl ---------------------------------------------------------------------------
2526 dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59
2527 dnl ----------------------
2528 dnl Check if the file-system supports mixed-case filenames. If we're able to
2529 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2530 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2532 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2533 if test "$cross_compiling" = yes ; then
2534 case "$target_alias" in
2535 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*)
2543 rm -f conftest CONFTEST
2545 if test -f CONFTEST ; then
2550 rm -f conftest CONFTEST
2553 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2555 dnl ---------------------------------------------------------------------------
2556 dnl CF_MKSTEMP version: 11 updated: 2021/01/01 13:31:04
2558 dnl Check for a working mkstemp. This creates two files, checks that they are
2559 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2560 AC_DEFUN([CF_MKSTEMP],[
2564 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2567 #include <sys/types.h>
2568 #ifdef HAVE_UNISTD_H
2574 #include <sys/stat.h>
2577 char *tmpl = "conftestXXXXXX";
2585 for (n = 0; n < 2; ++n) {
2586 strcpy(name[n], tmpl);
2587 if ((fd = mkstemp(name[n])) >= 0) {
2588 if (!strcmp(name[n], tmpl)
2589 || stat(name[n], &sb) != 0
2590 || (sb.st_mode & S_IFMT) != S_IFREG
2591 || (sb.st_mode & 077) != 0) {
2598 && !strcmp(name[0], name[1]))
2600 ${cf_cv_main_return:-return}(result);
2602 ],[cf_cv_func_mkstemp=yes
2603 ],[cf_cv_func_mkstemp=no
2604 ],[cf_cv_func_mkstemp=maybe])
2606 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2607 AC_CHECK_FUNC(mkstemp)
2609 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2610 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2613 dnl ---------------------------------------------------------------------------
2614 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2616 dnl Write a debug message to config.log, along with the line number in the
2617 dnl configure script.
2618 AC_DEFUN([CF_MSG_LOG],[
2619 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2621 dnl ---------------------------------------------------------------------------
2622 dnl CF_NCURSES_ADDON version: 6 updated: 2021/01/04 19:33:05
2623 dnl ----------------
2624 dnl Configure an ncurses add-on, built outside the ncurses tree.
2625 AC_DEFUN([CF_NCURSES_ADDON],[
2626 AC_REQUIRE([CF_NCURSES_CONFIG])
2628 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2630 AC_MSG_CHECKING(if you want wide-character code)
2631 AC_ARG_ENABLE(widec,
2632 [ --enable-widec compile with wide-char/UTF-8 code],
2633 [with_widec=$enableval],
2635 AC_MSG_RESULT($with_widec)
2636 if test "$with_widec" = yes ; then
2638 CF_NCURSES_CONFIG(ncursesw)
2640 CF_NCURSES_CONFIG(ncurses)
2643 if test "$NCURSES_CONFIG_PKG" != none ; then
2644 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2646 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2647 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2648 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2650 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2651 if test -z "$cf_cv_abi_version"
2653 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2656 elif test "$NCURSES_CONFIG" != none ; then
2658 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2660 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2661 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2662 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2664 # ABI version is not available from headers
2665 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2669 for cf_name in MAJOR MINOR PATCH
2671 cat >conftest.$ac_ext <<CF_EOF
2672 #include <${cf_cv_ncurses_header:-curses.h}>
2673 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2675 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2677 if test -f conftest.out ; then
2678 cf_result=`sed -e "s/^.*AUTOCONF_${cf_name}[[ ]][[ ]]*//" conftest.out`
2679 eval NCURSES_$cf_name=\"$cf_result\"
2680 # cat conftest.$ac_ext
2685 cf_cv_abi_version=${NCURSES_MAJOR}
2689 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2691 dnl Show the computed version, for logging
2692 cf_cv_timestamp=`date`
2694 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2696 dnl We need these values in the generated headers
2697 AC_SUBST(NCURSES_MAJOR)
2698 AC_SUBST(NCURSES_MINOR)
2699 AC_SUBST(NCURSES_PATCH)
2701 dnl We need these values in the generated makefiles
2702 AC_SUBST(cf_cv_rel_version)
2703 AC_SUBST(cf_cv_abi_version)
2705 dnl FIXME - not needed for Ada95
2706 AC_SUBST(cf_cv_builtin_bool)
2707 AC_SUBST(cf_cv_header_stdbool_h)
2708 AC_SUBST(cf_cv_type_of_bool)dnl
2711 dnl ---------------------------------------------------------------------------
2712 dnl CF_NCURSES_CC_CHECK version: 5 updated: 2020/12/31 20:19:42
2713 dnl -------------------
2714 dnl Check if we can compile with ncurses' header file
2715 dnl $1 is the cache variable to set
2716 dnl $2 is the header-file to include
2717 dnl $3 is the root name (ncurses or ncursesw)
2718 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2720 ]ifelse($3,ncursesw,[
2721 #define _XOPEN_SOURCE_EXTENDED
2722 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2723 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2726 #ifdef NCURSES_VERSION
2727 ]ifelse($3,ncursesw,[
2732 printf("%s\\n", NCURSES_VERSION);
2744 dnl ---------------------------------------------------------------------------
2745 dnl CF_NCURSES_CONFIG version: 26 updated: 2021/01/03 08:05:37
2746 dnl -----------------
2747 dnl Tie together the configure-script macros for ncurses, preferring these in
2749 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2750 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2751 dnl c) just plain libraries
2753 dnl $1 is the root library name (default: "ncurses")
2754 AC_DEFUN([CF_NCURSES_CONFIG],[
2755 AC_REQUIRE([CF_PKG_CONFIG])
2756 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2757 cf_have_ncuconfig=no
2759 if test "x${PKG_CONFIG:=none}" != xnone; then
2760 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2761 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2764 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2765 cf_have_ncuconfig=unknown
2767 cf_save_CFLAGS="$CFLAGS"
2768 cf_save_CPPFLAGS="$CPPFLAGS"
2769 cf_save_LIBS="$LIBS"
2771 cf_pkg_cflags="`$PKG_CONFIG --cflags $cf_ncuconfig_root`"
2772 cf_pkg_libs="`$PKG_CONFIG --libs $cf_ncuconfig_root`"
2774 # while -W for passing linker flags is prevalent, it is not "standard".
2775 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2776 # incompatible _and_ non-standard -W option which gives an error. Work
2777 # around that pitfall.
2778 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2780 CF_ADD_CFLAGS($cf_pkg_cflags)
2781 CF_ADD_LIBS($cf_pkg_libs)
2783 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2784 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2785 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2787 { char *xx = curses_version(); return (xx == 0); }],
2788 [cf_test_ncuconfig=yes],
2789 [cf_test_ncuconfig=no],
2790 [cf_test_ncuconfig=maybe])],
2791 [cf_test_ncuconfig=no])
2793 CFLAGS="$cf_save_CFLAGS"
2794 CPPFLAGS="$cf_save_CPPFLAGS"
2795 LIBS="$cf_save_LIBS"
2797 if test "x$cf_test_ncuconfig" != xyes; then
2798 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2799 cf_pkg_cflags="$cf_temp"
2800 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2801 cf_pkg_libs="$cf_temp"
2806 CF_ADD_CFLAGS($cf_pkg_cflags)
2807 CF_ADD_LIBS($cf_pkg_libs)
2809 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2810 [initscr(); mousemask(0,0); tigetstr((char *)0);],
2811 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2813 { char *xx = curses_version(); return (xx == 0); }],
2814 [cf_have_ncuconfig=yes],
2815 [cf_have_ncuconfig=no],
2816 [cf_have_ncuconfig=maybe])],
2817 [cf_have_ncuconfig=no])
2818 AC_MSG_RESULT($cf_have_ncuconfig)
2819 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2820 if test "$cf_have_ncuconfig" != "yes"
2822 CPPFLAGS="$cf_save_CPPFLAGS"
2823 LIBS="$cf_save_LIBS"
2824 NCURSES_CONFIG_PKG=none
2826 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2827 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2833 NCURSES_CONFIG_PKG=none
2836 NCURSES_CONFIG_PKG=none
2839 if test "x$cf_have_ncuconfig" = "xno"; then
2840 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2842 CF_ACVERSION_CHECK(2.52,
2843 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2844 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2846 if test "$NCURSES_CONFIG" != none ; then
2848 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2849 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2851 # even with config script, some packages use no-override for curses.h
2852 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2854 dnl like CF_NCURSES_CPPFLAGS
2855 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2857 dnl like CF_NCURSES_LIBS
2858 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2859 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2861 dnl like CF_NCURSES_VERSION
2862 cf_cv_ncurses_version="`$NCURSES_CONFIG --version`"
2866 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2867 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2874 dnl ---------------------------------------------------------------------------
2875 dnl CF_NCURSES_CPPFLAGS version: 22 updated: 2021/01/02 09:31:20
2876 dnl -------------------
2877 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2878 dnl the CPPFLAGS variable so we can include its header.
2880 dnl The header files may be installed as either curses.h, or ncurses.h (would
2881 dnl be obsolete, except that some packagers prefer this name to distinguish it
2882 dnl from a "native" curses implementation). If not installed for overwrite,
2883 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2884 dnl /usr/include/ncurses), but someone may have installed overwriting the
2885 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2886 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2889 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2890 dnl is already in the include-path, don't even bother with this, since we cannot
2891 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2893 dnl The optional parameter gives the root name of the library, in case it is
2894 dnl not installed as the default curses library. That is how the
2895 dnl wide-character version of ncurses is installed.
2896 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2897 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2899 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2900 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2902 test -n "$cf_cv_curses_dir" && \
2903 test "$cf_cv_curses_dir" != "no" && { \
2904 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2907 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2908 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2909 { test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw; } && cf_header_list="$cf_header_list curses.h ncurses.h"
2910 for cf_header in $cf_header_list
2912 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2913 test "$cf_cv_ncurses_h" != no && break
2920 # some applications need this, but should check for NCURSES_VERSION
2921 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2925 dnl ---------------------------------------------------------------------------
2926 dnl CF_NCURSES_HEADER version: 7 updated: 2021/01/04 19:33:05
2927 dnl -----------------
2928 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2929 dnl variations of ncurses' installs.
2931 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2932 AC_DEFUN([CF_NCURSES_HEADER],[
2934 if test "$cf_cv_ncurses_h" != no ; then
2935 cf_cv_ncurses_header=$cf_cv_ncurses_h
2938 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2939 test -n "$verbose" && echo
2940 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2941 test -n "$verbose" && echo "search path $cf_search"
2942 cf_save2_CPPFLAGS="$CPPFLAGS"
2943 for cf_incdir in $cf_search
2945 CF_ADD_INCDIR($cf_incdir)
2950 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2951 if test "$cf_cv_ncurses_h2" != no ; then
2952 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2953 test -n "$verbose" && echo $ECHO_N " ... found $ECHO_C" 1>&AC_FD_MSG
2956 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2958 CPPFLAGS="$cf_save2_CPPFLAGS"
2959 test "$cf_cv_ncurses_h2" != no && break
2961 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2964 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2965 cf_cv_ncurses_header="`basename "$cf_cv_ncurses_h2"`"
2966 if test "`basename "$cf_1st_incdir"`" = "$cf_ncuhdr_root" ; then
2967 cf_cv_ncurses_header="$cf_ncuhdr_root/$cf_cv_ncurses_header"
2969 CF_ADD_INCDIR($cf_1st_incdir)
2973 # Set definitions to allow ifdef'ing for ncurses.h
2975 case "$cf_cv_ncurses_header" in
2977 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2981 case "$cf_cv_ncurses_header" in
2982 (ncurses/curses.h|ncurses/ncurses.h)
2983 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2985 (ncursesw/curses.h|ncursesw/ncurses.h)
2986 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2991 dnl ---------------------------------------------------------------------------
2992 dnl CF_NCURSES_LIBS version: 20 updated: 2021/01/03 08:05:37
2994 dnl Look for the ncurses library. This is a little complicated on Linux,
2995 dnl because it may be linked with the gpm (general purpose mouse) library.
2996 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2997 dnl unusable with ncurses. However, we don't want to link with gpm unless
2998 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2999 dnl and the linker will record a dependency.
3001 dnl The optional parameter gives the root name of the library, in case it is
3002 dnl not installed as the default curses library. That is how the
3003 dnl wide-character version of ncurses is installed.
3004 AC_DEFUN([CF_NCURSES_LIBS],
3005 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
3007 cf_nculib_root=ifelse($1,,ncurses,$1)
3008 # This works, except for the special case where we find gpm, but
3009 # ncurses is in a nonstandard location via $LIBS, and we really want
3012 cf_ncurses_SAVE="$LIBS"
3013 AC_CHECK_LIB(gpm,Gpm_Open,
3014 [AC_CHECK_LIB(gpm,initscr,
3015 [LIBS="$cf_ncurses_SAVE"],
3016 [cf_ncurses_LIBS="-lgpm"])])
3020 # This is only necessary if you are linking against an obsolete
3021 # version of ncurses (but it should do no harm, since it's static).
3022 if test "$cf_nculib_root" = ncurses ; then
3023 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
3028 CF_ADD_LIBS($cf_ncurses_LIBS)
3030 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
3032 CF_ADD_LIBS(-l$cf_nculib_root)
3034 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3035 [#include <${cf_cv_ncurses_header:-curses.h}>],
3040 if test -n "$cf_ncurses_LIBS" ; then
3041 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3042 cf_ncurses_SAVE="$LIBS"
3043 for p in $cf_ncurses_LIBS ; do
3044 q=`echo "$LIBS" | sed -e "s%$p %%" -e "s%$p$%%"`
3045 if test "$q" != "$LIBS" ; then
3049 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3050 [initscr(); mousemask(0,0); tigetstr((char *)0);],
3051 [AC_MSG_RESULT(yes)],
3053 LIBS="$cf_ncurses_SAVE"])
3056 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3057 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3059 dnl ---------------------------------------------------------------------------
3060 dnl CF_NCURSES_VERSION version: 16 updated: 2020/12/31 20:19:42
3061 dnl ------------------
3062 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3063 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3064 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3065 AC_DEFUN([CF_NCURSES_VERSION],
3067 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3068 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3069 cf_cv_ncurses_version=no
3071 rm -f "$cf_tempfile"
3073 #include <${cf_cv_ncurses_header:-curses.h}>
3077 FILE *fp = fopen("$cf_tempfile", "w");
3078 #ifdef NCURSES_VERSION
3079 # ifdef NCURSES_VERSION_PATCH
3080 fprintf(fp, "%s.%d\\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3082 fprintf(fp, "%s\\n", NCURSES_VERSION);
3086 fprintf(fp, "old\\n");
3091 ${cf_cv_main_return:-return}(0);
3093 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3095 # This will not work if the preprocessor splits the line after the
3096 # Autoconf token. The 'unproto' program does that.
3097 cat > "conftest.$ac_ext" <<EOF
3098 #include <${cf_cv_ncurses_header:-curses.h}>
3100 #ifdef NCURSES_VERSION
3101 Autoconf NCURSES_VERSION
3109 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3111 if test -f conftest.out ; then
3112 cf_out=`sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%' conftest.out`
3113 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3117 rm -f "$cf_tempfile"
3119 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3121 dnl ---------------------------------------------------------------------------
3122 dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04
3124 dnl Compute the object-directory name from the given model name
3125 AC_DEFUN([CF_OBJ_SUBDIR],
3128 (libtool) $2='obj_lo' ;;
3129 (normal) $2='objects' ;;
3130 (debug) $2='obj_g' ;;
3131 (profile) $2='obj_p' ;;
3133 case "$cf_cv_system_name" in
3141 dnl ---------------------------------------------------------------------------
3142 dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04
3144 dnl Provide a value for the $PATH and similar separator (or amend the value
3145 dnl as provided in autoconf 2.5x).
3146 AC_DEFUN([CF_PATHSEP],
3148 AC_MSG_CHECKING(for PATH separator)
3149 case "$cf_cv_system_name" in
3150 (os2*) PATH_SEPARATOR=';' ;;
3151 (*) ${PATH_SEPARATOR:=':'} ;;
3153 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3154 AC_SUBST(PATH_SEPARATOR)
3155 AC_MSG_RESULT($PATH_SEPARATOR)
3157 dnl ---------------------------------------------------------------------------
3158 dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20
3160 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3161 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3162 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3163 dnl delayed evaluation of those symbols.
3164 AC_DEFUN([CF_PATH_SYNTAX],[
3165 if test "x$prefix" != xNONE; then
3166 cf_path_syntax="$prefix"
3168 cf_path_syntax="$ac_default_prefix"
3172 (.\[$]\(*\)*|.\'*\'*)
3176 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3178 (.\[$]\{*prefix\}*|.\[$]\{*dir\}*)
3182 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3187 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%`
3190 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3194 dnl ---------------------------------------------------------------------------
3195 dnl CF_PKG_CONFIG version: 11 updated: 2021/01/01 13:31:04
3197 dnl Check for the package-config program, unless disabled by command-line.
3198 AC_DEFUN([CF_PKG_CONFIG],
3200 AC_MSG_CHECKING(if you want to use pkg-config)
3201 AC_ARG_WITH(pkg-config,
3202 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3203 [cf_pkg_config=$withval],
3204 [cf_pkg_config=yes])
3205 AC_MSG_RESULT($cf_pkg_config)
3207 case "$cf_pkg_config" in
3212 CF_ACVERSION_CHECK(2.52,
3213 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3214 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3221 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3222 if test "$PKG_CONFIG" != none ; then
3223 CF_PATH_SYNTAX(PKG_CONFIG)
3224 elif test "x$cf_pkg_config" != xno ; then
3225 AC_MSG_WARN(pkg-config is not installed)
3228 AC_SUBST(PKG_CONFIG)
3230 dnl ---------------------------------------------------------------------------
3231 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3232 dnl -----------------
3233 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3235 dnl POSIX.1-1990 _POSIX_SOURCE
3236 dnl POSIX.1-1990 and _POSIX_SOURCE and
3237 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3239 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3240 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3241 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3244 dnl $1 is the nominal value for _POSIX_C_SOURCE
3245 AC_DEFUN([CF_POSIX_C_SOURCE],
3246 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3248 if test "$cf_cv_posix_visible" = no; then
3250 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3252 cf_save_CFLAGS="$CFLAGS"
3253 cf_save_CPPFLAGS="$CPPFLAGS"
3255 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3256 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3258 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3259 CF_MSG_LOG(if the symbol is already defined go no further)
3260 AC_TRY_COMPILE([#include <sys/types.h>],[
3261 #ifndef _POSIX_C_SOURCE
3264 [cf_cv_posix_c_source=no],
3265 [cf_want_posix_source=no
3266 case .$cf_POSIX_C_SOURCE in
3268 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3271 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3272 cf_want_posix_source=yes
3275 cf_want_posix_source=yes
3278 if test "$cf_want_posix_source" = yes ; then
3279 AC_TRY_COMPILE([#include <sys/types.h>],[
3280 #ifdef _POSIX_SOURCE
3283 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3285 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3286 CFLAGS="$cf_trim_CFLAGS"
3287 CPPFLAGS="$cf_trim_CPPFLAGS"
3288 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3289 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3290 AC_TRY_COMPILE([#include <sys/types.h>],[
3291 #ifndef _POSIX_C_SOURCE
3294 [cf_cv_posix_c_source=no])
3295 CFLAGS="$cf_save_CFLAGS"
3296 CPPFLAGS="$cf_save_CPPFLAGS"
3300 if test "$cf_cv_posix_c_source" != no ; then
3301 CFLAGS="$cf_trim_CFLAGS"
3302 CPPFLAGS="$cf_trim_CPPFLAGS"
3303 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3306 fi # cf_cv_posix_visible
3309 dnl ---------------------------------------------------------------------------
3310 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3311 dnl ----------------
3312 dnl POSIX documents test-macros which an application may set before any system
3313 dnl headers are included to make features available.
3315 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3316 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3317 dnl recent features visible in the system header files unless the application
3318 dnl overrides the corresponding test-macros. Doing that introduces portability
3321 dnl This macro makes a special check for the symbols used for this, to avoid a
3322 dnl conflicting definition.
3323 AC_DEFUN([CF_POSIX_VISIBLE],
3325 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3326 AC_TRY_COMPILE([#include <stdio.h>],[
3327 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3328 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3329 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3330 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3331 #error conflicting symbols found
3333 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3336 dnl ---------------------------------------------------------------------------
3337 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3339 dnl Check for archiver "ar".
3340 AC_DEFUN([CF_PROG_AR],[
3341 AC_CHECK_TOOL(AR, ar, ar)
3343 dnl ---------------------------------------------------------------------------
3344 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3346 dnl Check for awk, ensure that the check found something.
3347 AC_DEFUN([CF_PROG_AWK],
3350 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3352 dnl ---------------------------------------------------------------------------
3353 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3355 dnl standard check for CC, plus followup sanity checks
3356 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3357 AC_DEFUN([CF_PROG_CC],[
3358 CF_ACVERSION_CHECK(2.53,
3359 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3360 AC_REQUIRE([AC_PROG_CC])],
3362 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3364 CF_ACVERSION_CHECK(2.52,
3369 dnl ---------------------------------------------------------------------------
3370 dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04
3372 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3373 dnl the output file can be renamed, and allows for a shell variable that can
3374 dnl be used later. The parameter is either CC or CXX. The result is the
3376 dnl $cf_cv_prog_CC_c_o
3377 dnl $cf_cv_prog_CXX_c_o
3380 dnl $2 = compiler options, if any
3381 AC_DEFUN([CF_PROG_CC_C_O],
3382 [AC_REQUIRE([AC_PROG_CC])dnl
3383 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3384 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3386 cat > conftest.$ac_ext <<CF_EOF
3389 ${cf_cv_main_return:-return}(0);
3392 # We do the test twice because some compilers refuse to overwrite an
3393 # existing .o file with -o, though they will create one.
3394 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3395 if AC_TRY_EVAL(ac_try) &&
3396 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3398 eval cf_cv_prog_$1_c_o=yes
3400 eval cf_cv_prog_$1_c_o=no
3404 if test "$cf_cv_prog_$1_c_o" = yes; then
3405 AC_MSG_RESULT([yes])
3410 dnl ---------------------------------------------------------------------------
3411 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3413 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3414 dnl This macro adds a check to ensure the script found something.
3415 AC_DEFUN([CF_PROG_EGREP],
3416 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3417 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3418 then ac_cv_prog_egrep='grep -E'
3419 else ac_cv_prog_egrep='egrep'
3421 EGREP=$ac_cv_prog_egrep
3423 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3425 dnl ---------------------------------------------------------------------------
3426 dnl CF_PROG_EXT version: 15 updated: 2021/01/02 09:31:20
3428 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3429 AC_DEFUN([CF_PROG_EXT],
3431 AC_REQUIRE([CF_CHECK_CACHE])
3432 case "$cf_cv_system_name" in
3434 CFLAGS="$CFLAGS -Zmt"
3435 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3436 CXXFLAGS="$CXXFLAGS -Zmt"
3437 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3438 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3448 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3450 dnl ---------------------------------------------------------------------------
3451 dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14
3453 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3454 AC_DEFUN([CF_PROG_GNAT],[
3455 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3457 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3459 unset ac_cv_path_cf_TEMP_gnat
3461 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3462 eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat"
3464 if test "x$cf_TEMP_gnat" != xno; then
3465 unset cf_cv_gnat_version
3467 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3469 eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat"
3472 unset cf_cv_gnat_version
3473 unset ac_cv_path_cf_TEMP_gnat
3476 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3478 cf_cv_prog_gnat_correct=no
3480 cf_ada_make=gnatmake
3481 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3482 # gprconfig is newer than gnatmake; we can continue...
3485 rm -rf ./conftest* ./*~conftest*
3486 if mkdir conftest.src
3490 for cf_gprconfig in Ada C
3492 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3493 if test "$cf_gprconfig" = C
3495 for cf_gprconfig_param in \
3496 "$cf_gprconfig,,,,GNATGCC" \
3497 "$cf_gprconfig,,,,GCC" \
3500 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3501 test -n "$cf_gprconfig_value" && break
3504 cf_gprconfig_param=$cf_gprconfig
3505 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3507 if test -n "$cf_gprconfig_value"
3509 eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value"
3510 AC_MSG_RESULT($cf_gprconfig_value)
3512 AC_MSG_RESULT(missing)
3518 rm -rf ./conftest* ./*~conftest*
3521 if test "x$cf_ada_config" != "x#"
3524 CF_CHECK_GNAT_VERSION
3525 AC_CHECK_PROG(M4_exists, m4, yes, no)
3526 if test "$ac_cv_prog_M4_exists" = no; then
3527 cf_cv_prog_gnat_correct=no
3528 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3530 if test "$cf_cv_prog_gnat_correct" = yes; then
3531 AC_MSG_CHECKING(if GNAT works)
3532 CF_GNAT_TRY_RUN([procedure conftest;],
3535 procedure conftest is
3537 Text_IO.Put ("Hello World");
3539 GNAT.OS_Lib.OS_Exit (0);
3541 [cf_cv_prog_gnat_correct=yes],
3542 [cf_cv_prog_gnat_correct=no])
3543 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3546 cf_cv_prog_gnat_correct=no
3550 AC_SUBST(cf_ada_make)
3551 AC_SUBST(cf_ada_config)
3552 AC_SUBST(cf_ada_config_Ada)
3553 AC_SUBST(cf_ada_config_C)
3555 dnl ---------------------------------------------------------------------------
3556 dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05
3558 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3559 dnl misc/tabset install won't work properly. Usually this happens only when
3560 dnl using the fallback mkinstalldirs script
3561 AC_DEFUN([CF_PROG_INSTALL],
3567 CF_DIRNAME(cf_dir,$INSTALL)
3568 test -z "$cf_dir" && cf_dir=.
3569 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`"
3573 dnl ---------------------------------------------------------------------------
3574 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3576 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3577 dnl option if it is supported.
3578 AC_DEFUN([CF_PROG_LN_S],[
3580 AC_MSG_CHECKING(if $LN_S -f options work)
3582 rm -f conf$$.src conf$$dst
3584 echo first >conf$$.src
3585 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3590 rm -f conf$$.dst conf$$src
3591 AC_MSG_RESULT($cf_prog_ln_sf)
3593 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3595 dnl ---------------------------------------------------------------------------
3596 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3597 dnl ----------------
3598 dnl Remove all -U and -D options that refer to the given symbol from a list
3599 dnl of C compiler options. This works around the problem that not all
3600 dnl compilers process -U and -D options from left-to-right, so a -U option
3601 dnl cannot be used to cancel the effect of a preceding -D option.
3603 dnl $1 = target (which could be the same as the source variable)
3604 dnl $2 = source (including '$')
3605 dnl $3 = symbol to remove
3606 define([CF_REMOVE_DEFINE],
3609 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3610 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3612 dnl ---------------------------------------------------------------------------
3613 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3615 dnl Remove the given library from the symbol
3617 dnl $1 = target (which could be the same as the source variable)
3618 dnl $2 = source (including '$')
3619 dnl $3 = library to remove
3620 define([CF_REMOVE_LIB],
3622 # remove $3 library from $2
3623 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3625 dnl ---------------------------------------------------------------------------
3626 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3627 dnl ---------------------
3628 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3629 dnl $1 = name of current macro
3630 define([CF_RESTORE_XTRA_FLAGS],
3632 LIBS="$cf_save_LIBS_$1"
3633 CFLAGS="$cf_save_CFLAGS_$1"
3634 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3636 dnl ---------------------------------------------------------------------------
3637 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3638 dnl ------------------
3639 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3640 dnl and libraries which do not update those variables.
3642 dnl $1 = name of current macro
3643 define([CF_SAVE_XTRA_FLAGS],
3645 cf_save_LIBS_$1="$LIBS"
3646 cf_save_CFLAGS_$1="$CFLAGS"
3647 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3648 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3649 for cf_X_CFLAGS in $X_CFLAGS
3651 case "x$cf_X_CFLAGS" in
3653 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3656 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3661 dnl ---------------------------------------------------------------------------
3662 dnl CF_SHARED_OPTS version: 105 updated: 2021/01/02 17:09:14
3665 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3669 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3670 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3671 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3672 dnl shared library since that can lead to unexpected results at runtime.
3673 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3674 dnl libraries are compiled in ../../lib
3676 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3677 dnl to install symbolic links to the rel/abi versions of shared libraries.
3679 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3680 dnl version when making symbolic links.
3682 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3683 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3684 dnl (ex: libncurses.so.<ver>).
3686 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3687 AC_DEFUN([CF_SHARED_OPTS],
3689 AC_REQUIRE([CF_LD_RPATH_OPT])
3695 INSTALL_LIB="-m 644"
3696 : ${rel_builddir:=.}
3704 cf_cv_do_symlinks=no
3706 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3708 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3709 AC_ARG_WITH(shlib-version,
3710 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3711 [test -z "$withval" && withval=auto
3714 cf_cv_shlib_version=auto
3717 cf_cv_shlib_version=$withval
3720 AC_MSG_RESULT($withval)
3721 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3724 ],[cf_cv_shlib_version=auto])
3725 AC_MSG_RESULT($cf_cv_shlib_version)
3730 # Some less-capable ports of gcc support only -fpic
3734 if test "$GCC" = yes
3738 case "$cf_cv_system_name" in
3739 (*linux*) # e.g., PGI compiler
3745 if test "$cf_try_fPIC" = yes
3747 AC_MSG_CHECKING(which $CC option to use)
3748 cf_save_CFLAGS="$CFLAGS"
3749 for CC_SHARED_OPTS in -fPIC -fpic ''
3751 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3752 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3754 AC_MSG_RESULT($CC_SHARED_OPTS)
3755 CFLAGS="$cf_save_CFLAGS"
3758 cf_cv_shlib_version_infix=no
3760 case "$cf_cv_system_name" in
3761 (aix4.[3-9]*|aix[[5-7]]*)
3762 if test "$GCC" = yes; then
3763 CC_SHARED_OPTS='-Wl,-brtl'
3764 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3766 CC_SHARED_OPTS='-brtl'
3767 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3768 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3772 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3776 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3777 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3778 cf_cv_shlib_version=cygdll
3779 cf_cv_shlib_version_infix=cygdll
3782 cat >mk_shared_lib.sh <<-CF_EOF
3785 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3788 Linking shared library
3789 ** SHARED_LIB \[$]SHARED_LIB
3790 ** IMPORT_LIB \[$]IMPORT_LIB
3792 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3794 chmod +x mk_shared_lib.sh
3798 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3799 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3800 cf_cv_shlib_version=msysdll
3801 cf_cv_shlib_version_infix=msysdll
3804 cat >mk_shared_lib.sh <<-CF_EOF
3807 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3810 Linking shared library
3811 ** SHARED_LIB \[$]SHARED_LIB
3812 ** IMPORT_LIB \[$]IMPORT_LIB
3814 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3816 chmod +x mk_shared_lib.sh
3819 cf_try_cflags="no-cpp-precomp"
3820 CC_SHARED_OPTS="-dynamic"
3821 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3822 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3823 cf_cv_shlib_version_infix=yes
3824 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3825 cf_save_LDFLAGS=$LDFLAGS
3826 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3827 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3828 LDFLAGS=$cf_save_LDFLAGS])
3829 if test "$cf_cv_ldflags_search_paths_first" = yes; then
3830 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3834 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
3835 if test "$GCC" != yes; then
3838 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
3839 INSTALL_LIB="-m 555"
3842 # (tested with gcc 2.7.2 -- I don't have c89)
3843 if test "$GCC" = yes; then
3844 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3847 LD_SHARED_OPTS='-Wl,+b,${libdir}'
3849 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
3850 # HP-UX shared libraries must be executable, and should be
3851 # readonly to exploit a quirk in the memory manager.
3852 INSTALL_LIB="-m 555"
3855 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3856 if test "$cf_cv_shlib_version" = rel; then
3857 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3859 cf_shared_soname='`basename $[@]`'
3862 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
3865 if test "$cf_cv_enable_rpath" = yes ; then
3866 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3868 # tested with IRIX 5.2 and 'cc'.
3869 if test "$GCC" != yes; then
3870 CC_SHARED_OPTS='-KPIC'
3871 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3873 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
3875 cf_cv_rm_so_locs=yes
3877 (linux*|gnu*|k*bsd*-gnu)
3878 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3879 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3880 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3882 if test "$cf_cv_enable_rpath" = yes ; then
3883 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3886 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3889 cf_cv_shlib_version=msvcdll
3890 cf_cv_shlib_version_infix=msvcdll
3893 if test "$DFT_LWR_MODEL" = "shared" ; then
3894 LOCAL_LDFLAGS="-link -dll"
3895 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3896 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
3899 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
3900 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
3901 cat >mk_shared_lib.sh <<-CF_EOF
3904 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
3909 Linking shared library
3910 ** SHARED LIB \$SHARED_LIB
3911 ** IMPORT_LIB \$IMPORT_LIB
3913 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
3914 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
3915 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
3917 chmod +x mk_shared_lib.sh
3918 cat >mk_prog.sh <<-CF_EOF
3921 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
3924 ldopts=("/subsystem:console")
3927 while test \[$]# -gt 0; do
3930 # ignore -link argument
3932 -M[[TD]] | -M[[TD]]d)
3933 # ignore runtime-library option
3948 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
3951 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
3957 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
3958 ldopts+=("\[$]{linkarg}")
3966 ldopts+=("-out:\[$]1")
3975 if [[ "\$isdll" -ne 0 ]]; then
3976 for lib in \[$]{libs[[*]]}; do
3977 ldopts+=("\[$]lib.dll.lib")
3980 for lib in \[$]{libs[[*]]}; do
3981 ldopts+=("\[$]lib.lib")
3986 ** ld options: "\[$]{ldopts[[@]]}"
3988 exec \[$]LD \[$]{ldopts[[@]]}
3991 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
3992 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
3995 cf_cv_shlib_version=mingw
3996 cf_cv_shlib_version_infix=mingw
3999 if test "$DFT_LWR_MODEL" = "shared" ; then
4000 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
4001 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4002 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
4005 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
4006 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
4007 cat >mk_shared_lib.sh <<-CF_EOF
4010 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
4013 Linking shared library
4014 ** SHARED_LIB \[$]SHARED_LIB
4015 ** IMPORT_LIB \[$]IMPORT_LIB
4017 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
4019 chmod +x mk_shared_lib.sh
4021 (openbsd[[2-9]].*|mirbsd*)
4022 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4023 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4024 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4026 if test "$cf_cv_enable_rpath" = yes ; then
4027 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4029 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4031 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4035 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4039 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4041 (nto-qnx*|openbsd*|freebsd[[12]].*)
4042 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4043 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4044 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4046 (dragonfly*|freebsd*)
4047 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4048 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4049 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4050 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4051 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4054 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4057 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4058 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4059 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4060 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4061 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4062 if test "$cf_cv_shlib_version" = auto; then
4063 if test -f /usr/libexec/ld.elf_so; then
4064 cf_cv_shlib_version=abi
4066 cf_cv_shlib_version=rel
4070 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4072 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4076 # tested with OSF/1 V3.2 and 'cc'
4077 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4078 # link with shared libs).
4079 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4082 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4085 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4086 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4087 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4088 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4090 cf_cv_rm_so_locs=yes
4092 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
4093 # tested with osr5.0.5
4094 if test "$GCC" != yes; then
4095 CC_SHARED_OPTS='-belf -KPIC'
4097 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4098 if test "$cf_cv_enable_rpath" = yes ; then
4099 # only way is to set LD_RUN_PATH but no switch for it
4102 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4103 LINK_PROGS='LD_RUN_PATH=${libdir}'
4104 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4107 # tested with SunOS 4.1.1 and gcc 2.7.0
4108 if test "$GCC" != yes; then
4109 CC_SHARED_OPTS='-KPIC'
4111 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4112 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4115 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4116 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4117 if test "$DFT_LWR_MODEL" = "shared" ; then
4118 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4119 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4121 if test "$cf_cv_enable_rpath" = yes ; then
4122 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
4125 if test "$GCC" != yes; then
4126 cf_save_CFLAGS="$CFLAGS"
4127 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4129 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4130 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break])
4132 CFLAGS="$cf_save_CFLAGS"
4133 CC_SHARED_OPTS=$cf_shared_opts
4134 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4136 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4139 (sysv5uw7*|unix_sv*)
4140 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4141 if test "$GCC" != yes; then
4142 CC_SHARED_OPTS='-KPIC'
4144 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4147 CC_SHARED_OPTS='unknown'
4148 MK_SHARED_LIB='echo unknown'
4152 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4153 case "$cf_cv_shlib_version" in
4155 case "$MK_SHARED_LIB" in
4157 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4160 AC_MSG_WARN(ignored --with-shlib-version)
4166 if test -n "$cf_try_cflags"
4168 cat > conftest.$ac_ext <<EOF
4169 #line __oline__ "${as_me:-configure}"
4171 int main(int argc, char *argv[[]])
4174 return (argv[[argc-1]] == 0) ;
4177 cf_save_CFLAGS="$CFLAGS"
4178 for cf_opt in $cf_try_cflags
4180 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4181 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4182 if AC_TRY_EVAL(ac_compile); then
4184 cf_save_CFLAGS="$CFLAGS"
4189 CFLAGS="$cf_save_CFLAGS"
4193 # RPATH_LIST is a colon-separated list of directories
4194 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4195 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4197 test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4199 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4200 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4202 AC_SUBST(CC_SHARED_OPTS)
4203 AC_SUBST(LD_RPATH_OPT)
4204 AC_SUBST(LD_SHARED_OPTS)
4205 AC_SUBST(MK_SHARED_LIB)
4206 AC_SUBST(RM_SHARED_OPTS)
4208 AC_SUBST(LINK_PROGS)
4209 AC_SUBST(LINK_TESTS)
4211 AC_SUBST(EXTRA_LDFLAGS)
4212 AC_SUBST(LOCAL_LDFLAGS)
4213 AC_SUBST(LOCAL_LDFLAGS2)
4215 AC_SUBST(INSTALL_LIB)
4216 AC_SUBST(RPATH_LIST)
4218 dnl ---------------------------------------------------------------------------
4219 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4220 dnl ----------------
4221 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4222 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4225 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4226 dnl If missing, use "rel".
4227 define([CF_SHARED_SONAME],
4229 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4230 if test "$cf_cv_shlib_version" = rel; then
4231 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4233 cf_cv_shared_soname='`basename $[@]`'
4236 dnl ---------------------------------------------------------------------------
4237 dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20
4239 dnl Remove "-g" option from the compiler options
4240 AC_DEFUN([CF_STRIP_G_OPT],
4241 [$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl
4242 dnl ---------------------------------------------------------------------------
4243 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4245 dnl Construct a search-list for a nonstandard header/lib-file
4246 dnl $1 = the variable to return as result
4247 dnl $2 = the package name
4248 dnl $3 = the subdirectory, e.g., bin, include or lib
4249 AC_DEFUN([CF_SUBDIR_PATH],
4253 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4255 for cf_subdir_prefix in \
4263 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4266 dnl ---------------------------------------------------------------------------
4267 dnl CF_TERM_HEADER version: 6 updated: 2021/01/02 09:31:20
4269 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4270 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4271 dnl but some packagers change this, breaking various applications.
4272 AC_DEFUN([CF_TERM_HEADER],[
4273 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4274 case "${cf_cv_ncurses_header}" in
4275 (*/ncurses.h|*/ncursesw.h)
4276 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4279 cf_term_header=term.h
4283 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4285 AC_TRY_COMPILE([#include <stdio.h>
4286 #include <${cf_cv_ncurses_header:-curses.h}>
4288 ],[int x = auto_left_margin; (void)x],[
4289 cf_cv_term_header="$cf_test"],[
4290 cf_cv_term_header=unknown
4292 test "$cf_cv_term_header" != unknown && break
4296 # Set definitions to allow ifdef'ing to accommodate subdirectories
4298 case "$cf_cv_term_header" in
4300 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4304 case "$cf_cv_term_header" in
4306 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4309 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4313 dnl ---------------------------------------------------------------------------
4314 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4316 dnl Define a top_builddir symbol, for applications that need an absolute path.
4317 AC_DEFUN([CF_TOP_BUILDDIR],
4319 top_builddir=ifelse($1,,`pwd`,$1)
4320 AC_SUBST(top_builddir)
4322 dnl ---------------------------------------------------------------------------
4323 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
4324 dnl -------------------
4325 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4326 dnl can define it successfully.
4327 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4328 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4332 #include <sys/types.h>
4334 #ifndef _XOPEN_SOURCE
4337 [cf_cv_xopen_source=no],
4338 [cf_save="$CPPFLAGS"
4339 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4343 #include <sys/types.h>
4345 #ifdef _XOPEN_SOURCE
4348 [cf_cv_xopen_source=no],
4349 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4354 if test "$cf_cv_xopen_source" != no ; then
4355 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4356 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4357 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4358 CF_ADD_CFLAGS($cf_temp_xopen_source)
4361 dnl ---------------------------------------------------------------------------
4362 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4364 dnl Make an uppercase version of a variable
4365 dnl $1=uppercase($2)
4366 AC_DEFUN([CF_UPPER],
4368 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4370 dnl ---------------------------------------------------------------------------
4371 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
4373 dnl Check for multibyte support, and if not found, utf8 compatibility library
4374 AC_DEFUN([CF_UTF8_LIB],
4376 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4377 cf_save_LIBS="$LIBS"
4379 #include <stdlib.h>],[putwc(0,0);],
4380 [cf_cv_utf8_lib=yes],
4382 #include <libutf8.h>],[putwc(0,0);],utf8,
4383 [cf_cv_utf8_lib=add-on],
4384 [cf_cv_utf8_lib=no])
4387 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4389 if test "$cf_cv_utf8_lib" = "add-on" ; then
4390 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4391 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4392 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4393 CF_ADD_LIBS($cf_cv_library_file_utf8)
4396 dnl ---------------------------------------------------------------------------
4397 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4399 dnl Use AC_VERBOSE w/o the warnings
4400 AC_DEFUN([CF_VERBOSE],
4401 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4404 dnl ---------------------------------------------------------------------------
4405 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4407 dnl Check for compiler-support for weak symbols.
4408 dnl This works with "recent" gcc.
4409 AC_DEFUN([CF_WEAK_SYMBOLS],[
4410 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4413 #include <stdio.h>],
4415 #if defined(__GNUC__)
4416 # if defined __USE_ISOC99
4417 # define _cat_pragma(exp) _Pragma(#exp)
4418 # define _weak_pragma(exp) _cat_pragma(weak name)
4420 # define _weak_pragma(exp)
4422 # define _declare(name) __extension__ extern __typeof__(name) name
4423 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4427 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4430 dnl ---------------------------------------------------------------------------
4431 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4432 dnl --------------------
4433 dnl Command-line option to specify the Ada95 compiler.
4434 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4435 AC_MSG_CHECKING(for ada-compiler)
4436 AC_ARG_WITH(ada-compiler,
4437 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4438 [cf_ada_compiler=$withval],
4439 [cf_ada_compiler=gnatmake])
4440 AC_SUBST(cf_ada_compiler)
4441 AC_MSG_RESULT($cf_ada_compiler)
4443 dnl ---------------------------------------------------------------------------
4444 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4445 dnl -------------------
4446 dnl Command-line option to specify where Ada includes will install.
4447 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4448 AC_MSG_CHECKING(for ada-include)
4449 CF_WITH_PATH(ada-include,
4450 [ --with-ada-include=DIR Ada includes are in DIR],
4452 PREFIX/share/ada/adainclude,
4453 [$]prefix/share/ada/adainclude)
4454 AC_SUBST(ADA_INCLUDE)
4455 AC_MSG_RESULT($ADA_INCLUDE)
4457 dnl ---------------------------------------------------------------------------
4458 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4459 dnl -------------------
4460 dnl CF_WITH_ADA_LIBNAME
4461 dnl -------------------
4462 dnl Command-line option to specify how to name the resulting Ada library.
4463 dnl $1 = default value
4464 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4465 AC_MSG_CHECKING(for ada-libname)
4466 AC_ARG_WITH(ada-libname,
4467 [ --with-ada-libname=XXX override default Ada library-name],
4468 ADA_LIBNAME=[$]withval,
4470 case "x$ADA_LIBNAME" in
4475 AC_SUBST(ADA_LIBNAME)
4476 AC_MSG_RESULT($ADA_LIBNAME)
4478 dnl ---------------------------------------------------------------------------
4479 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4480 dnl -------------------
4481 dnl Command-line option to specify where Ada objects will install.
4482 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4483 AC_MSG_CHECKING(for ada-objects)
4484 CF_WITH_PATH(ada-objects,
4485 [ --with-ada-objects=DIR Ada objects are in DIR],
4487 PREFIX/lib/ada/adalib,
4488 [$]prefix/lib/ada/adalib)
4489 AC_SUBST(ADA_OBJECTS)
4490 AC_MSG_RESULT($ADA_OBJECTS)
4492 dnl ---------------------------------------------------------------------------
4493 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4494 dnl ---------------------
4495 dnl Command-line option to specify if an Ada95 shared-library should be built,
4496 dnl and optionally what its soname should be.
4497 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4498 AC_REQUIRE([CF_GNAT_PROJECTS])
4499 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4500 AC_ARG_WITH(ada-sharedlib,
4501 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4502 [with_ada_sharedlib=$withval],
4503 [with_ada_sharedlib=no])
4504 AC_MSG_RESULT($with_ada_sharedlib)
4506 if test "x$with_ada_sharedlib" != xno
4508 if test "x$cf_gnat_projects" != xyes
4510 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4511 with_ada_sharedlib=no
4515 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4516 MAKE_ADA_SHAREDLIB="#"
4518 if test "x$with_ada_sharedlib" != xno
4521 if test "x$with_ada_sharedlib" != xyes
4523 ADA_SHAREDLIB="$with_ada_sharedlib"
4527 AC_SUBST(ADA_SHAREDLIB)
4528 AC_SUBST(MAKE_ADA_SHAREDLIB)
4530 dnl ---------------------------------------------------------------------------
4531 dnl CF_WITH_CURSES_DIR version: 4 updated: 2021/01/02 19:22:58
4532 dnl ------------------
4533 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4535 AC_DEFUN([CF_WITH_CURSES_DIR],[
4537 AC_MSG_CHECKING(for specific curses-directory)
4538 AC_ARG_WITH(curses-dir,
4539 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4540 [cf_cv_curses_dir=$withval],
4541 [cf_cv_curses_dir=no])
4542 AC_MSG_RESULT($cf_cv_curses_dir)
4544 if test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no"
4546 CF_PATH_SYNTAX(withval)
4547 if test -d "$cf_cv_curses_dir"
4549 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4550 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4554 dnl ---------------------------------------------------------------------------
4555 dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59
4556 dnl ------------------
4557 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4558 dnl "lib" prefix, e.g., because it used the dll naming convention.
4560 dnl $1 = variable to set
4561 AC_DEFUN([CF_WITH_LIB_PREFIX],
4563 AC_MSG_CHECKING(if you want to have a library-prefix)
4564 AC_ARG_WITH(lib-prefix,
4565 [ --with-lib-prefix override library-prefix],
4566 [with_lib_prefix=$withval],
4567 [with_lib_prefix=auto])
4568 AC_MSG_RESULT($with_lib_prefix)
4570 if test "$with_lib_prefix" = auto
4573 elif test "$with_lib_prefix" = no
4577 LIB_PREFIX=$with_lib_prefix
4580 dnl ---------------------------------------------------------------------------
4581 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
4583 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4584 dnl defaulting to yes/no.
4586 dnl $1 = option name
4588 dnl $3 = environment variable to set
4589 dnl $4 = default value, shown in the help-message, must be a constant
4590 dnl $5 = default value, if it's an expression & cannot be in the help-message
4592 AC_DEFUN([CF_WITH_PATH],
4593 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4594 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4595 if ifelse([$5],,true,[test -n "$5"]) ; then
4596 CF_PATH_SYNTAX(withval)
4601 dnl ---------------------------------------------------------------------------
4602 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 11 updated: 2021/01/01 16:16:30
4603 dnl -------------------------
4604 dnl Allow the choice of the pkg-config library directory to be overridden.
4605 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4607 case "$PKG_CONFIG" in
4609 AC_MSG_CHECKING(for pkg-config library directory)
4612 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4616 PKG_CONFIG_LIBDIR=no
4617 AC_ARG_WITH(pkg-config-libdir,
4618 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4619 [PKG_CONFIG_LIBDIR=$withval],
4620 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
4622 case x$PKG_CONFIG_LIBDIR in
4626 # Look for the library directory using the same prefix as the executable
4627 if test "x$PKG_CONFIG" = xnone
4631 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
4634 # If you don't like using the default architecture, you have to specify the
4635 # intended library directory and corresponding compiler/linker options.
4637 # This case allows for Debian's 2014-flavor of multiarch, along with the
4638 # most common variations before that point. Some other variants spell the
4639 # directory differently, e.g., "pkg-config", and put it in unusual places.
4640 # pkg-config has always been poorly standardized, which is ironic...
4641 case x`(arch) 2>/dev/null` in
4644 $cf_path/lib/*64-linux-gnu \
4652 $cf_path/lib/*-linux-gnu \
4661 for cf_config in $cf_search_path
4663 CF_VERBOSE(checking $cf_config/pkgconfig)
4664 if test -d "$cf_config/pkgconfig"
4666 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
4667 AC_MSG_CHECKING(done)
4676 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
4677 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4680 AC_SUBST(PKG_CONFIG_LIBDIR)
4682 dnl ---------------------------------------------------------------------------
4683 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4685 dnl Check for POSIX thread library.
4686 AC_DEFUN([CF_WITH_PTHREAD],
4688 AC_MSG_CHECKING(if you want to link with the pthread library)
4689 AC_ARG_WITH(pthread,
4690 [ --with-pthread use POSIX thread library],
4691 [with_pthread=$withval],
4693 AC_MSG_RESULT($with_pthread)
4695 if test "$with_pthread" != no ; then
4696 AC_CHECK_HEADER(pthread.h,[
4697 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4699 for cf_lib_pthread in pthread c_r
4701 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4702 cf_save_LIBS="$LIBS"
4703 CF_ADD_LIB($cf_lib_pthread)
4705 #include <pthread.h>
4707 int rc = pthread_create(0,0,0,0);
4708 int r2 = pthread_mutexattr_settype(0, 0);
4709 ],[with_pthread=yes],[with_pthread=no])
4710 LIBS="$cf_save_LIBS"
4711 AC_MSG_RESULT($with_pthread)
4712 test "$with_pthread" = yes && break
4715 if test "$with_pthread" = yes ; then
4716 CF_ADD_LIB($cf_lib_pthread)
4717 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4719 AC_MSG_ERROR(Cannot link with pthread library)
4724 dnl ---------------------------------------------------------------------------
4725 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
4727 dnl For testing, override the derived host system-type which is used to decide
4728 dnl things such as the linker commands used to build shared libraries. This is
4729 dnl normally chosen automatically based on the type of system which you are
4730 dnl building on. We use it for testing the configure script.
4732 dnl This is different from the --host option: it is used only for testing parts
4733 dnl of the configure script which would not be reachable with --host since that
4734 dnl relies on the build environment being real, rather than mocked up.
4735 AC_DEFUN([CF_WITH_SYSTYPE],[
4736 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
4737 AC_ARG_WITH(system-type,
4738 [ --with-system-type=XXX test: override derived host system-type],
4739 [AC_MSG_WARN(overriding system type to $withval)
4740 cf_cv_system_name=$withval
4744 dnl ---------------------------------------------------------------------------
4745 dnl CF_XOPEN_SOURCE version: 57 updated: 2021/01/01 16:53:59
4747 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4748 dnl or adapt to the vendor's definitions to get equivalent functionality,
4749 dnl without losing the common non-POSIX features.
4752 dnl $1 is the nominal value for _XOPEN_SOURCE
4753 dnl $2 is the nominal value for _POSIX_C_SOURCE
4754 AC_DEFUN([CF_XOPEN_SOURCE],[
4755 AC_REQUIRE([AC_CANONICAL_HOST])
4756 AC_REQUIRE([CF_POSIX_VISIBLE])
4758 if test "$cf_cv_posix_visible" = no; then
4760 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4761 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4766 cf_xopen_source="-D_ALL_SOURCE"
4772 cf_xopen_source="-D_APPLE_C_SOURCE"
4775 cf_xopen_source="-D_DARWIN_C_SOURCE"
4778 (freebsd*|dragonfly*|midnightbsd*)
4779 # 5.x headers associate
4780 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4781 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4782 cf_POSIX_C_SOURCE=200112L
4784 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4787 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4790 cf_xopen_source="-D_HPUX_SOURCE"
4793 cf_xopen_source="-D_SGI_SOURCE"
4796 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4797 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4800 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4803 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4805 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4808 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4811 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4812 cf_xopen_source="-D_BSD_SOURCE"
4816 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4819 cf_xopen_source="-D_OSF_SOURCE"
4822 cf_xopen_source="-D_QNX_SOURCE"
4825 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4828 cf_xopen_source="-D__EXTENSIONS__"
4829 cf_cv_xopen_source=broken
4831 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4837 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4841 if test -n "$cf_xopen_source" ; then
4842 CF_ADD_CFLAGS($cf_xopen_source,true)
4845 dnl In anything but the default case, we may have system-specific setting
4846 dnl which is still not guaranteed to provide all of the entrypoints that
4847 dnl _XOPEN_SOURCE would yield.
4848 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4849 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4850 AC_TRY_COMPILE([#include <stdlib.h>],[
4851 #ifndef _XOPEN_SOURCE
4854 [cf_XOPEN_SOURCE_set=yes],
4855 [cf_XOPEN_SOURCE_set=no])
4856 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4857 if test "$cf_XOPEN_SOURCE_set" = yes
4859 AC_TRY_COMPILE([#include <stdlib.h>],[
4860 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4863 [cf_XOPEN_SOURCE_set_ok=yes],
4864 [cf_XOPEN_SOURCE_set_ok=no])
4865 if test "$cf_XOPEN_SOURCE_set_ok" = no
4867 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4873 fi # cf_cv_posix_visible
4875 dnl ---------------------------------------------------------------------------
4876 dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20
4877 dnl ------------------
4878 dnl Trim something using sed, then trim extra whitespace
4879 dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT
4880 define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl