1 dnl***************************************************************************
2 dnl Copyright 2018-2019,2020 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.163 2020/10/31 20:04:06 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: 14 updated: 2020/04/04 16:16:13
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: 15 updated: 2018/06/20 20:23:13
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: 10 updated: 2015/04/18 08:56:57
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: 4 updated: 2013/10/08 17:47:05
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: 7 updated: 2020/04/04 11:37:29
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: 8 updated: 2018/01/04 20:31:04
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: 9 updated: 2018/07/29 18:03:26
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: 11 updated: 2015/04/17 21:13:04
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],
631 AC_MSG_CHECKING(for prefix)
632 if test "x$prefix" = "xNONE" ; then
633 case "$cf_cv_system_name" in
634 # non-vendor systems don't have a conflict
635 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
638 (*) prefix=$ac_default_prefix
642 AC_MSG_RESULT($prefix)
644 if test "x$prefix" = "xNONE" ; then
645 AC_MSG_CHECKING(for default include-directory)
646 test -n "$verbose" && echo 1>&AC_FD_MSG
649 $includedir/ncurses \
651 $prefix/include/ncurses \
653 /usr/local/include/ncurses \
657 cf_dir=`eval echo $cf_symbol`
658 if test -f $cf_dir/curses.h ; then
659 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
660 includedir="$cf_symbol"
661 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
665 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
667 AC_MSG_RESULT($includedir)
670 dnl ---------------------------------------------------------------------------
671 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
673 dnl Check if we're accidentally using a cache from a different machine.
674 dnl Derive the system name, as a check for reusing the autoconf cache.
676 dnl If we've packaged config.guess and config.sub, run that (since it does a
677 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
678 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
679 dnl which is useful in cross-compiles.
681 dnl Note: we would use $ac_config_sub, but that is one of the places where
682 dnl autoconf 2.5x broke compatibility with autoconf 2.13
683 AC_DEFUN([CF_CHECK_CACHE],
685 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
686 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
687 system_name="$host_os"
689 system_name="`(uname -s -r) 2>/dev/null`"
690 if test -z "$system_name" ; then
691 system_name="`(hostname) 2>/dev/null`"
694 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
695 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
697 test -z "$system_name" && system_name="$cf_cv_system_name"
698 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
700 if test ".$system_name" != ".$cf_cv_system_name" ; then
701 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
702 AC_MSG_ERROR("Please remove config.cache and try again.")
705 dnl ---------------------------------------------------------------------------
706 dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
707 dnl ---------------------
708 AC_DEFUN([CF_CHECK_GNAT_VERSION],
710 AC_REQUIRE([CF_GNAT_VERSION])
711 case $cf_cv_gnat_version in
712 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
713 cf_cv_prog_gnat_correct=yes
716 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
717 cf_cv_prog_gnat_correct=no
721 dnl ---------------------------------------------------------------------------
722 dnl CF_CLANG_COMPILER version: 4 updated: 2020/10/31 15:46:50
723 dnl -----------------
724 dnl Check if the given compiler is really clang. clang's C driver defines
725 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
726 dnl not ignore some gcc options.
728 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
729 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
730 dnl the wrappers for gcc and g++ warnings.
732 dnl $1 = GCC (default) or GXX
733 dnl $2 = CLANG_COMPILER (default)
734 dnl $3 = CFLAGS (default) or CXXFLAGS
735 AC_DEFUN([CF_CLANG_COMPILER],[
736 ifelse([$2],,CLANG_COMPILER,[$2])=no
738 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
739 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
740 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
746 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
748 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
749 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
752 if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then
753 for cf_clang_opt in \
755 -Wno-error=implicit-function-declaration
757 AC_MSG_CHECKING(if option $cf_clang_opt works)
759 #include <stdio.h>],[
760 printf("hello!\n");],[
761 cf_clang_optok=yes],[
763 AC_MSG_RESULT($cf_clang_optok)
764 if test $cf_clang_optok = yes; then
765 CF_VERBOSE(adding option $cf_clang_opt)
766 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt)
771 dnl ---------------------------------------------------------------------------
772 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
773 dnl -----------------
774 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
775 dnl character-strings.
777 dnl It is ambiguous because the specification accommodated the pre-ANSI
778 dnl compilers bundled by more than one vendor in lieu of providing a standard C
779 dnl compiler other than by costly add-ons. Because of this, the specification
780 dnl did not take into account the use of const for telling the compiler that
781 dnl string literals would be in readonly memory.
783 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
784 dnl let the compiler decide how to represent Xt's strings which were #define'd.
785 dnl That does not solve the problem of using the block of Xt's strings which
786 dnl are compiled into the library (and is less efficient than one might want).
788 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
789 dnl when compiling the library and compiling using the library, to tell the
790 dnl compiler that String is const.
791 AC_DEFUN([CF_CONST_X_STRING],
793 AC_REQUIRE([AC_PATH_XTRA])
795 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
800 #include <X11/Intrinsic.h>
802 [String foo = malloc(1); (void)foo],[
804 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
807 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
808 #undef XTSTRINGDEFINES /* X11R5 and later */
810 #include <X11/Intrinsic.h>
811 ],[String foo = malloc(1); *foo = 0],[
812 cf_cv_const_x_string=no
814 cf_cv_const_x_string=yes
818 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
820 case $cf_cv_const_x_string in
822 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
825 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
831 dnl ---------------------------------------------------------------------------
832 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
833 dnl -----------------
834 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
835 dnl character-strings.
837 dnl It is ambiguous because the specification accommodated the pre-ANSI
838 dnl compilers bundled by more than one vendor in lieu of providing a standard C
839 dnl compiler other than by costly add-ons. Because of this, the specification
840 dnl did not take into account the use of const for telling the compiler that
841 dnl string literals would be in readonly memory.
843 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
844 dnl let the compiler decide how to represent Xt's strings which were #define'd.
845 dnl That does not solve the problem of using the block of Xt's strings which
846 dnl are compiled into the library (and is less efficient than one might want).
848 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
849 dnl when compiling the library and compiling using the library, to tell the
850 dnl compiler that String is const.
851 AC_DEFUN([CF_CONST_X_STRING],
853 AC_REQUIRE([AC_PATH_XTRA])
855 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
860 #include <X11/Intrinsic.h>
862 [String foo = malloc(1); (void)foo],[
864 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
867 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
868 #undef XTSTRINGDEFINES /* X11R5 and later */
870 #include <X11/Intrinsic.h>
871 ],[String foo = malloc(1); *foo = 0],[
872 cf_cv_const_x_string=no
874 cf_cv_const_x_string=yes
878 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
880 case $cf_cv_const_x_string in
882 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
885 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
891 dnl ---------------------------------------------------------------------------
892 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
894 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
895 dnl variations of ncurses' installs.
897 dnl $1 = ncurses when looking for ncurses, or is empty
898 AC_DEFUN([CF_CURSES_HEADER],[
899 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
900 cf_cv_ncurses_header=none
902 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
903 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
905 AC_TRY_COMPILE([#include <${cf_header}>],
906 [initscr(); tgoto("?", 0,0)],
907 [cf_cv_ncurses_header=$cf_header; break],[])
911 if test "$cf_cv_ncurses_header" = none ; then
912 AC_MSG_ERROR(No curses header-files found)
915 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
916 AC_CHECK_HEADERS($cf_cv_ncurses_header)
918 dnl ---------------------------------------------------------------------------
919 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
921 dnl "dirname" is not portable, so we fake it with a shell script.
922 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
923 dnl ---------------------------------------------------------------------------
924 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
926 dnl You can always use "make -n" to see the actual options, but it's hard to
927 dnl pick out/analyze warning messages when the compile-line is long.
930 dnl ECHO_LT - symbol to control if libtool is verbose
931 dnl ECHO_LD - symbol to prefix "cc -o" lines
932 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
933 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
934 dnl ECHO_CC - symbol to put before any "cc" line
936 AC_DEFUN([CF_DISABLE_ECHO],[
937 AC_MSG_CHECKING(if you want to see long compiling messages)
939 [ --disable-echo do not display "compiling" commands],
942 ECHO_LD='@echo linking [$]@;'
943 RULE_CC='@echo compiling [$]<'
944 SHOW_CC='@echo compiling [$]@'
953 AC_MSG_RESULT($enableval)
960 dnl ---------------------------------------------------------------------------
961 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
962 dnl ------------------------
963 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
964 AC_MSG_CHECKING(if we want to use GNAT projects)
965 CF_ARG_DISABLE(gnat-projects,
966 [ --disable-gnat-projects test: disable GNAT projects even if usable],
967 [enable_gnat_projects=no],
968 [enable_gnat_projects=yes])
969 AC_MSG_RESULT($enable_gnat_projects)
971 dnl ---------------------------------------------------------------------------
972 dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
973 dnl -----------------------
974 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
975 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
976 dnl an unconditional feature.
977 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
979 AC_MSG_CHECKING(if you want broken-linker support code)
980 AC_ARG_ENABLE(broken_linker,
981 [ --enable-broken_linker compile with broken-linker support code],
982 [with_broken_linker=$enableval],
983 [with_broken_linker=no])
984 AC_MSG_RESULT($with_broken_linker)
986 : ${BROKEN_LINKER:=0}
987 if test "x$with_broken_linker" = xyes ; then
988 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
991 AC_SUBST(BROKEN_LINKER)
993 dnl ---------------------------------------------------------------------------
994 dnl CF_ENABLE_WARNINGS version: 7 updated: 2020/08/29 09:05:21
995 dnl ------------------
996 dnl Configure-option to enable gcc warnings
998 dnl $1 = extra options to add, if supported
999 dnl $2 = option for checking attributes. By default, this is done when
1000 dnl warnings are enabled. For other values:
1001 dnl yes: always do this, e.g., to use in generated library-headers
1002 dnl no: never do this
1003 AC_DEFUN([CF_ENABLE_WARNINGS],[
1004 if ( test "$GCC" = yes || test "$GXX" = yes )
1006 CF_FIX_WARNINGS(CFLAGS)
1007 CF_FIX_WARNINGS(CPPFLAGS)
1008 CF_FIX_WARNINGS(LDFLAGS)
1009 AC_MSG_CHECKING(if you want to turn on gcc warnings)
1010 CF_ARG_ENABLE(warnings,
1011 [ --enable-warnings test: turn on gcc compiler warnings],
1012 [with_warnings=yes],
1014 AC_MSG_RESULT($with_warnings)
1015 if test "$with_warnings" = "yes"
1017 ifelse($2,,[CF_GCC_ATTRIBUTES])
1020 ifelse($2,yes,[CF_GCC_ATTRIBUTES])
1023 dnl ---------------------------------------------------------------------------
1024 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
1026 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
1027 dnl prefer a standard location, and use -L options only if we do not find the
1028 dnl library in the standard library location(s).
1029 dnl $1 = library name
1030 dnl $2 = library class, usually the same as library name
1032 dnl $4 = code fragment to compile/link
1033 dnl $5 = corresponding function-name
1034 dnl $6 = flag, nonnull if failure should not cause an error-exit
1036 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
1037 dnl to use a -L option.
1038 AC_DEFUN([CF_FIND_LIBRARY],
1040 eval 'cf_cv_have_lib_'$1'=no'
1043 eval 'cf_cv_have_lib_'$1'=yes',[
1044 cf_save_LIBS="$LIBS"
1045 AC_MSG_CHECKING(for $5 in -l$1)
1047 AC_TRY_LINK([$3],[$4],
1049 eval 'cf_cv_have_lib_'$1'=yes'
1052 CF_LIBRARY_PATH(cf_search,$2)
1053 for cf_libdir in $cf_search
1055 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1056 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1057 AC_TRY_LINK([$3],[$4],
1059 eval 'cf_cv_have_lib_'$1'=yes'
1062 LIBS="$cf_save_LIBS"])
1066 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
1068 if test $cf_found_library = no ; then
1069 AC_MSG_ERROR(Cannot link $1 library)
1073 dnl ---------------------------------------------------------------------------
1074 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
1076 dnl Find a library (specifically the linkage used in the code fragment),
1077 dnl searching for it if it is not already in the library path.
1078 dnl See also CF_ADD_SEARCHPATH.
1080 dnl Parameters (4-on are optional):
1081 dnl $1 = headers for library entrypoint
1082 dnl $2 = code fragment for library entrypoint
1083 dnl $3 = the library name without the "-l" option or ".so" suffix.
1084 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1085 dnl $5 = action to perform if not successful
1086 dnl $6 = module name, if not the same as the library name
1087 dnl $7 = extra libraries
1089 dnl Sets these variables:
1090 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1091 dnl $cf_cv_header_path_$3 - include-directory if needed
1092 dnl $cf_cv_library_path_$3 - library-directory if needed
1093 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1094 AC_DEFUN([CF_FIND_LINKAGE],[
1096 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1097 # will be set on completion of the AC_TRY_LINK below.
1098 cf_cv_header_path_$3=
1099 cf_cv_library_path_$3=
1101 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1103 cf_save_LIBS="$LIBS"
1105 AC_TRY_LINK([$1],[$2],[
1106 cf_cv_find_linkage_$3=yes
1107 cf_cv_header_path_$3=/usr/include
1108 cf_cv_library_path_$3=/usr/lib
1111 LIBS="-l$3 $7 $cf_save_LIBS"
1113 AC_TRY_LINK([$1],[$2],[
1114 cf_cv_find_linkage_$3=yes
1115 cf_cv_header_path_$3=/usr/include
1116 cf_cv_library_path_$3=/usr/lib
1117 cf_cv_library_file_$3="-l$3"
1119 cf_cv_find_linkage_$3=no
1120 LIBS="$cf_save_LIBS"
1122 CF_VERBOSE(find linkage for $3 library)
1123 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1125 cf_save_CPPFLAGS="$CPPFLAGS"
1126 cf_test_CPPFLAGS="$CPPFLAGS"
1128 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1129 for cf_cv_header_path_$3 in $cf_search
1131 if test -d $cf_cv_header_path_$3 ; then
1132 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1133 CPPFLAGS="$cf_save_CPPFLAGS"
1134 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1135 AC_TRY_COMPILE([$1],[$2],[
1136 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1137 cf_cv_find_linkage_$3=maybe
1138 cf_test_CPPFLAGS="$CPPFLAGS"
1140 CPPFLAGS="$cf_save_CPPFLAGS"
1145 if test "$cf_cv_find_linkage_$3" = maybe ; then
1147 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1149 cf_save_LIBS="$LIBS"
1150 cf_save_LDFLAGS="$LDFLAGS"
1153 CPPFLAGS="$cf_test_CPPFLAGS"
1154 LIBS="-l$3 $7 $cf_save_LIBS"
1155 AC_TRY_LINK([$1],[$2],[
1156 CF_VERBOSE(... found $3 library in system)
1157 cf_cv_find_linkage_$3=yes])
1158 CPPFLAGS="$cf_save_CPPFLAGS"
1159 LIBS="$cf_save_LIBS"
1162 if test "$cf_cv_find_linkage_$3" != yes ; then
1163 CF_LIBRARY_PATH(cf_search,$3)
1164 for cf_cv_library_path_$3 in $cf_search
1166 if test -d $cf_cv_library_path_$3 ; then
1167 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1168 CPPFLAGS="$cf_test_CPPFLAGS"
1169 LIBS="-l$3 $7 $cf_save_LIBS"
1170 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1171 AC_TRY_LINK([$1],[$2],[
1172 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1173 cf_cv_find_linkage_$3=yes
1174 cf_cv_library_file_$3="-l$3"
1176 CPPFLAGS="$cf_save_CPPFLAGS"
1177 LIBS="$cf_save_LIBS"
1178 LDFLAGS="$cf_save_LDFLAGS"
1182 CPPFLAGS="$cf_save_CPPFLAGS"
1183 LDFLAGS="$cf_save_LDFLAGS"
1187 cf_cv_find_linkage_$3=no
1192 LIBS="$cf_save_LIBS"
1194 if test "$cf_cv_find_linkage_$3" = yes ; then
1196 CF_ADD_INCDIR($cf_cv_header_path_$3)
1197 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1201 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1204 dnl ---------------------------------------------------------------------------
1205 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1206 dnl -----------------
1207 dnl make ADAFLAGS consistent with CFLAGS
1208 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1209 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1217 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1218 CF_ADD_ADAFLAGS($cf_O_flag)
1221 AC_MSG_RESULT($ADAFLAGS)
1223 dnl ---------------------------------------------------------------------------
1224 dnl CF_FIX_WARNINGS version: 2 updated: 2020/08/28 15:08:28
1226 dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's
1227 dnl "-Werror" flags can interfere with configure-checks. Those go into
1230 dnl $1 = variable name to repair
1231 define([CF_FIX_WARNINGS],[
1232 if ( test "$GCC" = yes || test "$GXX" = yes )
1236 CF_VERBOSE(repairing $1: [$]$1)
1238 for cf_temp_scan in [$]$1
1240 case "x$cf_temp_scan" in
1242 CF_APPEND_TEXT(EXTRA_CFLAGS,"$cf_temp_scan")
1245 CF_APPEND_TEXT(cf_temp_flags,"$cf_temp_scan")
1250 CF_VERBOSE(... fixed [$]$1)
1251 CF_VERBOSE(... extra $EXTRA_CFLAGS)
1255 AC_SUBST(EXTRA_CFLAGS)
1257 dnl ---------------------------------------------------------------------------
1258 dnl CF_GCC_ATTRIBUTES version: 19 updated: 2020/08/29 09:05:21
1259 dnl -----------------
1260 dnl Test for availability of useful gcc __attribute__ directives to quiet
1261 dnl compiler warnings. Though useful, not all are supported -- and contrary
1262 dnl to documentation, unrecognized directives cause older compilers to barf.
1263 AC_DEFUN([CF_GCC_ATTRIBUTES],
1265 if ( test "$GCC" = yes || test "$GXX" = yes )
1267 cat > conftest.i <<EOF
1269 #define GCC_PRINTF 0
1274 #ifndef GCC_NORETURN
1275 #define GCC_NORETURN /* nothing */
1278 #define GCC_UNUSED /* nothing */
1281 if test "$GCC" = yes
1283 AC_CHECKING([for $CC __attribute__ directives])
1284 cat > conftest.$ac_ext <<EOF
1285 #line __oline__ "${as_me:-configure}"
1286 #include "confdefs.h"
1287 #include "conftest.h"
1288 #include "conftest.i"
1290 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1292 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1295 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1297 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1299 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1300 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1301 extern void foo(void) GCC_NORETURN;
1302 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1304 cf_printf_attribute=no
1305 cf_scanf_attribute=no
1306 for cf_attribute in scanf printf unused noreturn
1308 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1309 cf_directive="__attribute__(($cf_attribute))"
1310 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1312 case $cf_attribute in
1314 cf_printf_attribute=yes
1315 cat >conftest.h <<EOF
1316 #define GCC_$cf_ATTRIBUTE 1
1320 cf_scanf_attribute=yes
1321 cat >conftest.h <<EOF
1322 #define GCC_$cf_ATTRIBUTE 1
1326 cat >conftest.h <<EOF
1327 #define GCC_$cf_ATTRIBUTE $cf_directive
1332 if AC_TRY_EVAL(ac_compile); then
1333 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1334 cat conftest.h >>confdefs.h
1335 case $cf_attribute in
1337 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1340 cf_value='/* nothing */'
1341 if test "$cf_printf_attribute" != no ; then
1342 cf_value='__attribute__((format(printf,fmt,var)))'
1343 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1345 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1348 cf_value='/* nothing */'
1349 if test "$cf_scanf_attribute" != no ; then
1350 cf_value='__attribute__((format(scanf,fmt,var)))'
1351 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1353 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1356 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1362 fgrep define conftest.i >>confdefs.h
1367 dnl ---------------------------------------------------------------------------
1368 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1370 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1371 dnl compatible), attempt to determine if icc/clang is actually used.
1372 AC_DEFUN([CF_GCC_VERSION],[
1373 AC_REQUIRE([AC_PROG_CC])
1375 if test "$GCC" = yes ; then
1376 AC_MSG_CHECKING(version of $CC)
1377 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.]].*//'`"
1378 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1379 AC_MSG_RESULT($GCC_VERSION)
1381 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1382 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1384 dnl ---------------------------------------------------------------------------
1385 dnl CF_GCC_WARNINGS version: 38 updated: 2020/08/28 15:08:28
1387 dnl Check if the compiler supports useful warning options. There's a few that
1388 dnl we don't use, simply because they're too noisy:
1390 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1391 dnl -Winline (usually not worthwhile)
1392 dnl -Wredundant-decls (system headers make this too noisy)
1393 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1394 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1395 dnl is enabled for ncurses using "--enable-const".
1399 dnl $1 is an optional list of gcc warning flags that a particular
1400 dnl application might want to use, e.g., "no-unused" for
1403 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1405 AC_DEFUN([CF_GCC_WARNINGS],
1407 AC_REQUIRE([CF_GCC_VERSION])
1408 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1409 cat > conftest.$ac_ext <<EOF
1410 #line __oline__ "${as_me:-configure}"
1411 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1413 if test "$INTEL_COMPILER" = yes
1415 # The "-wdXXX" options suppress warnings:
1416 # remark #1419: external declaration in primary source file
1417 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1418 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1419 # remark #193: zero used for undefined preprocessing identifier
1420 # remark #593: variable "curs_sb_left_arrow" was set but never used
1421 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1422 # remark #869: parameter "tw" was never referenced
1423 # remark #981: operands are evaluated in unspecified order
1424 # warning #279: controlling expression is constant
1426 AC_CHECKING([for $CC warning options])
1427 cf_save_CFLAGS="$CFLAGS"
1428 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
1440 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1441 if AC_TRY_EVAL(ac_compile); then
1442 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1443 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1446 CFLAGS="$cf_save_CFLAGS"
1447 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1449 AC_CHECKING([for $CC warning options])
1450 cf_save_CFLAGS="$CFLAGS"
1452 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1453 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1454 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1455 for cf_opt in W Wall \
1456 Wbad-function-cast \
1459 Wdeclaration-after-statement \
1462 Wmissing-declarations \
1463 Wmissing-prototypes \
1467 Wstrict-prototypes \
1468 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1470 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1471 if AC_TRY_EVAL(ac_compile); then
1472 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1475 case $GCC_VERSION in
1477 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1482 case $GCC_VERSION in
1484 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1489 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1492 CFLAGS="$cf_save_CFLAGS"
1496 AC_SUBST(EXTRA_CFLAGS)
1498 dnl ---------------------------------------------------------------------------
1499 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1500 dnl -----------------
1501 AC_DEFUN([CF_GNATPREP_OPT_T],[
1502 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1503 cf_cv_gnatprep_opt_t=no
1504 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1506 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1507 AC_SUBST(GNATPREP_OPTS)
1509 dnl ---------------------------------------------------------------------------
1510 dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
1511 dnl ----------------
1512 AC_DEFUN([CF_GNAT_GENERICS],
1514 AC_REQUIRE([CF_GNAT_VERSION])
1516 AC_MSG_CHECKING(if GNAT supports generics)
1517 case $cf_cv_gnat_version in
1518 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1519 cf_gnat_generics=yes
1525 AC_MSG_RESULT($cf_gnat_generics)
1527 if test "$cf_gnat_generics" = yes
1529 cf_compile_generics=generics
1530 cf_generic_objects="\${GENOBJS}"
1532 cf_compile_generics=
1536 AC_SUBST(cf_compile_generics)
1537 AC_SUBST(cf_generic_objects)
1539 dnl ---------------------------------------------------------------------------
1540 dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54
1541 dnl ----------------
1542 dnl GNAT projects are configured with ".gpr" project files.
1543 dnl GNAT libraries are a further development, using the project feature.
1544 AC_DEFUN([CF_GNAT_PROJECTS],
1546 AC_REQUIRE([CF_GNAT_VERSION])
1547 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1549 cf_gnat_libraries=no
1552 if test "$enable_gnat_projects" != no ; then
1553 AC_MSG_CHECKING(if GNAT supports project files)
1554 case $cf_cv_gnat_version in
1558 case $cf_cv_system_name in
1562 rm -rf conftest* *~conftest*
1563 if mkdir conftest.src conftest.bin conftest.lib
1566 rm -rf conftest* *~conftest*
1567 cat >>library.gpr <<CF_EOF
1569 Kind := External ("LIB_KIND");
1570 for Library_Name use "ConfTest";
1571 for Object_Dir use ".";
1572 for Library_ALI_Dir use External("LIBRARY_DIR");
1573 for Library_Version use External ("SONAME");
1574 for Library_Kind use Kind;
1575 for Library_Dir use External("BUILD_DIR");
1576 Source_Dir := External ("SOURCE_DIR");
1577 for Source_Dirs use (Source_Dir);
1580 cat >>confpackage.ads <<CF_EOF
1581 package ConfPackage is
1585 cat >>confpackage.adb <<CF_EOF
1587 package body ConfPackage is
1588 procedure conftest is
1590 Text_IO.Put ("Hello World");
1595 if ( $cf_ada_make $ADAFLAGS \
1597 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1598 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1599 -XSOURCE_DIR=`pwd` \
1600 -XSONAME=libConfTest.so.1 \
1601 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1602 cf_gnat_projects=yes
1606 if test -f conftest.lib/confpackage.ali
1608 cf_gnat_libraries=yes
1610 rm -rf conftest* *~conftest*
1615 AC_MSG_RESULT($cf_gnat_projects)
1616 fi # enable_gnat_projects
1618 if test $cf_gnat_projects = yes
1620 AC_MSG_CHECKING(if GNAT supports libraries)
1621 AC_MSG_RESULT($cf_gnat_libraries)
1624 if test "$cf_gnat_projects" = yes
1626 USE_OLD_MAKERULES="#"
1627 USE_GNAT_PROJECTS=""
1629 USE_OLD_MAKERULES=""
1630 USE_GNAT_PROJECTS="#"
1633 if test "$cf_gnat_libraries" = yes
1635 USE_GNAT_LIBRARIES=""
1637 USE_GNAT_LIBRARIES="#"
1640 AC_SUBST(USE_OLD_MAKERULES)
1641 AC_SUBST(USE_GNAT_PROJECTS)
1642 AC_SUBST(USE_GNAT_LIBRARIES)
1644 dnl ---------------------------------------------------------------------------
1645 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
1647 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1648 dnl is noted that gnat may compile a tasking unit even for configurations which
1649 dnl fail at runtime.
1650 AC_DEFUN([CF_GNAT_SIGINT],[
1651 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1652 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1656 pragma Warnings (Off); -- the next pragma exists since 3.11p
1657 pragma Unreserve_All_Interrupts;
1658 pragma Warnings (On);
1660 protected Process is
1662 function Continue return Boolean;
1663 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1665 Done : Boolean := False;
1669 [package body ConfTest is
1670 protected body Process is
1675 function Continue return Boolean is
1681 [cf_cv_gnat_sigint=yes],
1682 [cf_cv_gnat_sigint=no])])
1684 if test $cf_cv_gnat_sigint = yes ; then
1689 AC_SUBST(USE_GNAT_SIGINT)
1691 dnl ---------------------------------------------------------------------------
1692 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
1693 dnl ----------------
1694 dnl Verify that a test program compiles/links with GNAT.
1695 dnl $cf_ada_make is set to the program that compiles/links
1696 dnl $ADAFLAGS may be set to the GNAT flags.
1698 dnl $1 is the text of the spec
1699 dnl $2 is the text of the body
1700 dnl $3 is the shell command to execute if successful
1701 dnl $4 is the shell command to execute if not successful
1702 AC_DEFUN([CF_GNAT_TRY_LINK],
1704 rm -rf conftest* *~conftest*
1705 cat >>conftest.ads <<CF_EOF
1708 cat >>conftest.adb <<CF_EOF
1711 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1712 ifelse($3,, :,[ $3])
1716 rm -rf conftest* *~conftest*
1718 dnl ---------------------------------------------------------------------------
1719 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
1721 dnl Verify that a test program compiles and runs with GNAT
1722 dnl $cf_ada_make is set to the program that compiles/links
1723 dnl $ADAFLAGS may be set to the GNAT flags.
1725 dnl $1 is the text of the spec
1726 dnl $2 is the text of the body
1727 dnl $3 is the shell command to execute if successful
1728 dnl $4 is the shell command to execute if not successful
1729 AC_DEFUN([CF_GNAT_TRY_RUN],
1731 rm -rf conftest* *~conftest*
1732 cat >>conftest.ads <<CF_EOF
1735 cat >>conftest.adb <<CF_EOF
1738 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1739 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1740 ifelse($3,, :,[ $3])
1747 rm -rf conftest* *~conftest*
1749 dnl ---------------------------------------------------------------------------
1750 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1752 dnl $1 = cache variable to update
1753 dnl $2 = program name
1754 dnl Verify version of GNAT or related tool
1755 AC_DEFUN([CF_GNAT_VERSION],
1757 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1758 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1759 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1760 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1762 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1763 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1765 dnl ---------------------------------------------------------------------------
1766 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1768 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1769 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1770 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1771 dnl since it is interwoven with GNU extensions.
1773 dnl Well, yes we could work around it...
1776 dnl $1 is the nominal value for _XOPEN_SOURCE
1777 AC_DEFUN([CF_GNU_SOURCE],
1779 cf_gnu_xopen_source=ifelse($1,,500,$1)
1781 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1782 AC_TRY_COMPILE([#include <sys/types.h>],[
1783 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1785 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1788 # error not GNU C library
1790 [cf_cv_gnu_library=yes],
1791 [cf_cv_gnu_library=no])
1794 if test x$cf_cv_gnu_library = xyes; then
1796 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1797 # was changed to help a little. newlib incorporated the change about 4
1799 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1801 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1802 AC_TRY_COMPILE([#include <sys/types.h>],[
1803 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1805 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1808 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1810 [cf_cv_gnu_library_219=yes],
1811 [cf_cv_gnu_library_219=no])
1815 if test "x$cf_cv_gnu_library_219" = xyes; then
1817 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1818 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1821 #include <sys/types.h>
1823 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1826 # error GNU C library is too old
1828 [cf_cv_gnu_dftsrc_219=yes],
1829 [cf_cv_gnu_dftsrc_219=no])
1831 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1833 cf_cv_gnu_dftsrc_219=maybe
1836 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1838 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1839 AC_TRY_COMPILE([#include <sys/types.h>],[
1840 #ifndef _XOPEN_SOURCE
1841 #error expected _XOPEN_SOURCE to be defined
1843 [cf_cv_gnu_source=no],
1844 [cf_save="$CPPFLAGS"
1845 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1846 AC_TRY_COMPILE([#include <sys/types.h>],[
1847 #ifdef _XOPEN_SOURCE
1848 #error expected _XOPEN_SOURCE to be undefined
1850 [cf_cv_gnu_source=no],
1851 [cf_cv_gnu_source=yes])
1856 if test "$cf_cv_gnu_source" = yes
1858 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1859 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1860 AC_TRY_COMPILE([#include <sys/types.h>],[
1861 #ifdef _DEFAULT_SOURCE
1862 #error expected _DEFAULT_SOURCE to be undefined
1864 [cf_cv_default_source=no],
1865 [cf_cv_default_source=yes])
1867 if test "$cf_cv_default_source" = yes
1869 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1876 dnl ---------------------------------------------------------------------------
1877 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1879 dnl Construct a search-list of directories for a nonstandard header-file
1882 dnl $1 = the variable to return as result
1883 dnl $2 = the package name
1884 AC_DEFUN([CF_HEADER_PATH],
1888 # collect the current set of include-directories from compiler flags
1889 cf_header_path_list=""
1890 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1891 for cf_header_path in $CPPFLAGS $CFLAGS
1893 case $cf_header_path in
1895 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1896 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1897 cf_header_path_list="$cf_header_path_list [$]$1"
1903 # add the variations for the package we are looking for
1904 CF_SUBDIR_PATH($1,$2,include)
1906 test "$includedir" != NONE && \
1907 test "$includedir" != "/usr/include" && \
1908 test -d "$includedir" && {
1909 test -d $includedir && $1="[$]$1 $includedir"
1910 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1913 test "$oldincludedir" != NONE && \
1914 test "$oldincludedir" != "/usr/include" && \
1915 test -d "$oldincludedir" && {
1916 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
1917 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1920 $1="[$]$1 $cf_header_path_list"
1922 dnl ---------------------------------------------------------------------------
1923 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
1925 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1926 AC_DEFUN([CF_HELP_MESSAGE],
1927 [CF_ACVERSION_CHECK(2.53,[],[
1928 AC_DIVERT_HELP($1)])dnl
1930 dnl ---------------------------------------------------------------------------
1931 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
1933 dnl Construct the list of include-options according to whether we're building
1934 dnl in the source directory or using '--srcdir=DIR' option.
1935 AC_DEFUN([CF_INCLUDE_DIRS],
1937 if test "$srcdir" != "."; then
1938 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1940 CPPFLAGS="-I../include $CPPFLAGS"
1941 if test "$srcdir" != "."; then
1942 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
1944 CPPFLAGS="-I. $CPPFLAGS"
1947 dnl ---------------------------------------------------------------------------
1948 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
1950 dnl prompt for/fill-in useful install-program options
1951 AC_DEFUN([CF_INSTALL_OPTS],
1957 dnl ---------------------------------------------------------------------------
1958 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
1959 dnl ----------------
1960 dnl Almost all "install" programs default to the current user's ownership.
1961 dnl Almost - MINIX is an exception.
1962 AC_DEFUN([CF_INSTALL_OPT_O],
1964 AC_MSG_CHECKING(if install needs to be told about ownership)
1965 case `$ac_config_guess` in
1974 AC_MSG_RESULT($with_install_o)
1975 if test "x$with_install_o" = xyes
1977 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'`
1982 AC_SUBST(INSTALL_OPT_O)
1984 dnl ---------------------------------------------------------------------------
1985 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
1986 dnl ----------------
1987 dnl Some install-programs accept a "-p" option to preserve file modification
1988 dnl timestamps. That can be useful as an install option, as well as a way to
1989 dnl avoid the need for ranlib after copying a static archive.
1990 AC_DEFUN([CF_INSTALL_OPT_P],
1992 : ${INSTALL:=install}
1993 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
1998 if $INSTALL -p conftest.in conftest.out 2>/dev/null
2000 if test -f conftest.out/conftest.in
2002 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
2003 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
2004 if test -s conftest.err
2019 dnl ---------------------------------------------------------------------------
2020 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
2021 dnl ----------------
2022 dnl By default, we should strip executables which are installed, but leave the
2023 dnl ability to suppress that for unit-testing.
2024 AC_DEFUN([CF_INSTALL_OPT_S],
2026 AC_MSG_CHECKING(if you want to install stripped executables)
2027 CF_ARG_DISABLE(stripping,
2028 [ --disable-stripping do not strip (debug info) installed executables],
2029 [with_stripping=no],
2030 [with_stripping=yes])
2031 AC_MSG_RESULT($with_stripping)
2033 if test "$with_stripping" = yes
2039 AC_SUBST(INSTALL_OPT_S)
2041 dnl ---------------------------------------------------------------------------
2042 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
2043 dnl -----------------
2044 dnl Check if the given compiler is really the Intel compiler for Linux. It
2045 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
2046 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
2048 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
2049 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
2050 dnl the wrappers for gcc and g++ warnings.
2052 dnl $1 = GCC (default) or GXX
2053 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
2054 dnl $3 = CFLAGS (default) or CXXFLAGS
2055 AC_DEFUN([CF_INTEL_COMPILER],[
2056 AC_REQUIRE([AC_CANONICAL_HOST])
2057 ifelse([$2],,INTEL_COMPILER,[$2])=no
2059 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
2062 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
2063 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
2064 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
2066 #ifdef __INTEL_COMPILER
2070 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
2071 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
2073 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
2074 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
2079 dnl ---------------------------------------------------------------------------
2080 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
2082 dnl Add checks for large file support.
2083 AC_DEFUN([CF_LARGEFILE],[
2084 ifdef([AC_FUNC_FSEEKO],[
2086 if test "$enable_largefile" != no ; then
2089 # Normally we would collect these definitions in the config.h,
2090 # but (like _XOPEN_SOURCE), some environments rely on having these
2091 # defined before any of the system headers are included. Another
2092 # case comes up with C++, e.g., on AIX the compiler compiles the
2093 # header files by themselves before looking at the body files it is
2094 # told to compile. For ncurses, those header files do not include
2096 if test "$ac_cv_sys_large_files" != no
2098 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2100 if test "$ac_cv_sys_largefile_source" != no
2102 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2104 if test "$ac_cv_sys_file_offset_bits" != no
2106 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2109 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2111 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2112 #include <sys/types.h>
2115 /* if transitional largefile support is setup, this is true */
2116 extern struct dirent64 * readdir(DIR *);
2117 struct dirent64 *x = readdir((DIR *)0);
2118 struct dirent *y = readdir((DIR *)0);
2122 [cf_cv_struct_dirent64=yes],
2123 [cf_cv_struct_dirent64=no])
2125 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2129 dnl ---------------------------------------------------------------------------
2130 dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
2132 dnl For the given system and compiler, find the compiler flags to pass to the
2133 dnl loader to use the "rpath" feature.
2134 AC_DEFUN([CF_LD_RPATH_OPT],
2136 AC_REQUIRE([CF_CHECK_CACHE])
2139 if test "x$cf_cv_enable_rpath" != xno
2141 AC_MSG_CHECKING(for an rpath option)
2142 case $cf_cv_system_name in
2144 if test "$GCC" = yes; then
2145 LD_RPATH_OPT="-Wl,-rpath,"
2147 LD_RPATH_OPT="-rpath "
2150 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2151 LD_RPATH_OPT="-Wl,-rpath,"
2153 (openbsd[[2-9]].*|mirbsd*)
2154 LD_RPATH_OPT="-Wl,-rpath,"
2157 LD_RPATH_OPT="-rpath "
2160 LD_RPATH_OPT="-Wl,-rpath,"
2163 LD_RPATH_OPT="-rpath "
2171 AC_MSG_RESULT($LD_RPATH_OPT)
2173 case "x$LD_RPATH_OPT" in
2175 AC_MSG_CHECKING(if we need a space after rpath option)
2176 cf_save_LIBS="$LIBS"
2177 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2178 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2179 LIBS="$cf_save_LIBS"
2180 AC_MSG_RESULT($cf_rpath_space)
2181 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2186 dnl ---------------------------------------------------------------------------
2187 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
2189 dnl Construct a search-list of directories for a nonstandard library-file
2192 dnl $1 = the variable to return as result
2193 dnl $2 = the package name
2194 AC_DEFUN([CF_LIBRARY_PATH],
2197 cf_library_path_list=""
2198 if test -n "${LDFLAGS}${LIBS}" ; then
2199 for cf_library_path in $LDFLAGS $LIBS
2201 case $cf_library_path in
2203 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2204 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2205 cf_library_path_list="$cf_library_path_list [$]$1"
2211 CF_SUBDIR_PATH($1,$2,lib)
2213 $1="$cf_library_path_list [$]$1"
2215 dnl ---------------------------------------------------------------------------
2216 dnl CF_LIB_PREFIX version: 13 updated: 2020/04/04 10:11:47
2218 dnl Compute the library-prefix for the given host system
2219 dnl $1 = variable to set
2220 define([CF_LIB_PREFIX],
2222 case $cf_cv_system_name in
2224 if test "$DFT_LWR_MODEL" = libtool; then
2233 (*) LIB_PREFIX='lib'
2236 ifelse($1,,,[$1=$LIB_PREFIX])
2237 AC_SUBST(LIB_PREFIX)
2239 dnl ---------------------------------------------------------------------------
2240 dnl CF_LIB_SUFFIX version: 26 updated: 2020/04/04 10:11:47
2242 dnl Compute the library file-suffix from the given model name
2244 dnl $2 = variable to set (the nominal library suffix)
2245 dnl $3 = dependency variable to set (actual filename)
2246 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2247 AC_DEFUN([CF_LIB_SUFFIX],
2255 case $cf_cv_system_name in
2266 case $cf_cv_system_name in
2277 case $cf_cv_system_name in
2286 (cygwin*|msys*|mingw*)
2324 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2326 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2327 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2330 dnl ---------------------------------------------------------------------------
2331 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2333 dnl Compute the string to append to -library from the given model name
2335 dnl $2 = variable to set
2336 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2337 AC_DEFUN([CF_LIB_TYPE],
2343 (profile) $2='_p' ;;
2346 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2348 dnl ---------------------------------------------------------------------------
2349 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2350 dnl ----------------
2351 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2352 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2353 dnl have to provide wrappers for global tables to ensure they're linked
2355 AC_DEFUN([CF_LINK_DATAONLY],
2357 AC_MSG_CHECKING([if data-only library module links])
2358 AC_CACHE_VAL(cf_cv_link_dataonly,[
2360 cat >conftest.$ac_ext <<EOF
2361 #line __oline__ "configure"
2362 int testdata[[3]] = { 123, 456, 789 };
2364 if AC_TRY_EVAL(ac_compile) ; then
2365 mv conftest.o data.o && \
2366 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2368 rm -f conftest.$ac_ext data.o
2369 cat >conftest.$ac_ext <<EOF
2370 #line __oline__ "configure"
2374 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2376 extern int testdata[[3]];
2377 return testdata[[0]] == 123
2378 && testdata[[1]] == 456
2379 && testdata[[2]] == 789;
2383 if AC_TRY_EVAL(ac_compile); then
2384 mv conftest.o func.o && \
2385 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2387 rm -f conftest.$ac_ext func.o
2388 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2390 LIBS="conftest.a $LIBS"
2394 extern int testfunc();
2395 ${cf_cv_main_return:-return} (!testfunc());
2398 [cf_cv_link_dataonly=yes],
2399 [cf_cv_link_dataonly=no],
2400 [cf_cv_link_dataonly=unknown])
2403 AC_MSG_RESULT($cf_cv_link_dataonly)
2405 if test "$cf_cv_link_dataonly" = no ; then
2406 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2409 AC_SUBST(BROKEN_LINKER)
2412 dnl ---------------------------------------------------------------------------
2413 dnl CF_MAKEFLAGS version: 18 updated: 2018/02/21 21:26:03
2415 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2416 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2417 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2418 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2419 AC_DEFUN([CF_MAKEFLAGS],
2421 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2423 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2425 cat >cf_makeflags.tmp <<CF_EOF
2428 @ echo '.$cf_option'
2430 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2431 case "$cf_result" in
2433 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2434 case "$cf_result" in
2435 (.*CC=*) cf_cv_makeflags=
2437 (*) cf_cv_makeflags=$cf_option
2445 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2449 rm -f cf_makeflags.tmp
2452 AC_SUBST(cf_cv_makeflags)
2454 dnl ---------------------------------------------------------------------------
2455 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2457 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2458 dnl a monocase filesystem.
2459 AC_DEFUN([CF_MAKE_TAGS],[
2460 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2462 AC_CHECK_PROGS(CTAGS, exctags ctags)
2463 AC_CHECK_PROGS(ETAGS, exetags etags)
2465 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2467 if test "$cf_cv_mixedcase" = yes ; then
2468 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2473 if test "$MAKE_UPPER_TAGS" = yes ; then
2479 if test "$MAKE_LOWER_TAGS" = yes ; then
2488 AC_SUBST(MAKE_UPPER_TAGS)
2489 AC_SUBST(MAKE_LOWER_TAGS)
2491 dnl ---------------------------------------------------------------------------
2492 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
2493 dnl ----------------------
2494 dnl Check if the file-system supports mixed-case filenames. If we're able to
2495 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2496 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2498 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2499 if test "$cross_compiling" = yes ; then
2500 case $target_alias in
2501 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
2509 rm -f conftest CONFTEST
2511 if test -f CONFTEST ; then
2516 rm -f conftest CONFTEST
2519 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2521 dnl ---------------------------------------------------------------------------
2522 dnl CF_MKSTEMP version: 10 updated: 2017/01/21 11:12:16
2524 dnl Check for a working mkstemp. This creates two files, checks that they are
2525 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2526 AC_DEFUN([CF_MKSTEMP],[
2530 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2533 #include <sys/types.h>
2534 #ifdef HAVE_UNISTD_H
2540 #include <sys/stat.h>
2543 char *tmpl = "conftestXXXXXX";
2551 for (n = 0; n < 2; ++n) {
2552 strcpy(name[n], tmpl);
2553 if ((fd = mkstemp(name[n])) >= 0) {
2554 if (!strcmp(name[n], tmpl)
2555 || stat(name[n], &sb) != 0
2556 || (sb.st_mode & S_IFMT) != S_IFREG
2557 || (sb.st_mode & 077) != 0) {
2564 && !strcmp(name[0], name[1]))
2566 ${cf_cv_main_return:-return}(result);
2568 ],[cf_cv_func_mkstemp=yes
2569 ],[cf_cv_func_mkstemp=no
2570 ],[cf_cv_func_mkstemp=maybe])
2572 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2573 AC_CHECK_FUNC(mkstemp)
2575 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2576 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2579 dnl ---------------------------------------------------------------------------
2580 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2582 dnl Write a debug message to config.log, along with the line number in the
2583 dnl configure script.
2584 AC_DEFUN([CF_MSG_LOG],[
2585 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2587 dnl ---------------------------------------------------------------------------
2588 dnl CF_NCURSES_ADDON version: 5 updated: 2015/04/26 18:06:58
2589 dnl ----------------
2590 dnl Configure an ncurses add-on, built outside the ncurses tree.
2591 AC_DEFUN([CF_NCURSES_ADDON],[
2592 AC_REQUIRE([CF_NCURSES_CONFIG])
2594 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2596 AC_MSG_CHECKING(if you want wide-character code)
2597 AC_ARG_ENABLE(widec,
2598 [ --enable-widec compile with wide-char/UTF-8 code],
2599 [with_widec=$enableval],
2601 AC_MSG_RESULT($with_widec)
2602 if test "$with_widec" = yes ; then
2604 CF_NCURSES_CONFIG(ncursesw)
2606 CF_NCURSES_CONFIG(ncurses)
2609 if test "$NCURSES_CONFIG_PKG" != none ; then
2610 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2612 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2613 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2614 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2616 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2617 if test -z "$cf_cv_abi_version"
2619 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2622 elif test "$NCURSES_CONFIG" != none ; then
2624 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2626 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2627 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2628 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2630 # ABI version is not available from headers
2631 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2635 for cf_name in MAJOR MINOR PATCH
2637 cat >conftest.$ac_ext <<CF_EOF
2638 #include <${cf_cv_ncurses_header:-curses.h}>
2639 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2641 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2643 if test -f conftest.out ; then
2644 cf_result=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[ ]][[ ]]*//"`
2645 eval NCURSES_$cf_name=\"$cf_result\"
2646 # cat conftest.$ac_ext
2651 cf_cv_abi_version=${NCURSES_MAJOR}
2655 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2657 dnl Show the computed version, for logging
2658 cf_cv_timestamp=`date`
2660 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2662 dnl We need these values in the generated headers
2663 AC_SUBST(NCURSES_MAJOR)
2664 AC_SUBST(NCURSES_MINOR)
2665 AC_SUBST(NCURSES_PATCH)
2667 dnl We need these values in the generated makefiles
2668 AC_SUBST(cf_cv_rel_version)
2669 AC_SUBST(cf_cv_abi_version)
2671 dnl FIXME - not needed for Ada95
2672 AC_SUBST(cf_cv_builtin_bool)
2673 AC_SUBST(cf_cv_header_stdbool_h)
2674 AC_SUBST(cf_cv_type_of_bool)dnl
2677 dnl ---------------------------------------------------------------------------
2678 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2679 dnl -------------------
2680 dnl Check if we can compile with ncurses' header file
2681 dnl $1 is the cache variable to set
2682 dnl $2 is the header-file to include
2683 dnl $3 is the root name (ncurses or ncursesw)
2684 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2686 ]ifelse($3,ncursesw,[
2687 #define _XOPEN_SOURCE_EXTENDED
2688 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2689 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2692 #ifdef NCURSES_VERSION
2693 ]ifelse($3,ncursesw,[
2698 printf("%s\n", NCURSES_VERSION);
2710 dnl ---------------------------------------------------------------------------
2711 dnl CF_NCURSES_CONFIG version: 23 updated: 2020/02/27 05:21:59
2712 dnl -----------------
2713 dnl Tie together the configure-script macros for ncurses, preferring these in
2715 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2716 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2717 dnl c) just plain libraries
2719 dnl $1 is the root library name (default: "ncurses")
2720 AC_DEFUN([CF_NCURSES_CONFIG],[
2721 AC_REQUIRE([CF_PKG_CONFIG])
2722 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2723 cf_have_ncuconfig=no
2725 if test "x${PKG_CONFIG:=none}" != xnone; then
2726 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2727 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2730 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2731 cf_have_ncuconfig=unknown
2733 cf_save_CFLAGS="$CFLAGS"
2734 cf_save_CPPFLAGS="$CPPFLAGS"
2735 cf_save_LIBS="$LIBS"
2737 cf_pkg_cflags=`$PKG_CONFIG --cflags $cf_ncuconfig_root`
2738 cf_pkg_libs=`$PKG_CONFIG --libs $cf_ncuconfig_root`
2740 # while -W for passing linker flags is prevalent, it is not "standard".
2741 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2742 # incompatible _and_ non-standard -W option which gives an error. Work
2743 # around that pitfall.
2744 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2746 CF_ADD_CFLAGS($cf_pkg_cflags)
2747 CF_ADD_LIBS($cf_pkg_libs)
2749 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2750 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2751 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2753 { char *xx = curses_version(); return (xx == 0); }],
2754 [cf_test_ncuconfig=yes],
2755 [cf_test_ncuconfig=no],
2756 [cf_test_ncuconfig=maybe])],
2757 [cf_test_ncuconfig=no])
2759 CFLAGS="$cf_save_CFLAGS"
2760 CPPFLAGS="$cf_save_CPPFLAGS"
2761 LIBS="$cf_save_LIBS"
2763 if test "x$cf_test_ncuconfig" != xyes; then
2764 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2765 cf_pkg_cflags="$cf_temp"
2766 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2767 cf_pkg_libs="$cf_temp"
2772 CF_ADD_CFLAGS($cf_pkg_cflags)
2773 CF_ADD_LIBS($cf_pkg_libs)
2775 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2776 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2777 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2779 { char *xx = curses_version(); return (xx == 0); }],
2780 [cf_have_ncuconfig=yes],
2781 [cf_have_ncuconfig=no],
2782 [cf_have_ncuconfig=maybe])],
2783 [cf_have_ncuconfig=no])
2784 AC_MSG_RESULT($cf_have_ncuconfig)
2785 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2786 if test "$cf_have_ncuconfig" != "yes"
2788 CPPFLAGS="$cf_save_CPPFLAGS"
2789 LIBS="$cf_save_LIBS"
2790 NCURSES_CONFIG_PKG=none
2792 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2793 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2799 NCURSES_CONFIG_PKG=none
2802 NCURSES_CONFIG_PKG=none
2805 if test "x$cf_have_ncuconfig" = "xno"; then
2806 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2808 CF_ACVERSION_CHECK(2.52,
2809 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2810 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2812 if test "$NCURSES_CONFIG" != none ; then
2814 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2815 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2817 # even with config script, some packages use no-override for curses.h
2818 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2820 dnl like CF_NCURSES_CPPFLAGS
2821 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2823 dnl like CF_NCURSES_LIBS
2824 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2825 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2827 dnl like CF_NCURSES_VERSION
2828 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2832 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2833 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2840 dnl ---------------------------------------------------------------------------
2841 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2842 dnl -------------------
2843 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2844 dnl the CPPFLAGS variable so we can include its header.
2846 dnl The header files may be installed as either curses.h, or ncurses.h (would
2847 dnl be obsolete, except that some packagers prefer this name to distinguish it
2848 dnl from a "native" curses implementation). If not installed for overwrite,
2849 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2850 dnl /usr/include/ncurses), but someone may have installed overwriting the
2851 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2852 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2855 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2856 dnl is already in the include-path, don't even bother with this, since we cannot
2857 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2859 dnl The optional parameter gives the root name of the library, in case it is
2860 dnl not installed as the default curses library. That is how the
2861 dnl wide-character version of ncurses is installed.
2862 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2863 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2865 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2866 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2868 test -n "$cf_cv_curses_dir" && \
2869 test "$cf_cv_curses_dir" != "no" && { \
2870 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2873 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2874 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2875 ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2876 for cf_header in $cf_header_list
2878 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2879 test "$cf_cv_ncurses_h" != no && break
2886 # some applications need this, but should check for NCURSES_VERSION
2887 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2891 dnl ---------------------------------------------------------------------------
2892 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2893 dnl -----------------
2894 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2895 dnl variations of ncurses' installs.
2897 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2898 AC_DEFUN([CF_NCURSES_HEADER],[
2900 if test "$cf_cv_ncurses_h" != no ; then
2901 cf_cv_ncurses_header=$cf_cv_ncurses_h
2904 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2905 test -n "$verbose" && echo
2906 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2907 test -n "$verbose" && echo search path $cf_search
2908 cf_save2_CPPFLAGS="$CPPFLAGS"
2909 for cf_incdir in $cf_search
2911 CF_ADD_INCDIR($cf_incdir)
2916 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2917 if test "$cf_cv_ncurses_h2" != no ; then
2918 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2919 test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG
2922 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2924 CPPFLAGS="$cf_save2_CPPFLAGS"
2925 test "$cf_cv_ncurses_h2" != no && break
2927 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2930 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2931 cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2932 if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2933 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2935 CF_ADD_INCDIR($cf_1st_incdir)
2939 # Set definitions to allow ifdef'ing for ncurses.h
2941 case $cf_cv_ncurses_header in
2943 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2947 case $cf_cv_ncurses_header in
2948 (ncurses/curses.h|ncurses/ncurses.h)
2949 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2951 (ncursesw/curses.h|ncursesw/ncurses.h)
2952 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2957 dnl ---------------------------------------------------------------------------
2958 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2960 dnl Look for the ncurses library. This is a little complicated on Linux,
2961 dnl because it may be linked with the gpm (general purpose mouse) library.
2962 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2963 dnl unusable with ncurses. However, we don't want to link with gpm unless
2964 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2965 dnl and the linker will record a dependency.
2967 dnl The optional parameter gives the root name of the library, in case it is
2968 dnl not installed as the default curses library. That is how the
2969 dnl wide-character version of ncurses is installed.
2970 AC_DEFUN([CF_NCURSES_LIBS],
2971 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2973 cf_nculib_root=ifelse($1,,ncurses,$1)
2974 # This works, except for the special case where we find gpm, but
2975 # ncurses is in a nonstandard location via $LIBS, and we really want
2978 cf_ncurses_SAVE="$LIBS"
2979 AC_CHECK_LIB(gpm,Gpm_Open,
2980 [AC_CHECK_LIB(gpm,initscr,
2981 [LIBS="$cf_ncurses_SAVE"],
2982 [cf_ncurses_LIBS="-lgpm"])])
2986 # This is only necessary if you are linking against an obsolete
2987 # version of ncurses (but it should do no harm, since it's static).
2988 if test "$cf_nculib_root" = ncurses ; then
2989 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2994 CF_ADD_LIBS($cf_ncurses_LIBS)
2996 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2998 CF_ADD_LIBS(-l$cf_nculib_root)
3000 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
3001 [#include <${cf_cv_ncurses_header:-curses.h}>],
3006 if test -n "$cf_ncurses_LIBS" ; then
3007 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
3008 cf_ncurses_SAVE="$LIBS"
3009 for p in $cf_ncurses_LIBS ; do
3010 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
3011 if test "$q" != "$LIBS" ; then
3015 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
3016 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
3017 [AC_MSG_RESULT(yes)],
3019 LIBS="$cf_ncurses_SAVE"])
3022 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
3023 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
3025 dnl ---------------------------------------------------------------------------
3026 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
3027 dnl ------------------
3028 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
3029 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
3030 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
3031 AC_DEFUN([CF_NCURSES_VERSION],
3033 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
3034 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
3035 cf_cv_ncurses_version=no
3039 #include <${cf_cv_ncurses_header:-curses.h}>
3043 FILE *fp = fopen("$cf_tempfile", "w");
3044 #ifdef NCURSES_VERSION
3045 # ifdef NCURSES_VERSION_PATCH
3046 fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
3048 fprintf(fp, "%s\n", NCURSES_VERSION);
3052 fprintf(fp, "old\n");
3057 ${cf_cv_main_return:-return}(0);
3059 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
3061 # This will not work if the preprocessor splits the line after the
3062 # Autoconf token. The 'unproto' program does that.
3063 cat > conftest.$ac_ext <<EOF
3064 #include <${cf_cv_ncurses_header:-curses.h}>
3066 #ifdef NCURSES_VERSION
3067 Autoconf NCURSES_VERSION
3075 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
3077 if test -f conftest.out ; then
3078 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
3079 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
3085 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3087 dnl ---------------------------------------------------------------------------
3088 dnl CF_OBJ_SUBDIR version: 7 updated: 2015/04/17 21:13:04
3090 dnl Compute the object-directory name from the given model name
3091 AC_DEFUN([CF_OBJ_SUBDIR],
3094 (libtool) $2='obj_lo' ;;
3095 (normal) $2='objects' ;;
3096 (debug) $2='obj_g' ;;
3097 (profile) $2='obj_p' ;;
3099 case $cf_cv_system_name in
3107 dnl ---------------------------------------------------------------------------
3108 dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00
3110 dnl Provide a value for the $PATH and similar separator (or amend the value
3111 dnl as provided in autoconf 2.5x).
3112 AC_DEFUN([CF_PATHSEP],
3114 AC_MSG_CHECKING(for PATH separator)
3115 case $cf_cv_system_name in
3116 (os2*) PATH_SEPARATOR=';' ;;
3117 (*) ${PATH_SEPARATOR:=':'} ;;
3119 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3120 AC_SUBST(PATH_SEPARATOR)
3121 AC_MSG_RESULT($PATH_SEPARATOR)
3123 dnl ---------------------------------------------------------------------------
3124 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
3126 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3127 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3128 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3129 dnl delayed evaluation of those symbols.
3130 AC_DEFUN([CF_PATH_SYNTAX],[
3131 if test "x$prefix" != xNONE; then
3132 cf_path_syntax="$prefix"
3134 cf_path_syntax="$ac_default_prefix"
3138 (.\[$]\(*\)*|.\'*\'*)
3142 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3144 (.\[$]{*prefix}*|.\[$]{*dir}*)
3148 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3153 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3156 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3160 dnl ---------------------------------------------------------------------------
3161 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
3163 dnl Check for the package-config program, unless disabled by command-line.
3164 AC_DEFUN([CF_PKG_CONFIG],
3166 AC_MSG_CHECKING(if you want to use pkg-config)
3167 AC_ARG_WITH(pkg-config,
3168 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3169 [cf_pkg_config=$withval],
3170 [cf_pkg_config=yes])
3171 AC_MSG_RESULT($cf_pkg_config)
3173 case $cf_pkg_config in
3178 CF_ACVERSION_CHECK(2.52,
3179 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3180 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3187 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3188 if test "$PKG_CONFIG" != none ; then
3189 CF_PATH_SYNTAX(PKG_CONFIG)
3190 elif test "x$cf_pkg_config" != xno ; then
3191 AC_MSG_WARN(pkg-config is not installed)
3194 AC_SUBST(PKG_CONFIG)
3196 dnl ---------------------------------------------------------------------------
3197 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3198 dnl -----------------
3199 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3201 dnl POSIX.1-1990 _POSIX_SOURCE
3202 dnl POSIX.1-1990 and _POSIX_SOURCE and
3203 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3205 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3206 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3207 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3210 dnl $1 is the nominal value for _POSIX_C_SOURCE
3211 AC_DEFUN([CF_POSIX_C_SOURCE],
3212 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3214 if test "$cf_cv_posix_visible" = no; then
3216 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3218 cf_save_CFLAGS="$CFLAGS"
3219 cf_save_CPPFLAGS="$CPPFLAGS"
3221 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3222 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3224 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3225 CF_MSG_LOG(if the symbol is already defined go no further)
3226 AC_TRY_COMPILE([#include <sys/types.h>],[
3227 #ifndef _POSIX_C_SOURCE
3230 [cf_cv_posix_c_source=no],
3231 [cf_want_posix_source=no
3232 case .$cf_POSIX_C_SOURCE in
3234 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3237 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3238 cf_want_posix_source=yes
3241 cf_want_posix_source=yes
3244 if test "$cf_want_posix_source" = yes ; then
3245 AC_TRY_COMPILE([#include <sys/types.h>],[
3246 #ifdef _POSIX_SOURCE
3249 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3251 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3252 CFLAGS="$cf_trim_CFLAGS"
3253 CPPFLAGS="$cf_trim_CPPFLAGS"
3254 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3255 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3256 AC_TRY_COMPILE([#include <sys/types.h>],[
3257 #ifndef _POSIX_C_SOURCE
3260 [cf_cv_posix_c_source=no])
3261 CFLAGS="$cf_save_CFLAGS"
3262 CPPFLAGS="$cf_save_CPPFLAGS"
3266 if test "$cf_cv_posix_c_source" != no ; then
3267 CFLAGS="$cf_trim_CFLAGS"
3268 CPPFLAGS="$cf_trim_CPPFLAGS"
3269 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3272 fi # cf_cv_posix_visible
3275 dnl ---------------------------------------------------------------------------
3276 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3277 dnl ----------------
3278 dnl POSIX documents test-macros which an application may set before any system
3279 dnl headers are included to make features available.
3281 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3282 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3283 dnl recent features visible in the system header files unless the application
3284 dnl overrides the corresponding test-macros. Doing that introduces portability
3287 dnl This macro makes a special check for the symbols used for this, to avoid a
3288 dnl conflicting definition.
3289 AC_DEFUN([CF_POSIX_VISIBLE],
3291 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3292 AC_TRY_COMPILE([#include <stdio.h>],[
3293 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3294 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3295 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3296 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3297 #error conflicting symbols found
3299 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3302 dnl ---------------------------------------------------------------------------
3303 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3305 dnl Check for archiver "ar".
3306 AC_DEFUN([CF_PROG_AR],[
3307 AC_CHECK_TOOL(AR, ar, ar)
3309 dnl ---------------------------------------------------------------------------
3310 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3312 dnl Check for awk, ensure that the check found something.
3313 AC_DEFUN([CF_PROG_AWK],
3316 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3318 dnl ---------------------------------------------------------------------------
3319 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3321 dnl standard check for CC, plus followup sanity checks
3322 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3323 AC_DEFUN([CF_PROG_CC],[
3324 CF_ACVERSION_CHECK(2.53,
3325 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3326 AC_REQUIRE([AC_PROG_CC])],
3328 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3330 CF_ACVERSION_CHECK(2.52,
3335 dnl ---------------------------------------------------------------------------
3336 dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25
3338 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3339 dnl the output file can be renamed, and allows for a shell variable that can
3340 dnl be used later. The parameter is either CC or CXX. The result is the
3342 dnl $cf_cv_prog_CC_c_o
3343 dnl $cf_cv_prog_CXX_c_o
3346 dnl $2 = compiler options, if any
3347 AC_DEFUN([CF_PROG_CC_C_O],
3348 [AC_REQUIRE([AC_PROG_CC])dnl
3349 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3350 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3352 cat > conftest.$ac_ext <<CF_EOF
3355 ${cf_cv_main_return:-return}(0);
3358 # We do the test twice because some compilers refuse to overwrite an
3359 # existing .o file with -o, though they will create one.
3360 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3361 if AC_TRY_EVAL(ac_try) &&
3362 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3364 eval cf_cv_prog_$1_c_o=yes
3366 eval cf_cv_prog_$1_c_o=no
3370 if test $cf_cv_prog_$1_c_o = yes; then
3371 AC_MSG_RESULT([yes])
3376 dnl ---------------------------------------------------------------------------
3377 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3379 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3380 dnl This macro adds a check to ensure the script found something.
3381 AC_DEFUN([CF_PROG_EGREP],
3382 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3383 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3384 then ac_cv_prog_egrep='grep -E'
3385 else ac_cv_prog_egrep='egrep'
3387 EGREP=$ac_cv_prog_egrep
3389 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3391 dnl ---------------------------------------------------------------------------
3392 dnl CF_PROG_EXT version: 14 updated: 2018/06/20 20:23:13
3394 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3395 AC_DEFUN([CF_PROG_EXT],
3397 AC_REQUIRE([CF_CHECK_CACHE])
3398 case $cf_cv_system_name in
3400 CFLAGS="$CFLAGS -Zmt"
3401 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3402 CXXFLAGS="$CXXFLAGS -Zmt"
3403 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3404 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3414 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3416 dnl ---------------------------------------------------------------------------
3417 dnl CF_PROG_GNAT version: 10 updated: 2019/12/31 08:53:54
3419 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3420 AC_DEFUN([CF_PROG_GNAT],[
3421 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3423 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3425 unset ac_cv_path_cf_TEMP_gnat
3427 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3428 eval cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat
3430 if test "x$cf_TEMP_gnat" != xno; then
3431 unset cf_cv_gnat_version
3433 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3435 eval cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat
3438 unset cf_cv_gnat_version
3439 unset ac_cv_path_cf_TEMP_gnat
3442 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3444 cf_cv_prog_gnat_correct=no
3446 cf_ada_make=gnatmake
3447 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3448 # gprconfig is newer than gnatmake; we can continue...
3451 rm -rf conftest* *~conftest*
3452 if mkdir conftest.src
3456 for cf_gprconfig in Ada C
3458 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3459 if test $cf_gprconfig = C
3461 for cf_gprconfig_param in \
3462 $cf_gprconfig,,,,GNATGCC \
3463 $cf_gprconfig,,,,GCC \
3466 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3467 test -n "$cf_gprconfig_value" && break
3470 cf_gprconfig_param=$cf_gprconfig
3471 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3473 if test -n "$cf_gprconfig_value"
3475 eval cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value
3476 AC_MSG_RESULT($cf_gprconfig_value)
3478 AC_MSG_RESULT(missing)
3484 rm -rf conftest* *~conftest*
3487 if test "x$cf_ada_config" != "x#"
3490 CF_CHECK_GNAT_VERSION
3491 AC_CHECK_PROG(M4_exists, m4, yes, no)
3492 if test "$ac_cv_prog_M4_exists" = no; then
3493 cf_cv_prog_gnat_correct=no
3494 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3496 if test "$cf_cv_prog_gnat_correct" = yes; then
3497 AC_MSG_CHECKING(if GNAT works)
3498 CF_GNAT_TRY_RUN([procedure conftest;],
3501 procedure conftest is
3503 Text_IO.Put ("Hello World");
3505 GNAT.OS_Lib.OS_Exit (0);
3507 [cf_cv_prog_gnat_correct=yes],
3508 [cf_cv_prog_gnat_correct=no])
3509 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3512 cf_cv_prog_gnat_correct=no
3516 AC_SUBST(cf_ada_make)
3517 AC_SUBST(cf_ada_config)
3518 AC_SUBST(cf_ada_config_Ada)
3519 AC_SUBST(cf_ada_config_C)
3521 dnl ---------------------------------------------------------------------------
3522 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
3524 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3525 dnl misc/tabset install won't work properly. Usually this happens only when
3526 dnl using the fallback mkinstalldirs script
3527 AC_DEFUN([CF_PROG_INSTALL],
3533 CF_DIRNAME(cf_dir,$INSTALL)
3534 test -z "$cf_dir" && cf_dir=.
3535 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3539 dnl ---------------------------------------------------------------------------
3540 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3542 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3543 dnl option if it is supported.
3544 AC_DEFUN([CF_PROG_LN_S],[
3546 AC_MSG_CHECKING(if $LN_S -f options work)
3548 rm -f conf$$.src conf$$dst
3550 echo first >conf$$.src
3551 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3556 rm -f conf$$.dst conf$$src
3557 AC_MSG_RESULT($cf_prog_ln_sf)
3559 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3561 dnl ---------------------------------------------------------------------------
3562 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3563 dnl ----------------
3564 dnl Remove all -U and -D options that refer to the given symbol from a list
3565 dnl of C compiler options. This works around the problem that not all
3566 dnl compilers process -U and -D options from left-to-right, so a -U option
3567 dnl cannot be used to cancel the effect of a preceding -D option.
3569 dnl $1 = target (which could be the same as the source variable)
3570 dnl $2 = source (including '$')
3571 dnl $3 = symbol to remove
3572 define([CF_REMOVE_DEFINE],
3575 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3576 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3578 dnl ---------------------------------------------------------------------------
3579 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3581 dnl Remove the given library from the symbol
3583 dnl $1 = target (which could be the same as the source variable)
3584 dnl $2 = source (including '$')
3585 dnl $3 = library to remove
3586 define([CF_REMOVE_LIB],
3588 # remove $3 library from $2
3589 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3591 dnl ---------------------------------------------------------------------------
3592 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3593 dnl ---------------------
3594 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3595 dnl $1 = name of current macro
3596 define([CF_RESTORE_XTRA_FLAGS],
3598 LIBS="$cf_save_LIBS_$1"
3599 CFLAGS="$cf_save_CFLAGS_$1"
3600 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3602 dnl ---------------------------------------------------------------------------
3603 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3604 dnl ------------------
3605 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3606 dnl and libraries which do not update those variables.
3608 dnl $1 = name of current macro
3609 define([CF_SAVE_XTRA_FLAGS],
3611 cf_save_LIBS_$1="$LIBS"
3612 cf_save_CFLAGS_$1="$CFLAGS"
3613 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3614 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3615 for cf_X_CFLAGS in $X_CFLAGS
3617 case "x$cf_X_CFLAGS" in
3619 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3622 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3627 dnl ---------------------------------------------------------------------------
3628 dnl CF_SHARED_OPTS version: 102 updated: 2020/08/22 18:17:19
3631 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3635 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3636 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3637 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3638 dnl shared library since that can lead to unexpected results at runtime.
3639 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3640 dnl libraries are compiled in ../../lib
3642 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3643 dnl to install symbolic links to the rel/abi versions of shared libraries.
3645 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3646 dnl version when making symbolic links.
3648 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3649 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3650 dnl (ex: libncurses.so.<ver>).
3652 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3653 AC_DEFUN([CF_SHARED_OPTS],
3655 AC_REQUIRE([CF_LD_RPATH_OPT])
3661 INSTALL_LIB="-m 644"
3662 : ${rel_builddir:=.}
3670 cf_cv_do_symlinks=no
3672 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3674 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3675 AC_ARG_WITH(shlib-version,
3676 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3677 [test -z "$withval" && withval=auto
3680 cf_cv_shlib_version=auto
3683 cf_cv_shlib_version=$withval
3686 AC_MSG_RESULT($withval)
3687 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3690 ],[cf_cv_shlib_version=auto])
3691 AC_MSG_RESULT($cf_cv_shlib_version)
3696 # Some less-capable ports of gcc support only -fpic
3700 if test "$GCC" = yes
3704 case $cf_cv_system_name in
3705 (*linux*) # e.g., PGI compiler
3711 if test "$cf_try_fPIC" = yes
3713 AC_MSG_CHECKING(which $CC option to use)
3714 cf_save_CFLAGS="$CFLAGS"
3715 for CC_SHARED_OPTS in -fPIC -fpic ''
3717 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3718 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3720 AC_MSG_RESULT($CC_SHARED_OPTS)
3721 CFLAGS="$cf_save_CFLAGS"
3724 cf_cv_shlib_version_infix=no
3726 case $cf_cv_system_name in
3727 (aix4.[3-9]*|aix[[5-7]]*)
3728 if test "$GCC" = yes; then
3729 CC_SHARED_OPTS='-Wl,-brtl'
3730 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3732 CC_SHARED_OPTS='-brtl'
3733 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3734 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3738 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3742 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3743 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3744 cf_cv_shlib_version=cygdll
3745 cf_cv_shlib_version_infix=cygdll
3748 cat >mk_shared_lib.sh <<-CF_EOF
3751 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3754 Linking shared library
3755 ** SHARED_LIB \[$]SHARED_LIB
3756 ** IMPORT_LIB \[$]IMPORT_LIB
3758 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3760 chmod +x mk_shared_lib.sh
3764 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3765 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3766 cf_cv_shlib_version=msysdll
3767 cf_cv_shlib_version_infix=msysdll
3770 cat >mk_shared_lib.sh <<-CF_EOF
3773 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3776 Linking shared library
3777 ** SHARED_LIB \[$]SHARED_LIB
3778 ** IMPORT_LIB \[$]IMPORT_LIB
3780 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3782 chmod +x mk_shared_lib.sh
3785 cf_try_cflags="no-cpp-precomp"
3786 CC_SHARED_OPTS="-dynamic"
3787 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3788 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3789 cf_cv_shlib_version_infix=yes
3790 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3791 cf_save_LDFLAGS=$LDFLAGS
3792 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3793 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3794 LDFLAGS=$cf_save_LDFLAGS])
3795 if test $cf_cv_ldflags_search_paths_first = yes; then
3796 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3800 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
3801 if test "$GCC" != yes; then
3804 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
3805 INSTALL_LIB="-m 555"
3808 # (tested with gcc 2.7.2 -- I don't have c89)
3809 if test "$GCC" = yes; then
3810 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3813 LD_SHARED_OPTS='-Wl,+b,${libdir}'
3815 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
3816 # HP-UX shared libraries must be executable, and should be
3817 # readonly to exploit a quirk in the memory manager.
3818 INSTALL_LIB="-m 555"
3821 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3822 if test "$cf_cv_shlib_version" = rel; then
3823 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3825 cf_shared_soname='`basename $[@]`'
3828 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
3831 if test "$cf_cv_enable_rpath" = yes ; then
3832 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3834 # tested with IRIX 5.2 and 'cc'.
3835 if test "$GCC" != yes; then
3836 CC_SHARED_OPTS='-KPIC'
3837 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3839 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
3841 cf_cv_rm_so_locs=yes
3843 (linux*|gnu*|k*bsd*-gnu)
3844 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3845 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3846 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3848 if test "$cf_cv_enable_rpath" = yes ; then
3849 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3852 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3855 cf_cv_shlib_version=msvcdll
3856 cf_cv_shlib_version_infix=msvcdll
3859 if test "$DFT_LWR_MODEL" = "shared" ; then
3860 LOCAL_LDFLAGS="-link -dll"
3861 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3862 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
3865 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
3866 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
3867 cat >mk_shared_lib.sh <<-CF_EOF
3870 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
3875 Linking shared library
3876 ** SHARED LIB \$SHARED_LIB
3877 ** IMPORT_LIB \$IMPORT_LIB
3879 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
3880 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
3881 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
3883 chmod +x mk_shared_lib.sh
3884 cat >mk_prog.sh <<-CF_EOF
3887 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
3890 ldopts=("/subsystem:console")
3893 while test \[$]# -gt 0; do
3896 # ignore -link argument
3898 -M[[TD]] | -M[[TD]]d)
3899 # ignore runtime-library option
3914 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
3917 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
3923 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
3924 ldopts+=("\[$]{linkarg}")
3932 ldopts+=("-out:\[$]1")
3941 if [[ "\$isdll" -ne 0 ]]; then
3942 for lib in \[$]{libs[[*]]}; do
3943 ldopts+=("\[$]lib.dll.lib")
3946 for lib in \[$]{libs[[*]]}; do
3947 ldopts+=("\[$]lib.lib")
3952 ** ld options: "\[$]{ldopts[[@]]}"
3954 exec \[$]LD \[$]{ldopts[[@]]}
3957 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
3958 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh"
3961 cf_cv_shlib_version=mingw
3962 cf_cv_shlib_version_infix=mingw
3965 if test "$DFT_LWR_MODEL" = "shared" ; then
3966 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
3967 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3968 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
3971 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3972 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3973 cat >mk_shared_lib.sh <<-CF_EOF
3976 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3979 Linking shared library
3980 ** SHARED_LIB \[$]SHARED_LIB
3981 ** IMPORT_LIB \[$]IMPORT_LIB
3983 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3985 chmod +x mk_shared_lib.sh
3987 (openbsd[[2-9]].*|mirbsd*)
3988 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3989 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3990 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3992 if test "$cf_cv_enable_rpath" = yes ; then
3993 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3995 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3997 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4001 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]'
4005 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]'
4007 (nto-qnx*|openbsd*|freebsd[[12]].*)
4008 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4009 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
4010 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4012 (dragonfly*|freebsd*)
4013 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4014 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4015 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4016 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
4017 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4020 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
4023 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
4024 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
4025 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
4026 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4027 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
4028 if test "$cf_cv_shlib_version" = auto; then
4029 if test -f /usr/libexec/ld.elf_so; then
4030 cf_cv_shlib_version=abi
4032 cf_cv_shlib_version=rel
4036 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
4038 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]'
4042 # tested with OSF/1 V3.2 and 'cc'
4043 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
4044 # link with shared libs).
4045 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
4048 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
4051 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
4052 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
4053 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
4054 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4056 cf_cv_rm_so_locs=yes
4058 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
4059 # tested with osr5.0.5
4060 if test "$GCC" != yes; then
4061 CC_SHARED_OPTS='-belf -KPIC'
4063 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
4064 if test "$cf_cv_enable_rpath" = yes ; then
4065 # only way is to set LD_RUN_PATH but no switch for it
4068 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4069 LINK_PROGS='LD_RUN_PATH=${libdir}'
4070 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
4073 # tested with SunOS 4.1.1 and gcc 2.7.0
4074 if test "$GCC" != yes; then
4075 CC_SHARED_OPTS='-KPIC'
4077 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
4078 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
4081 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
4082 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
4083 if test "$DFT_LWR_MODEL" = "shared" ; then
4084 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
4085 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
4087 if test "$cf_cv_enable_rpath" = yes ; then
4088 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
4091 if test "$GCC" != yes; then
4092 cf_save_CFLAGS="$CFLAGS"
4093 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
4095 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
4096 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
4098 CFLAGS="$cf_save_CFLAGS"
4099 CC_SHARED_OPTS=$cf_shared_opts
4100 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4102 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4105 (sysv5uw7*|unix_sv*)
4106 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4107 if test "$GCC" != yes; then
4108 CC_SHARED_OPTS='-KPIC'
4110 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4113 CC_SHARED_OPTS='unknown'
4114 MK_SHARED_LIB='echo unknown'
4118 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4119 case "$cf_cv_shlib_version" in
4121 case "$MK_SHARED_LIB" in
4123 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4126 AC_MSG_WARN(ignored --with-shlib-version)
4132 if test -n "$cf_try_cflags"
4134 cat > conftest.$ac_ext <<EOF
4135 #line __oline__ "${as_me:-configure}"
4137 int main(int argc, char *argv[[]])
4140 return (argv[[argc-1]] == 0) ;
4143 cf_save_CFLAGS="$CFLAGS"
4144 for cf_opt in $cf_try_cflags
4146 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4147 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4148 if AC_TRY_EVAL(ac_compile); then
4150 cf_save_CFLAGS="$CFLAGS"
4155 CFLAGS="$cf_save_CFLAGS"
4159 # RPATH_LIST is a colon-separated list of directories
4160 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4161 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4163 test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4165 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4166 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4168 AC_SUBST(CC_SHARED_OPTS)
4169 AC_SUBST(LD_RPATH_OPT)
4170 AC_SUBST(LD_SHARED_OPTS)
4171 AC_SUBST(MK_SHARED_LIB)
4172 AC_SUBST(RM_SHARED_OPTS)
4174 AC_SUBST(LINK_PROGS)
4175 AC_SUBST(LINK_TESTS)
4177 AC_SUBST(EXTRA_LDFLAGS)
4178 AC_SUBST(LOCAL_LDFLAGS)
4179 AC_SUBST(LOCAL_LDFLAGS2)
4181 AC_SUBST(INSTALL_LIB)
4182 AC_SUBST(RPATH_LIST)
4184 dnl ---------------------------------------------------------------------------
4185 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4186 dnl ----------------
4187 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4188 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4191 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4192 dnl If missing, use "rel".
4193 define([CF_SHARED_SONAME],
4195 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4196 if test "$cf_cv_shlib_version" = rel; then
4197 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4199 cf_cv_shared_soname='`basename $[@]`'
4202 dnl ---------------------------------------------------------------------------
4203 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4205 dnl Remove "-g" option from the compiler options
4206 AC_DEFUN([CF_STRIP_G_OPT],
4207 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4208 dnl ---------------------------------------------------------------------------
4209 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4211 dnl Construct a search-list for a nonstandard header/lib-file
4212 dnl $1 = the variable to return as result
4213 dnl $2 = the package name
4214 dnl $3 = the subdirectory, e.g., bin, include or lib
4215 AC_DEFUN([CF_SUBDIR_PATH],
4219 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4221 for cf_subdir_prefix in \
4229 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4232 dnl ---------------------------------------------------------------------------
4233 dnl CF_TERM_HEADER version: 5 updated: 2020/03/19 20:23:48
4235 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4236 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4237 dnl but some packagers change this, breaking various applications.
4238 AC_DEFUN([CF_TERM_HEADER],[
4239 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4240 case ${cf_cv_ncurses_header} in
4241 (*/ncurses.h|*/ncursesw.h)
4242 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4245 cf_term_header=term.h
4249 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4251 AC_TRY_COMPILE([#include <stdio.h>
4252 #include <${cf_cv_ncurses_header:-curses.h}>
4254 ],[int x = auto_left_margin; (void)x],[
4255 cf_cv_term_header="$cf_test"],[
4256 cf_cv_term_header=unknown
4258 test "$cf_cv_term_header" != unknown && break
4262 # Set definitions to allow ifdef'ing to accommodate subdirectories
4264 case $cf_cv_term_header in
4266 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4270 case $cf_cv_term_header in
4272 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4275 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4279 dnl ---------------------------------------------------------------------------
4280 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4282 dnl Define a top_builddir symbol, for applications that need an absolute path.
4283 AC_DEFUN([CF_TOP_BUILDDIR],
4285 top_builddir=ifelse($1,,`pwd`,$1)
4286 AC_SUBST(top_builddir)
4288 dnl ---------------------------------------------------------------------------
4289 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
4290 dnl -------------------
4291 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4292 dnl can define it successfully.
4293 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4294 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4298 #include <sys/types.h>
4300 #ifndef _XOPEN_SOURCE
4303 [cf_cv_xopen_source=no],
4304 [cf_save="$CPPFLAGS"
4305 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4309 #include <sys/types.h>
4311 #ifdef _XOPEN_SOURCE
4314 [cf_cv_xopen_source=no],
4315 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4320 if test "$cf_cv_xopen_source" != no ; then
4321 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4322 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4323 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4324 CF_ADD_CFLAGS($cf_temp_xopen_source)
4327 dnl ---------------------------------------------------------------------------
4328 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4330 dnl Make an uppercase version of a variable
4331 dnl $1=uppercase($2)
4332 AC_DEFUN([CF_UPPER],
4334 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4336 dnl ---------------------------------------------------------------------------
4337 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
4339 dnl Check for multibyte support, and if not found, utf8 compatibility library
4340 AC_DEFUN([CF_UTF8_LIB],
4342 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4343 cf_save_LIBS="$LIBS"
4345 #include <stdlib.h>],[putwc(0,0);],
4346 [cf_cv_utf8_lib=yes],
4348 #include <libutf8.h>],[putwc(0,0);],utf8,
4349 [cf_cv_utf8_lib=add-on],
4350 [cf_cv_utf8_lib=no])
4353 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4355 if test "$cf_cv_utf8_lib" = "add-on" ; then
4356 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4357 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4358 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4359 CF_ADD_LIBS($cf_cv_library_file_utf8)
4362 dnl ---------------------------------------------------------------------------
4363 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4365 dnl Use AC_VERBOSE w/o the warnings
4366 AC_DEFUN([CF_VERBOSE],
4367 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4370 dnl ---------------------------------------------------------------------------
4371 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4373 dnl Check for compiler-support for weak symbols.
4374 dnl This works with "recent" gcc.
4375 AC_DEFUN([CF_WEAK_SYMBOLS],[
4376 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4379 #include <stdio.h>],
4381 #if defined(__GNUC__)
4382 # if defined __USE_ISOC99
4383 # define _cat_pragma(exp) _Pragma(#exp)
4384 # define _weak_pragma(exp) _cat_pragma(weak name)
4386 # define _weak_pragma(exp)
4388 # define _declare(name) __extension__ extern __typeof__(name) name
4389 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4393 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4396 dnl ---------------------------------------------------------------------------
4397 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4398 dnl --------------------
4399 dnl Command-line option to specify the Ada95 compiler.
4400 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4401 AC_MSG_CHECKING(for ada-compiler)
4402 AC_ARG_WITH(ada-compiler,
4403 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4404 [cf_ada_compiler=$withval],
4405 [cf_ada_compiler=gnatmake])
4406 AC_SUBST(cf_ada_compiler)
4407 AC_MSG_RESULT($cf_ada_compiler)
4409 dnl ---------------------------------------------------------------------------
4410 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4411 dnl -------------------
4412 dnl Command-line option to specify where Ada includes will install.
4413 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4414 AC_MSG_CHECKING(for ada-include)
4415 CF_WITH_PATH(ada-include,
4416 [ --with-ada-include=DIR Ada includes are in DIR],
4418 PREFIX/share/ada/adainclude,
4419 [$]prefix/share/ada/adainclude)
4420 AC_SUBST(ADA_INCLUDE)
4421 AC_MSG_RESULT($ADA_INCLUDE)
4423 dnl ---------------------------------------------------------------------------
4424 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4425 dnl -------------------
4426 dnl CF_WITH_ADA_LIBNAME
4427 dnl -------------------
4428 dnl Command-line option to specify how to name the resulting Ada library.
4429 dnl $1 = default value
4430 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4431 AC_MSG_CHECKING(for ada-libname)
4432 AC_ARG_WITH(ada-libname,
4433 [ --with-ada-libname=XXX override default Ada library-name],
4434 ADA_LIBNAME=[$]withval,
4436 case "x$ADA_LIBNAME" in
4441 AC_SUBST(ADA_LIBNAME)
4442 AC_MSG_RESULT($ADA_LIBNAME)
4444 dnl ---------------------------------------------------------------------------
4445 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4446 dnl -------------------
4447 dnl Command-line option to specify where Ada objects will install.
4448 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4449 AC_MSG_CHECKING(for ada-objects)
4450 CF_WITH_PATH(ada-objects,
4451 [ --with-ada-objects=DIR Ada objects are in DIR],
4453 PREFIX/lib/ada/adalib,
4454 [$]prefix/lib/ada/adalib)
4455 AC_SUBST(ADA_OBJECTS)
4456 AC_MSG_RESULT($ADA_OBJECTS)
4458 dnl ---------------------------------------------------------------------------
4459 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4460 dnl ---------------------
4461 dnl Command-line option to specify if an Ada95 shared-library should be built,
4462 dnl and optionally what its soname should be.
4463 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4464 AC_REQUIRE([CF_GNAT_PROJECTS])
4465 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4466 AC_ARG_WITH(ada-sharedlib,
4467 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4468 [with_ada_sharedlib=$withval],
4469 [with_ada_sharedlib=no])
4470 AC_MSG_RESULT($with_ada_sharedlib)
4472 if test "x$with_ada_sharedlib" != xno
4474 if test "x$cf_gnat_projects" != xyes
4476 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4477 with_ada_sharedlib=no
4481 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4482 MAKE_ADA_SHAREDLIB="#"
4484 if test "x$with_ada_sharedlib" != xno
4487 if test "x$with_ada_sharedlib" != xyes
4489 ADA_SHAREDLIB="$with_ada_sharedlib"
4493 AC_SUBST(ADA_SHAREDLIB)
4494 AC_SUBST(MAKE_ADA_SHAREDLIB)
4496 dnl ---------------------------------------------------------------------------
4497 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
4498 dnl ------------------
4499 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4501 AC_DEFUN([CF_WITH_CURSES_DIR],[
4503 AC_MSG_CHECKING(for specific curses-directory)
4504 AC_ARG_WITH(curses-dir,
4505 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4506 [cf_cv_curses_dir=$withval],
4507 [cf_cv_curses_dir=no])
4508 AC_MSG_RESULT($cf_cv_curses_dir)
4510 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
4512 CF_PATH_SYNTAX(withval)
4513 if test -d "$cf_cv_curses_dir"
4515 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4516 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4520 dnl ---------------------------------------------------------------------------
4521 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
4522 dnl ------------------
4523 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4524 dnl "lib" prefix, e.g., because it used the dll naming convention.
4526 dnl $1 = variable to set
4527 AC_DEFUN([CF_WITH_LIB_PREFIX],
4529 AC_MSG_CHECKING(if you want to have a library-prefix)
4530 AC_ARG_WITH(lib-prefix,
4531 [ --with-lib-prefix override library-prefix],
4532 [with_lib_prefix=$withval],
4533 [with_lib_prefix=auto])
4534 AC_MSG_RESULT($with_lib_prefix)
4536 if test $with_lib_prefix = auto
4539 elif test $with_lib_prefix = no
4543 LIB_PREFIX=$with_lib_prefix
4546 dnl ---------------------------------------------------------------------------
4547 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
4549 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4550 dnl defaulting to yes/no.
4552 dnl $1 = option name
4554 dnl $3 = environment variable to set
4555 dnl $4 = default value, shown in the help-message, must be a constant
4556 dnl $5 = default value, if it's an expression & cannot be in the help-message
4558 AC_DEFUN([CF_WITH_PATH],
4559 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4560 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4561 if ifelse([$5],,true,[test -n "$5"]) ; then
4562 CF_PATH_SYNTAX(withval)
4567 dnl ---------------------------------------------------------------------------
4568 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56
4569 dnl -------------------------
4570 dnl Allow the choice of the pkg-config library directory to be overridden.
4571 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4575 AC_MSG_CHECKING(for pkg-config library directory)
4578 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4582 PKG_CONFIG_LIBDIR=no
4583 AC_ARG_WITH(pkg-config-libdir,
4584 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4585 [PKG_CONFIG_LIBDIR=$withval],
4586 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
4588 case x$PKG_CONFIG_LIBDIR in
4592 # Look for the library directory using the same prefix as the executable
4593 if test "x$PKG_CONFIG" = xnone
4597 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
4600 # If you don't like using the default architecture, you have to specify the
4601 # intended library directory and corresponding compiler/linker options.
4603 # This case allows for Debian's 2014-flavor of multiarch, along with the
4604 # most common variations before that point. Some other variants spell the
4605 # directory differently, e.g., "pkg-config", and put it in unusual places.
4606 # pkg-config has always been poorly standardized, which is ironic...
4607 case x`(arch) 2>/dev/null` in
4610 $cf_path/lib/*64-linux-gnu \
4618 $cf_path/lib/*-linux-gnu \
4627 for cf_config in $cf_search_path
4629 CF_VERBOSE(checking $cf_config/pkgconfig)
4630 if test -d $cf_config/pkgconfig
4632 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
4633 AC_MSG_CHECKING(done)
4642 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
4643 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4646 AC_SUBST(PKG_CONFIG_LIBDIR)
4648 dnl ---------------------------------------------------------------------------
4649 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4651 dnl Check for POSIX thread library.
4652 AC_DEFUN([CF_WITH_PTHREAD],
4654 AC_MSG_CHECKING(if you want to link with the pthread library)
4655 AC_ARG_WITH(pthread,
4656 [ --with-pthread use POSIX thread library],
4657 [with_pthread=$withval],
4659 AC_MSG_RESULT($with_pthread)
4661 if test "$with_pthread" != no ; then
4662 AC_CHECK_HEADER(pthread.h,[
4663 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4665 for cf_lib_pthread in pthread c_r
4667 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4668 cf_save_LIBS="$LIBS"
4669 CF_ADD_LIB($cf_lib_pthread)
4671 #include <pthread.h>
4673 int rc = pthread_create(0,0,0,0);
4674 int r2 = pthread_mutexattr_settype(0, 0);
4675 ],[with_pthread=yes],[with_pthread=no])
4676 LIBS="$cf_save_LIBS"
4677 AC_MSG_RESULT($with_pthread)
4678 test "$with_pthread" = yes && break
4681 if test "$with_pthread" = yes ; then
4682 CF_ADD_LIB($cf_lib_pthread)
4683 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4685 AC_MSG_ERROR(Cannot link with pthread library)
4690 dnl ---------------------------------------------------------------------------
4691 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
4693 dnl For testing, override the derived host system-type which is used to decide
4694 dnl things such as the linker commands used to build shared libraries. This is
4695 dnl normally chosen automatically based on the type of system which you are
4696 dnl building on. We use it for testing the configure script.
4698 dnl This is different from the --host option: it is used only for testing parts
4699 dnl of the configure script which would not be reachable with --host since that
4700 dnl relies on the build environment being real, rather than mocked up.
4701 AC_DEFUN([CF_WITH_SYSTYPE],[
4702 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
4703 AC_ARG_WITH(system-type,
4704 [ --with-system-type=XXX test: override derived host system-type],
4705 [AC_MSG_WARN(overriding system type to $withval)
4706 cf_cv_system_name=$withval
4710 dnl ---------------------------------------------------------------------------
4711 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
4713 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4714 dnl or adapt to the vendor's definitions to get equivalent functionality,
4715 dnl without losing the common non-POSIX features.
4718 dnl $1 is the nominal value for _XOPEN_SOURCE
4719 dnl $2 is the nominal value for _POSIX_C_SOURCE
4720 AC_DEFUN([CF_XOPEN_SOURCE],[
4721 AC_REQUIRE([AC_CANONICAL_HOST])
4722 AC_REQUIRE([CF_POSIX_VISIBLE])
4724 if test "$cf_cv_posix_visible" = no; then
4726 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4727 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4732 cf_xopen_source="-D_ALL_SOURCE"
4738 cf_xopen_source="-D_APPLE_C_SOURCE"
4741 cf_xopen_source="-D_DARWIN_C_SOURCE"
4744 (freebsd*|dragonfly*|midnightbsd*)
4745 # 5.x headers associate
4746 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4747 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4748 cf_POSIX_C_SOURCE=200112L
4750 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4753 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4756 cf_xopen_source="-D_HPUX_SOURCE"
4759 cf_xopen_source="-D_SGI_SOURCE"
4762 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4763 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4766 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4769 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4771 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4774 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4777 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4778 cf_xopen_source="-D_BSD_SOURCE"
4782 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4785 cf_xopen_source="-D_OSF_SOURCE"
4788 cf_xopen_source="-D_QNX_SOURCE"
4791 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4794 cf_xopen_source="-D__EXTENSIONS__"
4795 cf_cv_xopen_source=broken
4797 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4803 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4807 if test -n "$cf_xopen_source" ; then
4808 CF_ADD_CFLAGS($cf_xopen_source,true)
4811 dnl In anything but the default case, we may have system-specific setting
4812 dnl which is still not guaranteed to provide all of the entrypoints that
4813 dnl _XOPEN_SOURCE would yield.
4814 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4815 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4816 AC_TRY_COMPILE([#include <stdlib.h>],[
4817 #ifndef _XOPEN_SOURCE
4820 [cf_XOPEN_SOURCE_set=yes],
4821 [cf_XOPEN_SOURCE_set=no])
4822 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4823 if test $cf_XOPEN_SOURCE_set = yes
4825 AC_TRY_COMPILE([#include <stdlib.h>],[
4826 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4829 [cf_XOPEN_SOURCE_set_ok=yes],
4830 [cf_XOPEN_SOURCE_set_ok=no])
4831 if test $cf_XOPEN_SOURCE_set_ok = no
4833 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4839 fi # cf_cv_posix_visible