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.159 2020/07/11 23:11:37 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_OPTION version: 5 updated: 2015/05/10 19:52:14
361 dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus
367 dnl $3 = action to perform if option is not default
368 dnl $4 = action if perform if option is default
369 dnl $5 = default option value (either 'yes' or 'no')
370 AC_DEFUN([CF_ARG_OPTION],
371 [AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes)
372 if test "$enableval" != "$5" ; then
374 ,[ $3]) ifelse([$4],,,[
377 fi],[enableval=$5 ifelse([$4],,,[
381 dnl ---------------------------------------------------------------------------
382 dnl CF_AR_FLAGS version: 7 updated: 2020/04/04 11:37:29
384 dnl Check for suitable "ar" (archiver) options for updating an archive.
386 dnl In particular, handle some obsolete cases where the "-" might be omitted,
387 dnl as well as a workaround for breakage of make's archive rules by the GNU
388 dnl binutils "ar" program.
389 AC_DEFUN([CF_AR_FLAGS],[
390 AC_REQUIRE([CF_PROG_AR])
392 AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[
393 case $cf_cv_system_name in
396 cat >mk_static_lib.sh <<-EOF
401 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@
403 chmod +x mk_static_lib.sh
404 AR=`pwd`/mk_static_lib.sh
407 cf_cv_ar_flags=unknown
408 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv
411 # check if $ARFLAGS already contains this choice
412 if test "x$ARFLAGS" != "x" ; then
413 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"`
414 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then
420 rm -f conftest.$ac_cv_objext
423 cat >conftest.$ac_ext <<EOF
424 #line __oline__ "configure"
425 int testdata[[3]] = { 123, 456, 789 };
427 if AC_TRY_EVAL(ac_compile) ; then
428 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC
429 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null
430 if test -f conftest.a ; then
431 cf_cv_ar_flags=$cf_ar_flags
435 CF_VERBOSE(cannot compile test-program)
439 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext
444 if test -n "$ARFLAGS" ; then
445 if test -n "$cf_cv_ar_flags" ; then
446 ARFLAGS="$ARFLAGS $cf_cv_ar_flags"
449 ARFLAGS=$cf_cv_ar_flags
454 dnl ---------------------------------------------------------------------------
455 dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04
457 dnl If we're cross-compiling, allow the user to override the tools and their
458 dnl options. The configure script is oriented toward identifying the host
459 dnl compiler, etc., but we need a build compiler to generate parts of the
462 dnl $1 = default for $CPPFLAGS
463 dnl $2 = default for $LIBS
464 AC_DEFUN([CF_BUILD_CC],[
465 CF_ACVERSION_CHECK(2.52,,
466 [AC_REQUIRE([CF_PROG_EXT])])
467 if test "$cross_compiling" = yes ; then
469 # defaults that we might want to override
470 : ${BUILD_CFLAGS:=''}
471 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'}
472 : ${BUILD_LDFLAGS:=''}
473 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'}
474 : ${BUILD_EXEEXT:='$x'}
475 : ${BUILD_OBJEXT:='o'}
477 AC_ARG_WITH(build-cc,
478 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)],
479 [BUILD_CC="$withval"],
480 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)])
481 AC_MSG_CHECKING(for native build C compiler)
482 AC_MSG_RESULT($BUILD_CC)
484 AC_MSG_CHECKING(for native build C preprocessor)
485 AC_ARG_WITH(build-cpp,
486 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)],
487 [BUILD_CPP="$withval"],
488 [BUILD_CPP='${BUILD_CC} -E'])
489 AC_MSG_RESULT($BUILD_CPP)
491 AC_MSG_CHECKING(for native build C flags)
492 AC_ARG_WITH(build-cflags,
493 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)],
494 [BUILD_CFLAGS="$withval"])
495 AC_MSG_RESULT($BUILD_CFLAGS)
497 AC_MSG_CHECKING(for native build C preprocessor-flags)
498 AC_ARG_WITH(build-cppflags,
499 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)],
500 [BUILD_CPPFLAGS="$withval"])
501 AC_MSG_RESULT($BUILD_CPPFLAGS)
503 AC_MSG_CHECKING(for native build linker-flags)
504 AC_ARG_WITH(build-ldflags,
505 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)],
506 [BUILD_LDFLAGS="$withval"])
507 AC_MSG_RESULT($BUILD_LDFLAGS)
509 AC_MSG_CHECKING(for native build linker-libraries)
510 AC_ARG_WITH(build-libs,
511 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})],
512 [BUILD_LIBS="$withval"])
513 AC_MSG_RESULT($BUILD_LIBS)
515 # this assumes we're on Unix.
519 : ${BUILD_CC:='${CC}'}
521 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then
522 AC_MSG_ERROR([Cross-build requires two compilers.
523 Use --with-build-cc to specify the native compiler.])
527 : ${BUILD_CC:='${CC}'}
528 : ${BUILD_CPP:='${CPP}'}
529 : ${BUILD_CFLAGS:='${CFLAGS}'}
530 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'}
531 : ${BUILD_LDFLAGS:='${LDFLAGS}'}
532 : ${BUILD_LIBS:='${LIBS}'}
533 : ${BUILD_EXEEXT:='$x'}
534 : ${BUILD_OBJEXT:='o'}
539 AC_SUBST(BUILD_CFLAGS)
540 AC_SUBST(BUILD_CPPFLAGS)
541 AC_SUBST(BUILD_LDFLAGS)
543 AC_SUBST(BUILD_EXEEXT)
544 AC_SUBST(BUILD_OBJEXT)
546 dnl ---------------------------------------------------------------------------
547 dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26
549 dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content
550 dnl into CC. This will not help with broken scripts that wrap the compiler
551 dnl with options, but eliminates a more common category of user confusion.
553 dnl In particular, it addresses the problem of being able to run the C
554 dnl preprocessor in a consistent manner.
556 dnl Caveat: this also disallows blanks in the pathname for the compiler, but
557 dnl the nuisance of having inconsistent settings for compiler and preprocessor
558 dnl outweighs that limitation.
559 AC_DEFUN([CF_CC_ENV_FLAGS],
561 # This should have been defined by AC_PROG_CC
564 AC_MSG_CHECKING(\$CFLAGS variable)
567 AC_MSG_RESULT(broken)
568 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options)
571 for cf_arg in $cf_flags
573 CF_ADD_CFLAGS($cf_arg)
581 AC_MSG_CHECKING(\$CC variable)
584 AC_MSG_RESULT(broken)
585 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options)
587 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'`
588 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'`
590 for cf_arg in $cf_flags
594 CF_ADD_CFLAGS($cf_arg)
601 CF_VERBOSE(resulting CC: '$CC')
602 CF_VERBOSE(resulting CFLAGS: '$CFLAGS')
603 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS')
610 dnl ---------------------------------------------------------------------------
611 dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04
613 dnl Determine the default configuration into which we'll install ncurses. This
614 dnl can be overridden by the user's command-line options. There's two items to
616 dnl 1. the prefix (e.g., /usr)
617 dnl 2. the header files (e.g., /usr/include/ncurses)
618 dnl We'll look for a previous installation of ncurses and use the same defaults.
620 dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and
621 dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's
622 dnl programs from a vendor's.
623 AC_DEFUN([CF_CFG_DEFAULTS],
625 AC_MSG_CHECKING(for prefix)
626 if test "x$prefix" = "xNONE" ; then
627 case "$cf_cv_system_name" in
628 # non-vendor systems don't have a conflict
629 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*)
632 (*) prefix=$ac_default_prefix
636 AC_MSG_RESULT($prefix)
638 if test "x$prefix" = "xNONE" ; then
639 AC_MSG_CHECKING(for default include-directory)
640 test -n "$verbose" && echo 1>&AC_FD_MSG
643 $includedir/ncurses \
645 $prefix/include/ncurses \
647 /usr/local/include/ncurses \
651 cf_dir=`eval echo $cf_symbol`
652 if test -f $cf_dir/curses.h ; then
653 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then
654 includedir="$cf_symbol"
655 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG
659 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG
661 AC_MSG_RESULT($includedir)
664 dnl ---------------------------------------------------------------------------
665 dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03
667 dnl Check if we're accidentally using a cache from a different machine.
668 dnl Derive the system name, as a check for reusing the autoconf cache.
670 dnl If we've packaged config.guess and config.sub, run that (since it does a
671 dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow
672 dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM
673 dnl which is useful in cross-compiles.
675 dnl Note: we would use $ac_config_sub, but that is one of the places where
676 dnl autoconf 2.5x broke compatibility with autoconf 2.13
677 AC_DEFUN([CF_CHECK_CACHE],
679 if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then
680 ifelse([$1],,[AC_CANONICAL_HOST],[$1])
681 system_name="$host_os"
683 system_name="`(uname -s -r) 2>/dev/null`"
684 if test -z "$system_name" ; then
685 system_name="`(hostname) 2>/dev/null`"
688 test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.])
689 AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"])
691 test -z "$system_name" && system_name="$cf_cv_system_name"
692 test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name)
694 if test ".$system_name" != ".$cf_cv_system_name" ; then
695 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name))
696 AC_MSG_ERROR("Please remove config.cache and try again.")
699 dnl ---------------------------------------------------------------------------
700 dnl CF_CHECK_GNAT_VERSION version: 3 updated: 2020/05/23 19:39:36
701 dnl ---------------------
702 AC_DEFUN([CF_CHECK_GNAT_VERSION],
704 AC_REQUIRE([CF_GNAT_VERSION])
705 case $cf_cv_gnat_version in
706 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
707 cf_cv_prog_gnat_correct=yes
710 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.)
711 cf_cv_prog_gnat_correct=no
715 dnl ---------------------------------------------------------------------------
716 dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35
717 dnl -----------------
718 dnl Check if the given compiler is really clang. clang's C driver defines
719 dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does
720 dnl not ignore some gcc options.
722 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
723 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
724 dnl the wrappers for gcc and g++ warnings.
726 dnl $1 = GCC (default) or GXX
727 dnl $2 = CLANG_COMPILER (default)
728 dnl $3 = CFLAGS (default) or CXXFLAGS
729 AC_DEFUN([CF_CLANG_COMPILER],[
730 ifelse([$2],,CLANG_COMPILER,[$2])=no
732 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
733 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler)
734 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
735 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments"
741 ],[ifelse([$2],,CLANG_COMPILER,[$2])=yes
742 cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments"
744 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
745 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2]))
748 dnl ---------------------------------------------------------------------------
749 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
750 dnl -----------------
751 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
752 dnl character-strings.
754 dnl It is ambiguous because the specification accommodated the pre-ANSI
755 dnl compilers bundled by more than one vendor in lieu of providing a standard C
756 dnl compiler other than by costly add-ons. Because of this, the specification
757 dnl did not take into account the use of const for telling the compiler that
758 dnl string literals would be in readonly memory.
760 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
761 dnl let the compiler decide how to represent Xt's strings which were #define'd.
762 dnl That does not solve the problem of using the block of Xt's strings which
763 dnl are compiled into the library (and is less efficient than one might want).
765 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
766 dnl when compiling the library and compiling using the library, to tell the
767 dnl compiler that String is const.
768 AC_DEFUN([CF_CONST_X_STRING],
770 AC_REQUIRE([AC_PATH_XTRA])
772 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
777 #include <X11/Intrinsic.h>
779 [String foo = malloc(1); (void)foo],[
781 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
784 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
785 #undef XTSTRINGDEFINES /* X11R5 and later */
787 #include <X11/Intrinsic.h>
788 ],[String foo = malloc(1); *foo = 0],[
789 cf_cv_const_x_string=no
791 cf_cv_const_x_string=yes
795 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
797 case $cf_cv_const_x_string in
799 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
802 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
808 dnl ---------------------------------------------------------------------------
809 dnl CF_CONST_X_STRING version: 4 updated: 2020/03/10 18:53:47
810 dnl -----------------
811 dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most
812 dnl character-strings.
814 dnl It is ambiguous because the specification accommodated the pre-ANSI
815 dnl compilers bundled by more than one vendor in lieu of providing a standard C
816 dnl compiler other than by costly add-ons. Because of this, the specification
817 dnl did not take into account the use of const for telling the compiler that
818 dnl string literals would be in readonly memory.
820 dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to
821 dnl let the compiler decide how to represent Xt's strings which were #define'd.
822 dnl That does not solve the problem of using the block of Xt's strings which
823 dnl are compiled into the library (and is less efficient than one might want).
825 dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both
826 dnl when compiling the library and compiling using the library, to tell the
827 dnl compiler that String is const.
828 AC_DEFUN([CF_CONST_X_STRING],
830 AC_REQUIRE([AC_PATH_XTRA])
832 CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING])
837 #include <X11/Intrinsic.h>
839 [String foo = malloc(1); (void)foo],[
841 AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[
844 #define _CONST_X_STRING /* X11R7.8 (perhaps) */
845 #undef XTSTRINGDEFINES /* X11R5 and later */
847 #include <X11/Intrinsic.h>
848 ],[String foo = malloc(1); *foo = 0],[
849 cf_cv_const_x_string=no
851 cf_cv_const_x_string=yes
855 CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING])
857 case $cf_cv_const_x_string in
859 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES)
862 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING)
868 dnl ---------------------------------------------------------------------------
869 dnl CF_CURSES_HEADER version: 5 updated: 2015/04/23 20:35:30
871 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
872 dnl variations of ncurses' installs.
874 dnl $1 = ncurses when looking for ncurses, or is empty
875 AC_DEFUN([CF_CURSES_HEADER],[
876 AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[
877 cf_cv_ncurses_header=none
879 ncurses.h ifelse($1,,,[$1/ncurses.h]) \
880 curses.h ifelse($1,,,[$1/curses.h]) ifelse($1,,[ncurses/ncurses.h ncurses/curses.h])
882 AC_TRY_COMPILE([#include <${cf_header}>],
883 [initscr(); tgoto("?", 0,0)],
884 [cf_cv_ncurses_header=$cf_header; break],[])
888 if test "$cf_cv_ncurses_header" = none ; then
889 AC_MSG_ERROR(No curses header-files found)
892 # cheat, to get the right #define's for HAVE_NCURSES_H, etc.
893 AC_CHECK_HEADERS($cf_cv_ncurses_header)
895 dnl ---------------------------------------------------------------------------
896 dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52
898 dnl "dirname" is not portable, so we fake it with a shell script.
899 AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl
900 dnl ---------------------------------------------------------------------------
901 dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57
903 dnl You can always use "make -n" to see the actual options, but it's hard to
904 dnl pick out/analyze warning messages when the compile-line is long.
907 dnl ECHO_LT - symbol to control if libtool is verbose
908 dnl ECHO_LD - symbol to prefix "cc -o" lines
909 dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o)
910 dnl SHOW_CC - symbol to put before explicit "cc -c" lines
911 dnl ECHO_CC - symbol to put before any "cc" line
913 AC_DEFUN([CF_DISABLE_ECHO],[
914 AC_MSG_CHECKING(if you want to see long compiling messages)
916 [ --disable-echo do not display "compiling" commands],
919 ECHO_LD='@echo linking [$]@;'
920 RULE_CC='@echo compiling [$]<'
921 SHOW_CC='@echo compiling [$]@'
930 AC_MSG_RESULT($enableval)
937 dnl ---------------------------------------------------------------------------
938 dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00
939 dnl ------------------------
940 AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[
941 AC_MSG_CHECKING(if we want to use GNAT projects)
942 CF_ARG_DISABLE(gnat-projects,
943 [ --disable-gnat-projects test: disable GNAT projects even if usable],
944 [enable_gnat_projects=no],
945 [enable_gnat_projects=yes])
946 AC_MSG_RESULT($enable_gnat_projects)
948 dnl ---------------------------------------------------------------------------
949 dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30
950 dnl -----------------------
951 dnl Some linkers cannot reference a data-only object. Cygwin used to be one.
952 dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need
953 dnl an unconditional feature.
954 AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[
956 AC_MSG_CHECKING(if you want broken-linker support code)
957 AC_ARG_ENABLE(broken_linker,
958 [ --enable-broken_linker compile with broken-linker support code],
959 [with_broken_linker=$enableval],
960 [with_broken_linker=no])
961 AC_MSG_RESULT($with_broken_linker)
963 : ${BROKEN_LINKER:=0}
964 if test "x$with_broken_linker" = xyes ; then
965 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules])
968 AC_SUBST(BROKEN_LINKER)
970 dnl ---------------------------------------------------------------------------
971 dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54
973 dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We
974 dnl prefer a standard location, and use -L options only if we do not find the
975 dnl library in the standard library location(s).
976 dnl $1 = library name
977 dnl $2 = library class, usually the same as library name
979 dnl $4 = code fragment to compile/link
980 dnl $5 = corresponding function-name
981 dnl $6 = flag, nonnull if failure should not cause an error-exit
983 dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had
984 dnl to use a -L option.
985 AC_DEFUN([CF_FIND_LIBRARY],
987 eval 'cf_cv_have_lib_'$1'=no'
990 eval 'cf_cv_have_lib_'$1'=yes',[
992 AC_MSG_CHECKING(for $5 in -l$1)
994 AC_TRY_LINK([$3],[$4],
996 eval 'cf_cv_have_lib_'$1'=yes'
999 CF_LIBRARY_PATH(cf_search,$2)
1000 for cf_libdir in $cf_search
1002 AC_MSG_CHECKING(for -l$1 in $cf_libdir)
1003 LIBS="-L$cf_libdir -l$1 $cf_save_LIBS"
1004 AC_TRY_LINK([$3],[$4],
1006 eval 'cf_cv_have_lib_'$1'=yes'
1009 LIBS="$cf_save_LIBS"])
1013 eval 'cf_found_library=[$]cf_cv_have_lib_'$1
1015 if test $cf_found_library = no ; then
1016 AC_MSG_ERROR(Cannot link $1 library)
1020 dnl ---------------------------------------------------------------------------
1021 dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13
1023 dnl Find a library (specifically the linkage used in the code fragment),
1024 dnl searching for it if it is not already in the library path.
1025 dnl See also CF_ADD_SEARCHPATH.
1027 dnl Parameters (4-on are optional):
1028 dnl $1 = headers for library entrypoint
1029 dnl $2 = code fragment for library entrypoint
1030 dnl $3 = the library name without the "-l" option or ".so" suffix.
1031 dnl $4 = action to perform if successful (default: update CPPFLAGS, etc)
1032 dnl $5 = action to perform if not successful
1033 dnl $6 = module name, if not the same as the library name
1034 dnl $7 = extra libraries
1036 dnl Sets these variables:
1037 dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found
1038 dnl $cf_cv_header_path_$3 - include-directory if needed
1039 dnl $cf_cv_library_path_$3 - library-directory if needed
1040 dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3
1041 AC_DEFUN([CF_FIND_LINKAGE],[
1043 # If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these
1044 # will be set on completion of the AC_TRY_LINK below.
1045 cf_cv_header_path_$3=
1046 cf_cv_library_path_$3=
1048 CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)])
1050 cf_save_LIBS="$LIBS"
1052 AC_TRY_LINK([$1],[$2],[
1053 cf_cv_find_linkage_$3=yes
1054 cf_cv_header_path_$3=/usr/include
1055 cf_cv_library_path_$3=/usr/lib
1058 LIBS="-l$3 $7 $cf_save_LIBS"
1060 AC_TRY_LINK([$1],[$2],[
1061 cf_cv_find_linkage_$3=yes
1062 cf_cv_header_path_$3=/usr/include
1063 cf_cv_library_path_$3=/usr/lib
1064 cf_cv_library_file_$3="-l$3"
1066 cf_cv_find_linkage_$3=no
1067 LIBS="$cf_save_LIBS"
1069 CF_VERBOSE(find linkage for $3 library)
1070 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)])
1072 cf_save_CPPFLAGS="$CPPFLAGS"
1073 cf_test_CPPFLAGS="$CPPFLAGS"
1075 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6]))
1076 for cf_cv_header_path_$3 in $cf_search
1078 if test -d $cf_cv_header_path_$3 ; then
1079 CF_VERBOSE(... testing $cf_cv_header_path_$3)
1080 CPPFLAGS="$cf_save_CPPFLAGS"
1081 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3)
1082 AC_TRY_COMPILE([$1],[$2],[
1083 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3)
1084 cf_cv_find_linkage_$3=maybe
1085 cf_test_CPPFLAGS="$CPPFLAGS"
1087 CPPFLAGS="$cf_save_CPPFLAGS"
1092 if test "$cf_cv_find_linkage_$3" = maybe ; then
1094 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)])
1096 cf_save_LIBS="$LIBS"
1097 cf_save_LDFLAGS="$LDFLAGS"
1100 CPPFLAGS="$cf_test_CPPFLAGS"
1101 LIBS="-l$3 $7 $cf_save_LIBS"
1102 AC_TRY_LINK([$1],[$2],[
1103 CF_VERBOSE(... found $3 library in system)
1104 cf_cv_find_linkage_$3=yes])
1105 CPPFLAGS="$cf_save_CPPFLAGS"
1106 LIBS="$cf_save_LIBS"
1109 if test "$cf_cv_find_linkage_$3" != yes ; then
1110 CF_LIBRARY_PATH(cf_search,$3)
1111 for cf_cv_library_path_$3 in $cf_search
1113 if test -d $cf_cv_library_path_$3 ; then
1114 CF_VERBOSE(... testing $cf_cv_library_path_$3)
1115 CPPFLAGS="$cf_test_CPPFLAGS"
1116 LIBS="-l$3 $7 $cf_save_LIBS"
1117 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3"
1118 AC_TRY_LINK([$1],[$2],[
1119 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3)
1120 cf_cv_find_linkage_$3=yes
1121 cf_cv_library_file_$3="-l$3"
1123 CPPFLAGS="$cf_save_CPPFLAGS"
1124 LIBS="$cf_save_LIBS"
1125 LDFLAGS="$cf_save_LDFLAGS"
1129 CPPFLAGS="$cf_save_CPPFLAGS"
1130 LDFLAGS="$cf_save_LDFLAGS"
1134 cf_cv_find_linkage_$3=no
1139 LIBS="$cf_save_LIBS"
1141 if test "$cf_cv_find_linkage_$3" = yes ; then
1143 CF_ADD_INCDIR($cf_cv_header_path_$3)
1144 CF_ADD_LIBDIR($cf_cv_library_path_$3)
1148 ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5])
1151 dnl ---------------------------------------------------------------------------
1152 dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04
1153 dnl -----------------
1154 dnl make ADAFLAGS consistent with CFLAGS
1155 AC_DEFUN([CF_FIXUP_ADAFLAGS],[
1156 AC_MSG_CHECKING(optimization options for ADAFLAGS)
1164 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'`
1165 CF_ADD_ADAFLAGS($cf_O_flag)
1168 AC_MSG_RESULT($ADAFLAGS)
1170 dnl ---------------------------------------------------------------------------
1171 dnl CF_GCC_ATTRIBUTES version: 18 updated: 2020/03/10 18:53:47
1172 dnl -----------------
1173 dnl Test for availability of useful gcc __attribute__ directives to quiet
1174 dnl compiler warnings. Though useful, not all are supported -- and contrary
1175 dnl to documentation, unrecognized directives cause older compilers to barf.
1176 AC_DEFUN([CF_GCC_ATTRIBUTES],
1178 if test "$GCC" = yes
1180 cat > conftest.i <<EOF
1182 #define GCC_PRINTF 0
1187 #ifndef GCC_NORETURN
1188 #define GCC_NORETURN /* nothing */
1191 #define GCC_UNUSED /* nothing */
1194 if test "$GCC" = yes
1196 AC_CHECKING([for $CC __attribute__ directives])
1197 cat > conftest.$ac_ext <<EOF
1198 #line __oline__ "${as_me:-configure}"
1199 #include "confdefs.h"
1200 #include "conftest.h"
1201 #include "conftest.i"
1203 #define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
1205 #define GCC_PRINTFLIKE(fmt,var) /*nothing*/
1208 #define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var)))
1210 #define GCC_SCANFLIKE(fmt,var) /*nothing*/
1212 extern void wow(char *,...) GCC_SCANFLIKE(1,2);
1213 extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN;
1214 extern void foo(void) GCC_NORETURN;
1215 int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; }
1217 cf_printf_attribute=no
1218 cf_scanf_attribute=no
1219 for cf_attribute in scanf printf unused noreturn
1221 CF_UPPER(cf_ATTRIBUTE,$cf_attribute)
1222 cf_directive="__attribute__(($cf_attribute))"
1223 echo "checking for $CC $cf_directive" 1>&AC_FD_CC
1225 case $cf_attribute in
1227 cf_printf_attribute=yes
1228 cat >conftest.h <<EOF
1229 #define GCC_$cf_ATTRIBUTE 1
1233 cf_scanf_attribute=yes
1234 cat >conftest.h <<EOF
1235 #define GCC_$cf_ATTRIBUTE 1
1239 cat >conftest.h <<EOF
1240 #define GCC_$cf_ATTRIBUTE $cf_directive
1245 if AC_TRY_EVAL(ac_compile); then
1246 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute)
1247 cat conftest.h >>confdefs.h
1248 case $cf_attribute in
1250 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc])
1253 cf_value='/* nothing */'
1254 if test "$cf_printf_attribute" != no ; then
1255 cf_value='__attribute__((format(printf,fmt,var)))'
1256 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.])
1258 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc])
1261 cf_value='/* nothing */'
1262 if test "$cf_scanf_attribute" != no ; then
1263 cf_value='__attribute__((format(scanf,fmt,var)))'
1264 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.])
1266 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc])
1269 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc])
1275 fgrep define conftest.i >>confdefs.h
1280 dnl ---------------------------------------------------------------------------
1281 dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36
1283 dnl Find version of gcc, and (because icc/clang pretend to be gcc without being
1284 dnl compatible), attempt to determine if icc/clang is actually used.
1285 AC_DEFUN([CF_GCC_VERSION],[
1286 AC_REQUIRE([AC_PROG_CC])
1288 if test "$GCC" = yes ; then
1289 AC_MSG_CHECKING(version of $CC)
1290 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.]].*//'`"
1291 test -z "$GCC_VERSION" && GCC_VERSION=unknown
1292 AC_MSG_RESULT($GCC_VERSION)
1294 CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS)
1295 CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS)
1297 dnl ---------------------------------------------------------------------------
1298 dnl CF_GCC_WARNINGS version: 37 updated: 2020/01/05 20:04:12
1300 dnl Check if the compiler supports useful warning options. There's a few that
1301 dnl we don't use, simply because they're too noisy:
1303 dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x)
1304 dnl -Winline (usually not worthwhile)
1305 dnl -Wredundant-decls (system headers make this too noisy)
1306 dnl -Wtraditional (combines too many unrelated messages, only a few useful)
1307 dnl -Wwrite-strings (too noisy, but should review occasionally). This
1308 dnl is enabled for ncurses using "--enable-const".
1312 dnl $1 is an optional list of gcc warning flags that a particular
1313 dnl application might want to use, e.g., "no-unused" for
1316 dnl If $with_ext_const is "yes", add a check for -Wwrite-strings
1318 AC_DEFUN([CF_GCC_WARNINGS],
1320 AC_REQUIRE([CF_GCC_VERSION])
1321 if test "x$have_x" = xyes; then CF_CONST_X_STRING fi
1322 cat > conftest.$ac_ext <<EOF
1323 #line __oline__ "${as_me:-configure}"
1324 int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; }
1326 if test "$INTEL_COMPILER" = yes
1328 # The "-wdXXX" options suppress warnings:
1329 # remark #1419: external declaration in primary source file
1330 # remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1331 # remark #1684: conversion from pointer to same-sized integral type (potential portability problem)
1332 # remark #193: zero used for undefined preprocessing identifier
1333 # remark #593: variable "curs_sb_left_arrow" was set but never used
1334 # remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits
1335 # remark #869: parameter "tw" was never referenced
1336 # remark #981: operands are evaluated in unspecified order
1337 # warning #279: controlling expression is constant
1339 AC_CHECKING([for $CC warning options])
1340 cf_save_CFLAGS="$CFLAGS"
1341 EXTRA_CFLAGS="-Wall"
1353 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1354 if AC_TRY_EVAL(ac_compile); then
1355 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1356 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1359 CFLAGS="$cf_save_CFLAGS"
1360 elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown"
1362 AC_CHECKING([for $CC warning options])
1363 cf_save_CFLAGS="$CFLAGS"
1366 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings"
1367 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs"
1368 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings=
1369 for cf_opt in W Wall \
1370 Wbad-function-cast \
1373 Wdeclaration-after-statement \
1376 Wmissing-declarations \
1377 Wmissing-prototypes \
1381 Wstrict-prototypes \
1382 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1
1384 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt"
1385 if AC_TRY_EVAL(ac_compile); then
1386 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt)
1389 case $GCC_VERSION in
1391 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1396 case $GCC_VERSION in
1398 CF_VERBOSE(feature is broken in gcc $GCC_VERSION)
1403 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt"
1406 CFLAGS="$cf_save_CFLAGS"
1410 AC_SUBST(EXTRA_CFLAGS)
1412 dnl ---------------------------------------------------------------------------
1413 dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25
1414 dnl -----------------
1415 AC_DEFUN([CF_GNATPREP_OPT_T],[
1416 AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[
1417 cf_cv_gnatprep_opt_t=no
1418 gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes
1420 test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS"
1421 AC_SUBST(GNATPREP_OPTS)
1423 dnl ---------------------------------------------------------------------------
1424 dnl CF_GNAT_GENERICS version: 6 updated: 2020/07/04 19:30:27
1425 dnl ----------------
1426 AC_DEFUN([CF_GNAT_GENERICS],
1428 AC_REQUIRE([CF_GNAT_VERSION])
1430 AC_MSG_CHECKING(if GNAT supports generics)
1431 case $cf_cv_gnat_version in
1432 (3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]])
1433 cf_gnat_generics=yes
1439 AC_MSG_RESULT($cf_gnat_generics)
1441 if test "$cf_gnat_generics" = yes
1443 cf_compile_generics=generics
1444 cf_generic_objects="\${GENOBJS}"
1446 cf_compile_generics=
1450 AC_SUBST(cf_compile_generics)
1451 AC_SUBST(cf_generic_objects)
1453 dnl ---------------------------------------------------------------------------
1454 dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54
1455 dnl ----------------
1456 dnl GNAT projects are configured with ".gpr" project files.
1457 dnl GNAT libraries are a further development, using the project feature.
1458 AC_DEFUN([CF_GNAT_PROJECTS],
1460 AC_REQUIRE([CF_GNAT_VERSION])
1461 AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS])
1463 cf_gnat_libraries=no
1466 if test "$enable_gnat_projects" != no ; then
1467 AC_MSG_CHECKING(if GNAT supports project files)
1468 case $cf_cv_gnat_version in
1472 case $cf_cv_system_name in
1476 rm -rf conftest* *~conftest*
1477 if mkdir conftest.src conftest.bin conftest.lib
1480 rm -rf conftest* *~conftest*
1481 cat >>library.gpr <<CF_EOF
1483 Kind := External ("LIB_KIND");
1484 for Library_Name use "ConfTest";
1485 for Object_Dir use ".";
1486 for Library_ALI_Dir use External("LIBRARY_DIR");
1487 for Library_Version use External ("SONAME");
1488 for Library_Kind use Kind;
1489 for Library_Dir use External("BUILD_DIR");
1490 Source_Dir := External ("SOURCE_DIR");
1491 for Source_Dirs use (Source_Dir);
1494 cat >>confpackage.ads <<CF_EOF
1495 package ConfPackage is
1499 cat >>confpackage.adb <<CF_EOF
1501 package body ConfPackage is
1502 procedure conftest is
1504 Text_IO.Put ("Hello World");
1509 if ( $cf_ada_make $ADAFLAGS \
1511 -XBUILD_DIR=`cd ../conftest.bin;pwd` \
1512 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \
1513 -XSOURCE_DIR=`pwd` \
1514 -XSONAME=libConfTest.so.1 \
1515 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then
1516 cf_gnat_projects=yes
1520 if test -f conftest.lib/confpackage.ali
1522 cf_gnat_libraries=yes
1524 rm -rf conftest* *~conftest*
1529 AC_MSG_RESULT($cf_gnat_projects)
1530 fi # enable_gnat_projects
1532 if test $cf_gnat_projects = yes
1534 AC_MSG_CHECKING(if GNAT supports libraries)
1535 AC_MSG_RESULT($cf_gnat_libraries)
1538 if test "$cf_gnat_projects" = yes
1540 USE_OLD_MAKERULES="#"
1541 USE_GNAT_PROJECTS=""
1543 USE_OLD_MAKERULES=""
1544 USE_GNAT_PROJECTS="#"
1547 if test "$cf_gnat_libraries" = yes
1549 USE_GNAT_LIBRARIES=""
1551 USE_GNAT_LIBRARIES="#"
1554 AC_SUBST(USE_OLD_MAKERULES)
1555 AC_SUBST(USE_GNAT_PROJECTS)
1556 AC_SUBST(USE_GNAT_LIBRARIES)
1558 dnl ---------------------------------------------------------------------------
1559 dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59
1561 dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it
1562 dnl is noted that gnat may compile a tasking unit even for configurations which
1563 dnl fail at runtime.
1564 AC_DEFUN([CF_GNAT_SIGINT],[
1565 AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[
1566 CF_GNAT_TRY_LINK([with Ada.Interrupts.Names;
1570 pragma Warnings (Off); -- the next pragma exists since 3.11p
1571 pragma Unreserve_All_Interrupts;
1572 pragma Warnings (On);
1574 protected Process is
1576 function Continue return Boolean;
1577 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT);
1579 Done : Boolean := False;
1583 [package body ConfTest is
1584 protected body Process is
1589 function Continue return Boolean is
1595 [cf_cv_gnat_sigint=yes],
1596 [cf_cv_gnat_sigint=no])])
1598 if test $cf_cv_gnat_sigint = yes ; then
1603 AC_SUBST(USE_GNAT_SIGINT)
1605 dnl ---------------------------------------------------------------------------
1606 dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45
1607 dnl ----------------
1608 dnl Verify that a test program compiles/links with GNAT.
1609 dnl $cf_ada_make is set to the program that compiles/links
1610 dnl $ADAFLAGS may be set to the GNAT flags.
1612 dnl $1 is the text of the spec
1613 dnl $2 is the text of the body
1614 dnl $3 is the shell command to execute if successful
1615 dnl $4 is the shell command to execute if not successful
1616 AC_DEFUN([CF_GNAT_TRY_LINK],
1618 rm -rf conftest* *~conftest*
1619 cat >>conftest.ads <<CF_EOF
1622 cat >>conftest.adb <<CF_EOF
1625 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1626 ifelse($3,, :,[ $3])
1630 rm -rf conftest* *~conftest*
1632 dnl ---------------------------------------------------------------------------
1633 dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45
1635 dnl Verify that a test program compiles and runs with GNAT
1636 dnl $cf_ada_make is set to the program that compiles/links
1637 dnl $ADAFLAGS may be set to the GNAT flags.
1639 dnl $1 is the text of the spec
1640 dnl $2 is the text of the body
1641 dnl $3 is the shell command to execute if successful
1642 dnl $4 is the shell command to execute if not successful
1643 AC_DEFUN([CF_GNAT_TRY_RUN],
1645 rm -rf conftest* *~conftest*
1646 cat >>conftest.ads <<CF_EOF
1649 cat >>conftest.adb <<CF_EOF
1652 if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then
1653 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then
1654 ifelse($3,, :,[ $3])
1661 rm -rf conftest* *~conftest*
1663 dnl ---------------------------------------------------------------------------
1664 dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54
1666 dnl $1 = cache variable to update
1667 dnl $2 = program name
1668 dnl Verify version of GNAT or related tool
1669 AC_DEFUN([CF_GNAT_VERSION],
1671 AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[
1672 cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \
1673 grep '[[0-9]].[[0-9]][[0-9]]*' |\
1674 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'`
1676 test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no
1677 ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version])
1679 dnl ---------------------------------------------------------------------------
1680 dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41
1682 dnl Check if we must define _GNU_SOURCE to get a reasonable value for
1683 dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect
1684 dnl (or misfeature) of glibc2, which breaks portability of many applications,
1685 dnl since it is interwoven with GNU extensions.
1687 dnl Well, yes we could work around it...
1690 dnl $1 is the nominal value for _XOPEN_SOURCE
1691 AC_DEFUN([CF_GNU_SOURCE],
1693 cf_gnu_xopen_source=ifelse($1,,500,$1)
1695 AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[
1696 AC_TRY_COMPILE([#include <sys/types.h>],[
1697 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0
1699 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0
1702 # error not GNU C library
1704 [cf_cv_gnu_library=yes],
1705 [cf_cv_gnu_library=no])
1708 if test x$cf_cv_gnu_library = xyes; then
1710 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE
1711 # was changed to help a little. newlib incorporated the change about 4
1713 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[
1715 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1716 AC_TRY_COMPILE([#include <sys/types.h>],[
1717 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2)
1719 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3)
1722 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old
1724 [cf_cv_gnu_library_219=yes],
1725 [cf_cv_gnu_library_219=no])
1729 if test "x$cf_cv_gnu_library_219" = xyes; then
1731 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[
1732 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source)
1735 #include <sys/types.h>
1737 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1)
1740 # error GNU C library is too old
1742 [cf_cv_gnu_dftsrc_219=yes],
1743 [cf_cv_gnu_dftsrc_219=no])
1745 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save"
1747 cf_cv_gnu_dftsrc_219=maybe
1750 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then
1752 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[
1753 AC_TRY_COMPILE([#include <sys/types.h>],[
1754 #ifndef _XOPEN_SOURCE
1755 #error expected _XOPEN_SOURCE to be defined
1757 [cf_cv_gnu_source=no],
1758 [cf_save="$CPPFLAGS"
1759 CF_ADD_CFLAGS(-D_GNU_SOURCE)
1760 AC_TRY_COMPILE([#include <sys/types.h>],[
1761 #ifdef _XOPEN_SOURCE
1762 #error expected _XOPEN_SOURCE to be undefined
1764 [cf_cv_gnu_source=no],
1765 [cf_cv_gnu_source=yes])
1770 if test "$cf_cv_gnu_source" = yes
1772 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[
1773 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE)
1774 AC_TRY_COMPILE([#include <sys/types.h>],[
1775 #ifdef _DEFAULT_SOURCE
1776 #error expected _DEFAULT_SOURCE to be undefined
1778 [cf_cv_default_source=no],
1779 [cf_cv_default_source=yes])
1781 if test "$cf_cv_default_source" = yes
1783 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE)
1790 dnl ---------------------------------------------------------------------------
1791 dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48
1793 dnl Construct a search-list of directories for a nonstandard header-file
1796 dnl $1 = the variable to return as result
1797 dnl $2 = the package name
1798 AC_DEFUN([CF_HEADER_PATH],
1802 # collect the current set of include-directories from compiler flags
1803 cf_header_path_list=""
1804 if test -n "${CFLAGS}${CPPFLAGS}" ; then
1805 for cf_header_path in $CPPFLAGS $CFLAGS
1807 case $cf_header_path in
1809 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'`
1810 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE)
1811 cf_header_path_list="$cf_header_path_list [$]$1"
1817 # add the variations for the package we are looking for
1818 CF_SUBDIR_PATH($1,$2,include)
1820 test "$includedir" != NONE && \
1821 test "$includedir" != "/usr/include" && \
1822 test -d "$includedir" && {
1823 test -d $includedir && $1="[$]$1 $includedir"
1824 test -d $includedir/$2 && $1="[$]$1 $includedir/$2"
1827 test "$oldincludedir" != NONE && \
1828 test "$oldincludedir" != "/usr/include" && \
1829 test -d "$oldincludedir" && {
1830 test -d $oldincludedir && $1="[$]$1 $oldincludedir"
1831 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2"
1834 $1="[$]$1 $cf_header_path_list"
1836 dnl ---------------------------------------------------------------------------
1837 dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54
1839 dnl Insert text into the help-message, for readability, from AC_ARG_WITH.
1840 AC_DEFUN([CF_HELP_MESSAGE],
1841 [CF_ACVERSION_CHECK(2.53,[],[
1842 AC_DIVERT_HELP($1)])dnl
1844 dnl ---------------------------------------------------------------------------
1845 dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42
1847 dnl Construct the list of include-options according to whether we're building
1848 dnl in the source directory or using '--srcdir=DIR' option.
1849 AC_DEFUN([CF_INCLUDE_DIRS],
1851 if test "$srcdir" != "."; then
1852 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS"
1854 CPPFLAGS="-I../include $CPPFLAGS"
1855 if test "$srcdir" != "."; then
1856 CPPFLAGS="-I\${srcdir} $CPPFLAGS"
1858 CPPFLAGS="-I. $CPPFLAGS"
1861 dnl ---------------------------------------------------------------------------
1862 dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21
1864 dnl prompt for/fill-in useful install-program options
1865 AC_DEFUN([CF_INSTALL_OPTS],
1871 dnl ---------------------------------------------------------------------------
1872 dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35
1873 dnl ----------------
1874 dnl Almost all "install" programs default to the current user's ownership.
1875 dnl Almost - MINIX is an exception.
1876 AC_DEFUN([CF_INSTALL_OPT_O],
1878 AC_MSG_CHECKING(if install needs to be told about ownership)
1879 case `$ac_config_guess` in
1888 AC_MSG_RESULT($with_install_o)
1889 if test "x$with_install_o" = xyes
1891 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'`
1896 AC_SUBST(INSTALL_OPT_O)
1898 dnl ---------------------------------------------------------------------------
1899 dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21
1900 dnl ----------------
1901 dnl Some install-programs accept a "-p" option to preserve file modification
1902 dnl timestamps. That can be useful as an install option, as well as a way to
1903 dnl avoid the need for ranlib after copying a static archive.
1904 AC_DEFUN([CF_INSTALL_OPT_P],
1906 : ${INSTALL:=install}
1907 AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[
1912 if $INSTALL -p conftest.in conftest.out 2>/dev/null
1914 if test -f conftest.out/conftest.in
1916 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \
1917 test conftest.out/conftest.in -nt conftest.in 2>conftest.err
1918 if test -s conftest.err
1933 dnl ---------------------------------------------------------------------------
1934 dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21
1935 dnl ----------------
1936 dnl By default, we should strip executables which are installed, but leave the
1937 dnl ability to suppress that for unit-testing.
1938 AC_DEFUN([CF_INSTALL_OPT_S],
1940 AC_MSG_CHECKING(if you want to install stripped executables)
1941 CF_ARG_DISABLE(stripping,
1942 [ --disable-stripping do not strip (debug info) installed executables],
1943 [with_stripping=no],
1944 [with_stripping=yes])
1945 AC_MSG_RESULT($with_stripping)
1947 if test "$with_stripping" = yes
1953 AC_SUBST(INSTALL_OPT_S)
1955 dnl ---------------------------------------------------------------------------
1956 dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00
1957 dnl -----------------
1958 dnl Check if the given compiler is really the Intel compiler for Linux. It
1959 dnl tries to imitate gcc, but does not return an error when it finds a mismatch
1960 dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK.
1962 dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to
1963 dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from
1964 dnl the wrappers for gcc and g++ warnings.
1966 dnl $1 = GCC (default) or GXX
1967 dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS
1968 dnl $3 = CFLAGS (default) or CXXFLAGS
1969 AC_DEFUN([CF_INTEL_COMPILER],[
1970 AC_REQUIRE([AC_CANONICAL_HOST])
1971 ifelse([$2],,INTEL_COMPILER,[$2])=no
1973 if test "$ifelse([$1],,[$1],GCC)" = yes ; then
1976 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler)
1977 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])"
1978 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc"
1980 #ifdef __INTEL_COMPILER
1984 ],[ifelse([$2],,INTEL_COMPILER,[$2])=yes
1985 cf_save_CFLAGS="$cf_save_CFLAGS -we147"
1987 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS"
1988 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2]))
1993 dnl ---------------------------------------------------------------------------
1994 dnl CF_LARGEFILE version: 12 updated: 2020/03/19 20:23:48
1996 dnl Add checks for large file support.
1997 AC_DEFUN([CF_LARGEFILE],[
1998 ifdef([AC_FUNC_FSEEKO],[
2000 if test "$enable_largefile" != no ; then
2003 # Normally we would collect these definitions in the config.h,
2004 # but (like _XOPEN_SOURCE), some environments rely on having these
2005 # defined before any of the system headers are included. Another
2006 # case comes up with C++, e.g., on AIX the compiler compiles the
2007 # header files by themselves before looking at the body files it is
2008 # told to compile. For ncurses, those header files do not include
2010 if test "$ac_cv_sys_large_files" != no
2012 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES)
2014 if test "$ac_cv_sys_largefile_source" != no
2016 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE)
2018 if test "$ac_cv_sys_file_offset_bits" != no
2020 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits)
2023 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[
2025 #pragma GCC diagnostic error "-Wincompatible-pointer-types"
2026 #include <sys/types.h>
2029 /* if transitional largefile support is setup, this is true */
2030 extern struct dirent64 * readdir(DIR *);
2031 struct dirent64 *x = readdir((DIR *)0);
2032 struct dirent *y = readdir((DIR *)0);
2036 [cf_cv_struct_dirent64=yes],
2037 [cf_cv_struct_dirent64=no])
2039 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64])
2043 dnl ---------------------------------------------------------------------------
2044 dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35
2046 dnl For the given system and compiler, find the compiler flags to pass to the
2047 dnl loader to use the "rpath" feature.
2048 AC_DEFUN([CF_LD_RPATH_OPT],
2050 AC_REQUIRE([CF_CHECK_CACHE])
2053 if test "x$cf_cv_enable_rpath" != xno
2055 AC_MSG_CHECKING(for an rpath option)
2056 case $cf_cv_system_name in
2058 if test "$GCC" = yes; then
2059 LD_RPATH_OPT="-Wl,-rpath,"
2061 LD_RPATH_OPT="-rpath "
2064 (linux*|gnu*|k*bsd*-gnu|freebsd*)
2065 LD_RPATH_OPT="-Wl,-rpath,"
2067 (openbsd[[2-9]].*|mirbsd*)
2068 LD_RPATH_OPT="-Wl,-rpath,"
2071 LD_RPATH_OPT="-rpath "
2074 LD_RPATH_OPT="-Wl,-rpath,"
2077 LD_RPATH_OPT="-rpath "
2085 AC_MSG_RESULT($LD_RPATH_OPT)
2087 case "x$LD_RPATH_OPT" in
2089 AC_MSG_CHECKING(if we need a space after rpath option)
2090 cf_save_LIBS="$LIBS"
2091 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir)
2092 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes)
2093 LIBS="$cf_save_LIBS"
2094 AC_MSG_RESULT($cf_rpath_space)
2095 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT "
2100 dnl ---------------------------------------------------------------------------
2101 dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48
2103 dnl Construct a search-list of directories for a nonstandard library-file
2106 dnl $1 = the variable to return as result
2107 dnl $2 = the package name
2108 AC_DEFUN([CF_LIBRARY_PATH],
2111 cf_library_path_list=""
2112 if test -n "${LDFLAGS}${LIBS}" ; then
2113 for cf_library_path in $LDFLAGS $LIBS
2115 case $cf_library_path in
2117 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'`
2118 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE)
2119 cf_library_path_list="$cf_library_path_list [$]$1"
2125 CF_SUBDIR_PATH($1,$2,lib)
2127 $1="$cf_library_path_list [$]$1"
2129 dnl ---------------------------------------------------------------------------
2130 dnl CF_LIB_PREFIX version: 13 updated: 2020/04/04 10:11:47
2132 dnl Compute the library-prefix for the given host system
2133 dnl $1 = variable to set
2134 define([CF_LIB_PREFIX],
2136 case $cf_cv_system_name in
2138 if test "$DFT_LWR_MODEL" = libtool; then
2147 (*) LIB_PREFIX='lib'
2150 ifelse($1,,,[$1=$LIB_PREFIX])
2151 AC_SUBST(LIB_PREFIX)
2153 dnl ---------------------------------------------------------------------------
2154 dnl CF_LIB_SUFFIX version: 26 updated: 2020/04/04 10:11:47
2156 dnl Compute the library file-suffix from the given model name
2158 dnl $2 = variable to set (the nominal library suffix)
2159 dnl $3 = dependency variable to set (actual filename)
2160 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2161 AC_DEFUN([CF_LIB_SUFFIX],
2169 case $cf_cv_system_name in
2180 case $cf_cv_system_name in
2191 case $cf_cv_system_name in
2200 (cygwin*|msys*|mingw*)
2238 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}"
2240 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}"
2241 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}"
2244 dnl ---------------------------------------------------------------------------
2245 dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04
2247 dnl Compute the string to append to -library from the given model name
2249 dnl $2 = variable to set
2250 dnl The variable $LIB_SUFFIX, if set, prepends the variable to set.
2251 AC_DEFUN([CF_LIB_TYPE],
2257 (profile) $2='_p' ;;
2260 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}"
2262 dnl ---------------------------------------------------------------------------
2263 dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30
2264 dnl ----------------
2265 dnl Some systems have a non-ANSI linker that doesn't pull in modules that have
2266 dnl only data (i.e., no functions), for example NeXT. On those systems we'll
2267 dnl have to provide wrappers for global tables to ensure they're linked
2269 AC_DEFUN([CF_LINK_DATAONLY],
2271 AC_MSG_CHECKING([if data-only library module links])
2272 AC_CACHE_VAL(cf_cv_link_dataonly,[
2274 cat >conftest.$ac_ext <<EOF
2275 #line __oline__ "configure"
2276 int testdata[[3]] = { 123, 456, 789 };
2278 if AC_TRY_EVAL(ac_compile) ; then
2279 mv conftest.o data.o && \
2280 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null
2282 rm -f conftest.$ac_ext data.o
2283 cat >conftest.$ac_ext <<EOF
2284 #line __oline__ "configure"
2288 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */
2290 extern int testdata[[3]];
2291 return testdata[[0]] == 123
2292 && testdata[[1]] == 456
2293 && testdata[[2]] == 789;
2297 if AC_TRY_EVAL(ac_compile); then
2298 mv conftest.o func.o && \
2299 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null
2301 rm -f conftest.$ac_ext func.o
2302 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null
2304 LIBS="conftest.a $LIBS"
2308 extern int testfunc();
2309 ${cf_cv_main_return:-return} (!testfunc());
2312 [cf_cv_link_dataonly=yes],
2313 [cf_cv_link_dataonly=no],
2314 [cf_cv_link_dataonly=unknown])
2317 AC_MSG_RESULT($cf_cv_link_dataonly)
2319 if test "$cf_cv_link_dataonly" = no ; then
2320 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link])
2323 AC_SUBST(BROKEN_LINKER)
2326 dnl ---------------------------------------------------------------------------
2327 dnl CF_MAKEFLAGS version: 18 updated: 2018/02/21 21:26:03
2329 dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make'
2330 dnl options to lower-levels. It's very useful for "make -n" -- if we have it.
2331 dnl (GNU 'make' does both, something POSIX 'make', which happens to make the
2332 dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-)
2333 AC_DEFUN([CF_MAKEFLAGS],
2335 AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[
2337 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}'
2339 cat >cf_makeflags.tmp <<CF_EOF
2342 @ echo '.$cf_option'
2344 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'`
2345 case "$cf_result" in
2347 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`
2348 case "$cf_result" in
2349 (.*CC=*) cf_cv_makeflags=
2351 (*) cf_cv_makeflags=$cf_option
2359 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\")
2363 rm -f cf_makeflags.tmp
2366 AC_SUBST(cf_cv_makeflags)
2368 dnl ---------------------------------------------------------------------------
2369 dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32
2371 dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have
2372 dnl a monocase filesystem.
2373 AC_DEFUN([CF_MAKE_TAGS],[
2374 AC_REQUIRE([CF_MIXEDCASE_FILENAMES])
2376 AC_CHECK_PROGS(CTAGS, exctags ctags)
2377 AC_CHECK_PROGS(ETAGS, exetags etags)
2379 AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no)
2381 if test "$cf_cv_mixedcase" = yes ; then
2382 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no)
2387 if test "$MAKE_UPPER_TAGS" = yes ; then
2393 if test "$MAKE_LOWER_TAGS" = yes ; then
2402 AC_SUBST(MAKE_UPPER_TAGS)
2403 AC_SUBST(MAKE_LOWER_TAGS)
2405 dnl ---------------------------------------------------------------------------
2406 dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00
2407 dnl ----------------------
2408 dnl Check if the file-system supports mixed-case filenames. If we're able to
2409 dnl create a lowercase name and see it as uppercase, it doesn't support that.
2410 AC_DEFUN([CF_MIXEDCASE_FILENAMES],
2412 AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[
2413 if test "$cross_compiling" = yes ; then
2414 case $target_alias in
2415 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*)
2423 rm -f conftest CONFTEST
2425 if test -f CONFTEST ; then
2430 rm -f conftest CONFTEST
2433 test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.])
2435 dnl ---------------------------------------------------------------------------
2436 dnl CF_MKSTEMP version: 10 updated: 2017/01/21 11:12:16
2438 dnl Check for a working mkstemp. This creates two files, checks that they are
2439 dnl successfully created and distinct (AmigaOS apparently fails on the last).
2440 AC_DEFUN([CF_MKSTEMP],[
2444 AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[
2447 #include <sys/types.h>
2448 #ifdef HAVE_UNISTD_H
2454 #include <sys/stat.h>
2457 char *tmpl = "conftestXXXXXX";
2465 for (n = 0; n < 2; ++n) {
2466 strcpy(name[n], tmpl);
2467 if ((fd = mkstemp(name[n])) >= 0) {
2468 if (!strcmp(name[n], tmpl)
2469 || stat(name[n], &sb) != 0
2470 || (sb.st_mode & S_IFMT) != S_IFREG
2471 || (sb.st_mode & 077) != 0) {
2478 && !strcmp(name[0], name[1]))
2480 ${cf_cv_main_return:-return}(result);
2482 ],[cf_cv_func_mkstemp=yes
2483 ],[cf_cv_func_mkstemp=no
2484 ],[cf_cv_func_mkstemp=maybe])
2486 if test "x$cf_cv_func_mkstemp" = xmaybe ; then
2487 AC_CHECK_FUNC(mkstemp)
2489 if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then
2490 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.])
2493 dnl ---------------------------------------------------------------------------
2494 dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32
2496 dnl Write a debug message to config.log, along with the line number in the
2497 dnl configure script.
2498 AC_DEFUN([CF_MSG_LOG],[
2499 echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC
2501 dnl ---------------------------------------------------------------------------
2502 dnl CF_NCURSES_ADDON version: 5 updated: 2015/04/26 18:06:58
2503 dnl ----------------
2504 dnl Configure an ncurses add-on, built outside the ncurses tree.
2505 AC_DEFUN([CF_NCURSES_ADDON],[
2506 AC_REQUIRE([CF_NCURSES_CONFIG])
2508 AC_PROVIDE([CF_SUBST_NCURSES_VERSION])
2510 AC_MSG_CHECKING(if you want wide-character code)
2511 AC_ARG_ENABLE(widec,
2512 [ --enable-widec compile with wide-char/UTF-8 code],
2513 [with_widec=$enableval],
2515 AC_MSG_RESULT($with_widec)
2516 if test "$with_widec" = yes ; then
2518 CF_NCURSES_CONFIG(ncursesw)
2520 CF_NCURSES_CONFIG(ncurses)
2523 if test "$NCURSES_CONFIG_PKG" != none ; then
2524 cf_version=`$PKG_CONFIG --modversion $NCURSES_CONFIG_PKG 2>/dev/null`
2526 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2527 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2528 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2530 cf_cv_abi_version=`$PKG_CONFIG --variable=abi_version $NCURSES_CONFIG_PKG 2>/dev/null`
2531 if test -z "$cf_cv_abi_version"
2533 cf_cv_abi_version=`$PKG_CONFIG --variable=major_version $NCURSES_CONFIG_PKG 2>/dev/null`
2536 elif test "$NCURSES_CONFIG" != none ; then
2538 cf_version=`$NCURSES_CONFIG --version 2>/dev/null`
2540 NCURSES_MAJOR=`echo "$cf_version" | sed -e 's/\..*//'`
2541 NCURSES_MINOR=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.//' -e 's/\..*//'`
2542 NCURSES_PATCH=`echo "$cf_version" | sed -e 's/^[[0-9]][[0-9]]*\.[[0-9]][[0-9]]*\.//'`
2544 # ABI version is not available from headers
2545 cf_cv_abi_version=`$NCURSES_CONFIG --abi-version 2>/dev/null`
2549 for cf_name in MAJOR MINOR PATCH
2551 cat >conftest.$ac_ext <<CF_EOF
2552 #include <${cf_cv_ncurses_header:-curses.h}>
2553 AUTOCONF_$cf_name NCURSES_VERSION_$cf_name
2555 cf_try="$ac_cpp conftest.$ac_ext 2>&5 | fgrep AUTOCONF_$cf_name >conftest.out"
2557 if test -f conftest.out ; then
2558 cf_result=`cat conftest.out | sed -e "s/^.*AUTOCONF_$cf_name[[ ]][[ ]]*//"`
2559 eval NCURSES_$cf_name=\"$cf_result\"
2560 # cat conftest.$ac_ext
2565 cf_cv_abi_version=${NCURSES_MAJOR}
2569 cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR}
2571 dnl Show the computed version, for logging
2572 cf_cv_timestamp=`date`
2574 AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp))
2576 dnl We need these values in the generated headers
2577 AC_SUBST(NCURSES_MAJOR)
2578 AC_SUBST(NCURSES_MINOR)
2579 AC_SUBST(NCURSES_PATCH)
2581 dnl We need these values in the generated makefiles
2582 AC_SUBST(cf_cv_rel_version)
2583 AC_SUBST(cf_cv_abi_version)
2585 dnl FIXME - not needed for Ada95
2586 AC_SUBST(cf_cv_builtin_bool)
2587 AC_SUBST(cf_cv_header_stdbool_h)
2588 AC_SUBST(cf_cv_type_of_bool)dnl
2591 dnl ---------------------------------------------------------------------------
2592 dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05
2593 dnl -------------------
2594 dnl Check if we can compile with ncurses' header file
2595 dnl $1 is the cache variable to set
2596 dnl $2 is the header-file to include
2597 dnl $3 is the root name (ncurses or ncursesw)
2598 AC_DEFUN([CF_NCURSES_CC_CHECK],[
2600 ]ifelse($3,ncursesw,[
2601 #define _XOPEN_SOURCE_EXTENDED
2602 #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */
2603 #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */
2606 #ifdef NCURSES_VERSION
2607 ]ifelse($3,ncursesw,[
2612 printf("%s\n", NCURSES_VERSION);
2624 dnl ---------------------------------------------------------------------------
2625 dnl CF_NCURSES_CONFIG version: 23 updated: 2020/02/27 05:21:59
2626 dnl -----------------
2627 dnl Tie together the configure-script macros for ncurses, preferring these in
2629 dnl a) ".pc" files for pkg-config, using $NCURSES_CONFIG_PKG
2630 dnl b) the "-config" script from ncurses, using $NCURSES_CONFIG
2631 dnl c) just plain libraries
2633 dnl $1 is the root library name (default: "ncurses")
2634 AC_DEFUN([CF_NCURSES_CONFIG],[
2635 AC_REQUIRE([CF_PKG_CONFIG])
2636 cf_ncuconfig_root=ifelse($1,,ncurses,$1)
2637 cf_have_ncuconfig=no
2639 if test "x${PKG_CONFIG:=none}" != xnone; then
2640 AC_MSG_CHECKING(pkg-config for $cf_ncuconfig_root)
2641 if "$PKG_CONFIG" --exists $cf_ncuconfig_root ; then
2644 AC_MSG_CHECKING(if the $cf_ncuconfig_root package files work)
2645 cf_have_ncuconfig=unknown
2647 cf_save_CFLAGS="$CFLAGS"
2648 cf_save_CPPFLAGS="$CPPFLAGS"
2649 cf_save_LIBS="$LIBS"
2651 cf_pkg_cflags=`$PKG_CONFIG --cflags $cf_ncuconfig_root`
2652 cf_pkg_libs=`$PKG_CONFIG --libs $cf_ncuconfig_root`
2654 # while -W for passing linker flags is prevalent, it is not "standard".
2655 # At least one wrapper for c89/c99 (in Apple's xcode) has its own
2656 # incompatible _and_ non-standard -W option which gives an error. Work
2657 # around that pitfall.
2658 case "x${CC}@@${cf_pkg_libs}@${cf_pkg_cflags}" in
2660 CF_ADD_CFLAGS($cf_pkg_cflags)
2661 CF_ADD_LIBS($cf_pkg_libs)
2663 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2664 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2665 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2667 { char *xx = curses_version(); return (xx == 0); }],
2668 [cf_test_ncuconfig=yes],
2669 [cf_test_ncuconfig=no],
2670 [cf_test_ncuconfig=maybe])],
2671 [cf_test_ncuconfig=no])
2673 CFLAGS="$cf_save_CFLAGS"
2674 CPPFLAGS="$cf_save_CPPFLAGS"
2675 LIBS="$cf_save_LIBS"
2677 if test "x$cf_test_ncuconfig" != xyes; then
2678 cf_temp=`echo "x$cf_pkg_cflags" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2679 cf_pkg_cflags="$cf_temp"
2680 cf_temp=`echo "x$cf_pkg_libs" | sed -e s/^x// -e 's/-W[[^ ]]*//g'`
2681 cf_pkg_libs="$cf_temp"
2686 CF_ADD_CFLAGS($cf_pkg_cflags)
2687 CF_ADD_LIBS($cf_pkg_libs)
2689 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2690 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2691 [AC_TRY_RUN([#include <${cf_cv_ncurses_header:-curses.h}>
2693 { char *xx = curses_version(); return (xx == 0); }],
2694 [cf_have_ncuconfig=yes],
2695 [cf_have_ncuconfig=no],
2696 [cf_have_ncuconfig=maybe])],
2697 [cf_have_ncuconfig=no])
2698 AC_MSG_RESULT($cf_have_ncuconfig)
2699 test "$cf_have_ncuconfig" = maybe && cf_have_ncuconfig=yes
2700 if test "$cf_have_ncuconfig" != "yes"
2702 CPPFLAGS="$cf_save_CPPFLAGS"
2703 LIBS="$cf_save_LIBS"
2704 NCURSES_CONFIG_PKG=none
2706 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2707 NCURSES_CONFIG_PKG=$cf_ncuconfig_root
2713 NCURSES_CONFIG_PKG=none
2716 NCURSES_CONFIG_PKG=none
2719 if test "x$cf_have_ncuconfig" = "xno"; then
2720 cf_ncurses_config="${cf_ncuconfig_root}${NCURSES_CONFIG_SUFFIX}-config"; echo "Looking for ${cf_ncurses_config}"
2722 CF_ACVERSION_CHECK(2.52,
2723 [AC_CHECK_TOOLS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)],
2724 [AC_PATH_PROGS(NCURSES_CONFIG, ${cf_ncurses_config} ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config, none)])
2726 if test "$NCURSES_CONFIG" != none ; then
2728 CF_ADD_CFLAGS(`$NCURSES_CONFIG --cflags`)
2729 CF_ADD_LIBS(`$NCURSES_CONFIG --libs`)
2731 # even with config script, some packages use no-override for curses.h
2732 CF_CURSES_HEADER(ifelse($1,,ncurses,$1))
2734 dnl like CF_NCURSES_CPPFLAGS
2735 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2737 dnl like CF_NCURSES_LIBS
2738 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root)
2739 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2741 dnl like CF_NCURSES_VERSION
2742 cf_cv_ncurses_version=`$NCURSES_CONFIG --version`
2746 CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1))
2747 CF_NCURSES_LIBS(ifelse($1,,ncurses,$1))
2754 dnl ---------------------------------------------------------------------------
2755 dnl CF_NCURSES_CPPFLAGS version: 21 updated: 2012/10/06 08:57:51
2756 dnl -------------------
2757 dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting
2758 dnl the CPPFLAGS variable so we can include its header.
2760 dnl The header files may be installed as either curses.h, or ncurses.h (would
2761 dnl be obsolete, except that some packagers prefer this name to distinguish it
2762 dnl from a "native" curses implementation). If not installed for overwrite,
2763 dnl the curses.h file would be in an ncurses subdirectory (e.g.,
2764 dnl /usr/include/ncurses), but someone may have installed overwriting the
2765 dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd
2766 dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in
2769 dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header
2770 dnl is already in the include-path, don't even bother with this, since we cannot
2771 dnl easily determine which file it is. In this case, it has to be <curses.h>.
2773 dnl The optional parameter gives the root name of the library, in case it is
2774 dnl not installed as the default curses library. That is how the
2775 dnl wide-character version of ncurses is installed.
2776 AC_DEFUN([CF_NCURSES_CPPFLAGS],
2777 [AC_REQUIRE([CF_WITH_CURSES_DIR])
2779 AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl
2780 cf_ncuhdr_root=ifelse($1,,ncurses,$1)
2782 test -n "$cf_cv_curses_dir" && \
2783 test "$cf_cv_curses_dir" != "no" && { \
2784 CF_ADD_INCDIR($cf_cv_curses_dir/include/$cf_ncuhdr_root)
2787 AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[
2788 cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h"
2789 ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h"
2790 for cf_header in $cf_header_list
2792 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1)
2793 test "$cf_cv_ncurses_h" != no && break
2800 # some applications need this, but should check for NCURSES_VERSION
2801 AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
2805 dnl ---------------------------------------------------------------------------
2806 dnl CF_NCURSES_HEADER version: 4 updated: 2015/04/15 19:08:48
2807 dnl -----------------
2808 dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common
2809 dnl variations of ncurses' installs.
2811 dnl See also CF_CURSES_HEADER, which sets the same cache variable.
2812 AC_DEFUN([CF_NCURSES_HEADER],[
2814 if test "$cf_cv_ncurses_h" != no ; then
2815 cf_cv_ncurses_header=$cf_cv_ncurses_h
2818 AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[
2819 test -n "$verbose" && echo
2820 CF_HEADER_PATH(cf_search,$cf_ncuhdr_root)
2821 test -n "$verbose" && echo search path $cf_search
2822 cf_save2_CPPFLAGS="$CPPFLAGS"
2823 for cf_incdir in $cf_search
2825 CF_ADD_INCDIR($cf_incdir)
2830 CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1)
2831 if test "$cf_cv_ncurses_h2" != no ; then
2832 cf_cv_ncurses_h2=$cf_incdir/$cf_header
2833 test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG
2836 test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG
2838 CPPFLAGS="$cf_save2_CPPFLAGS"
2839 test "$cf_cv_ncurses_h2" != no && break
2841 test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found)
2844 CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2)
2845 cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2`
2846 if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then
2847 cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header
2849 CF_ADD_INCDIR($cf_1st_incdir)
2853 # Set definitions to allow ifdef'ing for ncurses.h
2855 case $cf_cv_ncurses_header in
2857 AC_DEFINE(HAVE_NCURSES_H,1,[Define to 1 if we have ncurses.h])
2861 case $cf_cv_ncurses_header in
2862 (ncurses/curses.h|ncurses/ncurses.h)
2863 AC_DEFINE(HAVE_NCURSES_NCURSES_H,1,[Define to 1 if we have ncurses/ncurses.h])
2865 (ncursesw/curses.h|ncursesw/ncurses.h)
2866 AC_DEFINE(HAVE_NCURSESW_NCURSES_H,1,[Define to 1 if we have ncursesw/ncurses.h])
2871 dnl ---------------------------------------------------------------------------
2872 dnl CF_NCURSES_LIBS version: 17 updated: 2015/04/15 19:08:48
2874 dnl Look for the ncurses library. This is a little complicated on Linux,
2875 dnl because it may be linked with the gpm (general purpose mouse) library.
2876 dnl Some distributions have gpm linked with (bsd) curses, which makes it
2877 dnl unusable with ncurses. However, we don't want to link with gpm unless
2878 dnl ncurses has a dependency, since gpm is normally set up as a shared library,
2879 dnl and the linker will record a dependency.
2881 dnl The optional parameter gives the root name of the library, in case it is
2882 dnl not installed as the default curses library. That is how the
2883 dnl wide-character version of ncurses is installed.
2884 AC_DEFUN([CF_NCURSES_LIBS],
2885 [AC_REQUIRE([CF_NCURSES_CPPFLAGS])
2887 cf_nculib_root=ifelse($1,,ncurses,$1)
2888 # This works, except for the special case where we find gpm, but
2889 # ncurses is in a nonstandard location via $LIBS, and we really want
2892 cf_ncurses_SAVE="$LIBS"
2893 AC_CHECK_LIB(gpm,Gpm_Open,
2894 [AC_CHECK_LIB(gpm,initscr,
2895 [LIBS="$cf_ncurses_SAVE"],
2896 [cf_ncurses_LIBS="-lgpm"])])
2900 # This is only necessary if you are linking against an obsolete
2901 # version of ncurses (but it should do no harm, since it's static).
2902 if test "$cf_nculib_root" = ncurses ; then
2903 AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"])
2908 CF_ADD_LIBS($cf_ncurses_LIBS)
2910 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
2912 CF_ADD_LIBS(-l$cf_nculib_root)
2914 CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root,
2915 [#include <${cf_cv_ncurses_header:-curses.h}>],
2920 if test -n "$cf_ncurses_LIBS" ; then
2921 AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS)
2922 cf_ncurses_SAVE="$LIBS"
2923 for p in $cf_ncurses_LIBS ; do
2924 q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"`
2925 if test "$q" != "$LIBS" ; then
2929 AC_TRY_LINK([#include <${cf_cv_ncurses_header:-curses.h}>],
2930 [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);],
2931 [AC_MSG_RESULT(yes)],
2933 LIBS="$cf_ncurses_SAVE"])
2936 CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root)
2937 AC_DEFINE_UNQUOTED($cf_nculib_ROOT)
2939 dnl ---------------------------------------------------------------------------
2940 dnl CF_NCURSES_VERSION version: 15 updated: 2017/05/09 19:26:10
2941 dnl ------------------
2942 dnl Check for the version of ncurses, to aid in reporting bugs, etc.
2943 dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use
2944 dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi.
2945 AC_DEFUN([CF_NCURSES_VERSION],
2947 AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl
2948 AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[
2949 cf_cv_ncurses_version=no
2953 #include <${cf_cv_ncurses_header:-curses.h}>
2957 FILE *fp = fopen("$cf_tempfile", "w");
2958 #ifdef NCURSES_VERSION
2959 # ifdef NCURSES_VERSION_PATCH
2960 fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH);
2962 fprintf(fp, "%s\n", NCURSES_VERSION);
2966 fprintf(fp, "old\n");
2971 ${cf_cv_main_return:-return}(0);
2973 cf_cv_ncurses_version=`cat $cf_tempfile`],,[
2975 # This will not work if the preprocessor splits the line after the
2976 # Autoconf token. The 'unproto' program does that.
2977 cat > conftest.$ac_ext <<EOF
2978 #include <${cf_cv_ncurses_header:-curses.h}>
2980 #ifdef NCURSES_VERSION
2981 Autoconf NCURSES_VERSION
2989 cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out"
2991 if test -f conftest.out ; then
2992 cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'`
2993 test -n "$cf_out" && cf_cv_ncurses_version="$cf_out"
2999 test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES,1,[Define to 1 if we are using ncurses headers/libraries])
3001 dnl ---------------------------------------------------------------------------
3002 dnl CF_OBJ_SUBDIR version: 7 updated: 2015/04/17 21:13:04
3004 dnl Compute the object-directory name from the given model name
3005 AC_DEFUN([CF_OBJ_SUBDIR],
3008 (libtool) $2='obj_lo' ;;
3009 (normal) $2='objects' ;;
3010 (debug) $2='obj_g' ;;
3011 (profile) $2='obj_p' ;;
3013 case $cf_cv_system_name in
3021 dnl ---------------------------------------------------------------------------
3022 dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00
3024 dnl Provide a value for the $PATH and similar separator (or amend the value
3025 dnl as provided in autoconf 2.5x).
3026 AC_DEFUN([CF_PATHSEP],
3028 AC_MSG_CHECKING(for PATH separator)
3029 case $cf_cv_system_name in
3030 (os2*) PATH_SEPARATOR=';' ;;
3031 (*) ${PATH_SEPARATOR:=':'} ;;
3033 ifelse([$1],,,[$1=$PATH_SEPARATOR])
3034 AC_SUBST(PATH_SEPARATOR)
3035 AC_MSG_RESULT($PATH_SEPARATOR)
3037 dnl ---------------------------------------------------------------------------
3038 dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57
3040 dnl Check the argument to see that it looks like a pathname. Rewrite it if it
3041 dnl begins with one of the prefix/exec_prefix variables, and then again if the
3042 dnl result begins with 'NONE'. This is necessary to work around autoconf's
3043 dnl delayed evaluation of those symbols.
3044 AC_DEFUN([CF_PATH_SYNTAX],[
3045 if test "x$prefix" != xNONE; then
3046 cf_path_syntax="$prefix"
3048 cf_path_syntax="$ac_default_prefix"
3052 (.\[$]\(*\)*|.\'*\'*)
3056 (.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX
3058 (.\[$]{*prefix}*|.\[$]{*dir}*)
3062 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3067 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%`
3070 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2)
3074 dnl ---------------------------------------------------------------------------
3075 dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58
3077 dnl Check for the package-config program, unless disabled by command-line.
3078 AC_DEFUN([CF_PKG_CONFIG],
3080 AC_MSG_CHECKING(if you want to use pkg-config)
3081 AC_ARG_WITH(pkg-config,
3082 [ --with-pkg-config{=path} enable/disable use of pkg-config],
3083 [cf_pkg_config=$withval],
3084 [cf_pkg_config=yes])
3085 AC_MSG_RESULT($cf_pkg_config)
3087 case $cf_pkg_config in
3092 CF_ACVERSION_CHECK(2.52,
3093 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)],
3094 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)])
3101 test -z "$PKG_CONFIG" && PKG_CONFIG=none
3102 if test "$PKG_CONFIG" != none ; then
3103 CF_PATH_SYNTAX(PKG_CONFIG)
3104 elif test "x$cf_pkg_config" != xno ; then
3105 AC_MSG_WARN(pkg-config is not installed)
3108 AC_SUBST(PKG_CONFIG)
3110 dnl ---------------------------------------------------------------------------
3111 dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17
3112 dnl -----------------
3113 dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed.
3115 dnl POSIX.1-1990 _POSIX_SOURCE
3116 dnl POSIX.1-1990 and _POSIX_SOURCE and
3117 dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2
3119 dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L
3120 dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L
3121 dnl X/Open 2000 _POSIX_C_SOURCE=200112L
3124 dnl $1 is the nominal value for _POSIX_C_SOURCE
3125 AC_DEFUN([CF_POSIX_C_SOURCE],
3126 [AC_REQUIRE([CF_POSIX_VISIBLE])dnl
3128 if test "$cf_cv_posix_visible" = no; then
3130 cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1])
3132 cf_save_CFLAGS="$CFLAGS"
3133 cf_save_CPPFLAGS="$CPPFLAGS"
3135 CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE)
3136 CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE)
3138 AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[
3139 CF_MSG_LOG(if the symbol is already defined go no further)
3140 AC_TRY_COMPILE([#include <sys/types.h>],[
3141 #ifndef _POSIX_C_SOURCE
3144 [cf_cv_posix_c_source=no],
3145 [cf_want_posix_source=no
3146 case .$cf_POSIX_C_SOURCE in
3148 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3151 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE"
3152 cf_want_posix_source=yes
3155 cf_want_posix_source=yes
3158 if test "$cf_want_posix_source" = yes ; then
3159 AC_TRY_COMPILE([#include <sys/types.h>],[
3160 #ifdef _POSIX_SOURCE
3163 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE")
3165 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE)
3166 CFLAGS="$cf_trim_CFLAGS"
3167 CPPFLAGS="$cf_trim_CPPFLAGS"
3168 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source)
3169 CF_MSG_LOG(if the second compile does not leave our definition intact error)
3170 AC_TRY_COMPILE([#include <sys/types.h>],[
3171 #ifndef _POSIX_C_SOURCE
3174 [cf_cv_posix_c_source=no])
3175 CFLAGS="$cf_save_CFLAGS"
3176 CPPFLAGS="$cf_save_CPPFLAGS"
3180 if test "$cf_cv_posix_c_source" != no ; then
3181 CFLAGS="$cf_trim_CFLAGS"
3182 CPPFLAGS="$cf_trim_CPPFLAGS"
3183 CF_ADD_CFLAGS($cf_cv_posix_c_source)
3186 fi # cf_cv_posix_visible
3189 dnl ---------------------------------------------------------------------------
3190 dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17
3191 dnl ----------------
3192 dnl POSIX documents test-macros which an application may set before any system
3193 dnl headers are included to make features available.
3195 dnl Some BSD platforms (originally FreeBSD, but copied by a few others)
3196 dnl diverged from POSIX in 2002 by setting symbols which make all of the most
3197 dnl recent features visible in the system header files unless the application
3198 dnl overrides the corresponding test-macros. Doing that introduces portability
3201 dnl This macro makes a special check for the symbols used for this, to avoid a
3202 dnl conflicting definition.
3203 AC_DEFUN([CF_POSIX_VISIBLE],
3205 AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[
3206 AC_TRY_COMPILE([#include <stdio.h>],[
3207 #if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \
3208 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \
3209 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \
3210 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0)
3211 #error conflicting symbols found
3213 ],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes])
3216 dnl ---------------------------------------------------------------------------
3217 dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22
3219 dnl Check for archiver "ar".
3220 AC_DEFUN([CF_PROG_AR],[
3221 AC_CHECK_TOOL(AR, ar, ar)
3223 dnl ---------------------------------------------------------------------------
3224 dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59
3226 dnl Check for awk, ensure that the check found something.
3227 AC_DEFUN([CF_PROG_AWK],
3230 test -z "$AWK" && AC_MSG_ERROR(No awk program found)
3232 dnl ---------------------------------------------------------------------------
3233 dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54
3235 dnl standard check for CC, plus followup sanity checks
3236 dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name
3237 AC_DEFUN([CF_PROG_CC],[
3238 CF_ACVERSION_CHECK(2.53,
3239 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice)
3240 AC_REQUIRE([AC_PROG_CC])],
3242 ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)])
3244 CF_ACVERSION_CHECK(2.52,
3249 dnl ---------------------------------------------------------------------------
3250 dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25
3252 dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that
3253 dnl the output file can be renamed, and allows for a shell variable that can
3254 dnl be used later. The parameter is either CC or CXX. The result is the
3256 dnl $cf_cv_prog_CC_c_o
3257 dnl $cf_cv_prog_CXX_c_o
3260 dnl $2 = compiler options, if any
3261 AC_DEFUN([CF_PROG_CC_C_O],
3262 [AC_REQUIRE([AC_PROG_CC])dnl
3263 AC_MSG_CHECKING([whether [$]$1 understands -c and -o together])
3264 AC_CACHE_VAL(cf_cv_prog_$1_c_o,
3266 cat > conftest.$ac_ext <<CF_EOF
3269 ${cf_cv_main_return:-return}(0);
3272 # We do the test twice because some compilers refuse to overwrite an
3273 # existing .o file with -o, though they will create one.
3274 ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC'
3275 if AC_TRY_EVAL(ac_try) &&
3276 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try);
3278 eval cf_cv_prog_$1_c_o=yes
3280 eval cf_cv_prog_$1_c_o=no
3284 if test $cf_cv_prog_$1_c_o = yes; then
3285 AC_MSG_RESULT([yes])
3290 dnl ---------------------------------------------------------------------------
3291 dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57
3293 dnl AC_PROG_EGREP was introduced in autoconf 2.53.
3294 dnl This macro adds a check to ensure the script found something.
3295 AC_DEFUN([CF_PROG_EGREP],
3296 [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
3297 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3298 then ac_cv_prog_egrep='grep -E'
3299 else ac_cv_prog_egrep='egrep'
3301 EGREP=$ac_cv_prog_egrep
3303 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found)
3305 dnl ---------------------------------------------------------------------------
3306 dnl CF_PROG_EXT version: 14 updated: 2018/06/20 20:23:13
3308 dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX.
3309 AC_DEFUN([CF_PROG_EXT],
3311 AC_REQUIRE([CF_CHECK_CACHE])
3312 case $cf_cv_system_name in
3314 CFLAGS="$CFLAGS -Zmt"
3315 CF_APPEND_TEXT(CPPFLAGS,-D__ST_MT_ERRNO__)
3316 CXXFLAGS="$CXXFLAGS -Zmt"
3317 # autoconf's macro sets -Zexe and suffix both, which conflict:w
3318 LDFLAGS="$LDFLAGS -Zmt -Zcrtdll"
3328 test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT",[Define to the program extension (normally blank)])
3330 dnl ---------------------------------------------------------------------------
3331 dnl CF_PROG_GNAT version: 10 updated: 2019/12/31 08:53:54
3333 dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete.
3334 AC_DEFUN([CF_PROG_GNAT],[
3335 for cf_prog_gnat in gnat gnatmake gprconfig gprbuild
3337 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat})
3339 unset ac_cv_path_cf_TEMP_gnat
3341 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no)
3342 eval cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat
3344 if test "x$cf_TEMP_gnat" != xno; then
3345 unset cf_cv_gnat_version
3347 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat)
3349 eval cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat
3352 unset cf_cv_gnat_version
3353 unset ac_cv_path_cf_TEMP_gnat
3356 if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then
3358 cf_cv_prog_gnat_correct=no
3360 cf_ada_make=gnatmake
3361 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then
3362 # gprconfig is newer than gnatmake; we can continue...
3365 rm -rf conftest* *~conftest*
3366 if mkdir conftest.src
3370 for cf_gprconfig in Ada C
3372 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig)
3373 if test $cf_gprconfig = C
3375 for cf_gprconfig_param in \
3376 $cf_gprconfig,,,,GNATGCC \
3377 $cf_gprconfig,,,,GCC \
3380 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3381 test -n "$cf_gprconfig_value" && break
3384 cf_gprconfig_param=$cf_gprconfig
3385 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1`
3387 if test -n "$cf_gprconfig_value"
3389 eval cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value
3390 AC_MSG_RESULT($cf_gprconfig_value)
3392 AC_MSG_RESULT(missing)
3398 rm -rf conftest* *~conftest*
3401 if test "x$cf_ada_config" != "x#"
3404 CF_CHECK_GNAT_VERSION
3405 AC_CHECK_PROG(M4_exists, m4, yes, no)
3406 if test "$ac_cv_prog_M4_exists" = no; then
3407 cf_cv_prog_gnat_correct=no
3408 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled)
3410 if test "$cf_cv_prog_gnat_correct" = yes; then
3411 AC_MSG_CHECKING(if GNAT works)
3412 CF_GNAT_TRY_RUN([procedure conftest;],
3415 procedure conftest is
3417 Text_IO.Put ("Hello World");
3419 GNAT.OS_Lib.OS_Exit (0);
3421 [cf_cv_prog_gnat_correct=yes],
3422 [cf_cv_prog_gnat_correct=no])
3423 AC_MSG_RESULT($cf_cv_prog_gnat_correct)
3426 cf_cv_prog_gnat_correct=no
3430 AC_SUBST(cf_ada_make)
3431 AC_SUBST(cf_ada_config)
3432 AC_SUBST(cf_ada_config_Ada)
3433 AC_SUBST(cf_ada_config_C)
3435 dnl ---------------------------------------------------------------------------
3436 dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57
3438 dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the
3439 dnl misc/tabset install won't work properly. Usually this happens only when
3440 dnl using the fallback mkinstalldirs script
3441 AC_DEFUN([CF_PROG_INSTALL],
3447 CF_DIRNAME(cf_dir,$INSTALL)
3448 test -z "$cf_dir" && cf_dir=.
3449 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'`
3453 dnl ---------------------------------------------------------------------------
3454 dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37
3456 dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f"
3457 dnl option if it is supported.
3458 AC_DEFUN([CF_PROG_LN_S],[
3460 AC_MSG_CHECKING(if $LN_S -f options work)
3462 rm -f conf$$.src conf$$dst
3464 echo first >conf$$.src
3465 if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then
3470 rm -f conf$$.dst conf$$src
3471 AC_MSG_RESULT($cf_prog_ln_sf)
3473 test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f"
3475 dnl ---------------------------------------------------------------------------
3476 dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50
3477 dnl ----------------
3478 dnl Remove all -U and -D options that refer to the given symbol from a list
3479 dnl of C compiler options. This works around the problem that not all
3480 dnl compilers process -U and -D options from left-to-right, so a -U option
3481 dnl cannot be used to cancel the effect of a preceding -D option.
3483 dnl $1 = target (which could be the same as the source variable)
3484 dnl $2 = source (including '$')
3485 dnl $3 = symbol to remove
3486 define([CF_REMOVE_DEFINE],
3489 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \
3490 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'`
3492 dnl ---------------------------------------------------------------------------
3493 dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52
3495 dnl Remove the given library from the symbol
3497 dnl $1 = target (which could be the same as the source variable)
3498 dnl $2 = source (including '$')
3499 dnl $3 = library to remove
3500 define([CF_REMOVE_LIB],
3502 # remove $3 library from $2
3503 $1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'`
3505 dnl ---------------------------------------------------------------------------
3506 dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45
3507 dnl ---------------------
3508 dnl Restore flags saved in CF_SAVE_XTRA_FLAGS
3509 dnl $1 = name of current macro
3510 define([CF_RESTORE_XTRA_FLAGS],
3512 LIBS="$cf_save_LIBS_$1"
3513 CFLAGS="$cf_save_CFLAGS_$1"
3514 CPPFLAGS="$cf_save_CPPFLAGS_$1"
3516 dnl ---------------------------------------------------------------------------
3517 dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44
3518 dnl ------------------
3519 dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers
3520 dnl and libraries which do not update those variables.
3522 dnl $1 = name of current macro
3523 define([CF_SAVE_XTRA_FLAGS],
3525 cf_save_LIBS_$1="$LIBS"
3526 cf_save_CFLAGS_$1="$CFLAGS"
3527 cf_save_CPPFLAGS_$1="$CPPFLAGS"
3528 LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}"
3529 for cf_X_CFLAGS in $X_CFLAGS
3531 case "x$cf_X_CFLAGS" in
3533 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS"
3536 CFLAGS="$CFLAGS $cf_X_CFLAGS"
3541 dnl ---------------------------------------------------------------------------
3542 dnl CF_SHARED_OPTS version: 97 updated: 2020/07/11 19:09:29
3545 dnl Attempt to determine the appropriate CC/LD options for creating a shared
3549 dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within
3550 dnl the build-tree, i.e., by making use of the libraries that are compiled in
3551 dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the
3552 dnl shared library since that can lead to unexpected results at runtime.
3553 dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared
3554 dnl libraries are compiled in ../../lib
3556 dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure
3557 dnl to install symbolic links to the rel/abi versions of shared libraries.
3559 dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi
3560 dnl version when making symbolic links.
3562 dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library
3563 dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix
3564 dnl (ex: libncurses.so.<ver>).
3566 dnl Some loaders leave 'so_locations' lying around. It's nice to clean up.
3567 AC_DEFUN([CF_SHARED_OPTS],
3569 AC_REQUIRE([CF_LD_RPATH_OPT])
3575 INSTALL_LIB="-m 644"
3576 : ${rel_builddir:=.}
3584 cf_cv_do_symlinks=no
3586 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT"
3588 AC_MSG_CHECKING(if release/abi version should be used for shared libs)
3589 AC_ARG_WITH(shlib-version,
3590 [ --with-shlib-version=X Specify rel or abi version for shared libs],
3591 [test -z "$withval" && withval=auto
3594 cf_cv_shlib_version=auto
3597 cf_cv_shlib_version=$withval
3600 AC_MSG_RESULT($withval)
3601 AC_MSG_ERROR([option value must be one of: rel, abi, or auto])
3604 ],[cf_cv_shlib_version=auto])
3605 AC_MSG_RESULT($cf_cv_shlib_version)
3610 # Some less-capable ports of gcc support only -fpic
3614 if test "$GCC" = yes
3618 case $cf_cv_system_name in
3619 (*linux*) # e.g., PGI compiler
3625 if test "$cf_try_fPIC" = yes
3627 AC_MSG_CHECKING(which $CC option to use)
3628 cf_save_CFLAGS="$CFLAGS"
3629 for CC_SHARED_OPTS in -fPIC -fpic ''
3631 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS"
3632 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[])
3634 AC_MSG_RESULT($CC_SHARED_OPTS)
3635 CFLAGS="$cf_save_CFLAGS"
3638 cf_cv_shlib_version_infix=no
3640 case $cf_cv_system_name in
3641 (aix4.[3-9]*|aix[[5-7]]*)
3642 if test "$GCC" = yes; then
3643 CC_SHARED_OPTS='-Wl,-brtl'
3644 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3646 CC_SHARED_OPTS='-brtl'
3647 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall"
3648 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@'
3652 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0'
3656 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3657 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3658 cf_cv_shlib_version=cygdll
3659 cf_cv_shlib_version_infix=cygdll
3662 cat >mk_shared_lib.sh <<-CF_EOF
3665 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3668 Linking shared library
3669 ** SHARED_LIB \[$]SHARED_LIB
3670 ** IMPORT_LIB \[$]IMPORT_LIB
3672 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3674 chmod +x mk_shared_lib.sh
3678 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3679 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3680 cf_cv_shlib_version=msysdll
3681 cf_cv_shlib_version_infix=msysdll
3684 cat >mk_shared_lib.sh <<-CF_EOF
3687 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3690 Linking shared library
3691 ** SHARED_LIB \[$]SHARED_LIB
3692 ** IMPORT_LIB \[$]IMPORT_LIB
3694 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3696 chmod +x mk_shared_lib.sh
3699 cf_try_cflags="no-cpp-precomp"
3700 CC_SHARED_OPTS="-dynamic"
3701 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]'
3702 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi
3703 cf_cv_shlib_version_infix=yes
3704 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [
3705 cf_save_LDFLAGS=$LDFLAGS
3706 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3707 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no)
3708 LDFLAGS=$cf_save_LDFLAGS])
3709 if test $cf_cv_ldflags_search_paths_first = yes; then
3710 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
3714 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list
3715 if test "$GCC" != yes; then
3718 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]'
3719 INSTALL_LIB="-m 555"
3722 # (tested with gcc 2.7.2 -- I don't have c89)
3723 if test "$GCC" = yes; then
3724 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}'
3727 LD_SHARED_OPTS='-Wl,+b,${libdir}'
3729 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]'
3730 # HP-UX shared libraries must be executable, and should be
3731 # readonly to exploit a quirk in the memory manager.
3732 INSTALL_LIB="-m 555"
3735 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3736 if test "$cf_cv_shlib_version" = rel; then
3737 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
3739 cf_shared_soname='`basename $[@]`'
3742 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]'
3745 if test "$cf_cv_enable_rpath" = yes ; then
3746 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3748 # tested with IRIX 5.2 and 'cc'.
3749 if test "$GCC" != yes; then
3750 CC_SHARED_OPTS='-KPIC'
3751 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]'
3753 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]'
3755 cf_cv_rm_so_locs=yes
3757 (linux*|gnu*|k*bsd*-gnu)
3758 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3759 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3760 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3762 if test "$cf_cv_enable_rpath" = yes ; then
3763 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3766 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3769 cf_cv_shlib_version=msvcdll
3770 cf_cv_shlib_version_infix=msvcdll
3773 if test "$DFT_LWR_MODEL" = "shared" ; then
3774 LOCAL_LDFLAGS="-link -dll"
3775 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3776 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS"
3779 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}'
3780 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib"
3781 cat >mk_shared_lib.sh <<-CF_EOF
3784 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\`
3789 Linking shared library
3790 ** SHARED LIB \$SHARED_LIB
3791 ** IMPORT_LIB \$IMPORT_LIB
3793 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g")
3794 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args
3795 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}"
3797 chmod +x mk_shared_lib.sh
3798 cat >mk_prog.sh <<-CF_EOF
3801 # Ignore first argument (compiler) and use LD (link.exe) unconditionally
3804 ldopts=("/subsystem:console")
3807 while test \[$]# -gt 0; do
3810 # ignore -link argument
3825 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`")
3828 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`")
3834 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do
3835 ldopts+=("\[$]{linkarg}")
3843 ldopts+=("-out:\[$]1")
3852 if [[ "\$isdll" -ne 0 ]]; then
3853 for lib in \[$]{libs[[*]]}; do
3854 ldopts+=("\[$]lib.dll.lib")
3857 for lib in \[$]{libs[[*]]}; do
3858 ldopts+=("\[$]lib.lib")
3863 ** ld options: "\[$]{ldopts[[@]]}"
3865 exec \[$]LD \[$]{ldopts[[@]]}
3868 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh"
3871 cf_cv_shlib_version=mingw
3872 cf_cv_shlib_version_infix=mingw
3875 if test "$DFT_LWR_MODEL" = "shared" ; then
3876 LOCAL_LDFLAGS="-Wl,--enable-auto-import"
3877 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3878 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS"
3881 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}'
3882 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a"
3883 cat >mk_shared_lib.sh <<-CF_EOF
3886 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\`
3889 Linking shared library
3890 ** SHARED_LIB \[$]SHARED_LIB
3891 ** IMPORT_LIB \[$]IMPORT_LIB
3893 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB}
3895 chmod +x mk_shared_lib.sh
3897 (openbsd[[2-9]].*|mirbsd*)
3898 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3899 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3900 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3902 if test "$cf_cv_enable_rpath" = yes ; then
3903 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3905 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3907 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3909 (nto-qnx*|openbsd*|freebsd[[12]].*)
3910 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3911 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]'
3912 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3914 (dragonfly*|freebsd*)
3915 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3916 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
3917 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
3918 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS"
3919 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3922 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]'
3925 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC"
3926 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then
3927 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)"
3928 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3929 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS"
3930 if test "$cf_cv_shlib_version" = auto; then
3931 if test -f /usr/libexec/ld.elf_so; then
3932 cf_cv_shlib_version=abi
3934 cf_cv_shlib_version=rel
3938 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]'
3940 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -Wl,-shared -Wl,-Bshareable -o $[@]'
3944 # tested with OSF/1 V3.2 and 'cc'
3945 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't
3946 # link with shared libs).
3947 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`'
3950 MK_SHARED_LIB="${MK_SHARED_LIB} -msym"
3953 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]'
3954 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then
3955 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)"
3956 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3958 cf_cv_rm_so_locs=yes
3960 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98
3961 # tested with osr5.0.5
3962 if test "$GCC" != yes; then
3963 CC_SHARED_OPTS='-belf -KPIC'
3965 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@'
3966 if test "$cf_cv_enable_rpath" = yes ; then
3967 # only way is to set LD_RUN_PATH but no switch for it
3970 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3971 LINK_PROGS='LD_RUN_PATH=${libdir}'
3972 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib'
3975 # tested with SunOS 4.1.1 and gcc 2.7.0
3976 if test "$GCC" != yes; then
3977 CC_SHARED_OPTS='-KPIC'
3979 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]'
3980 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel
3983 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2
3984 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3
3985 if test "$DFT_LWR_MODEL" = "shared" ; then
3986 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}"
3987 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS"
3989 if test "$cf_cv_enable_rpath" = yes ; then
3990 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS"
3993 if test "$GCC" != yes; then
3994 cf_save_CFLAGS="$CFLAGS"
3995 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O
3997 CFLAGS="$cf_shared_opts $cf_save_CFLAGS"
3998 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break])
4000 CFLAGS="$cf_save_CFLAGS"
4001 CC_SHARED_OPTS=$cf_shared_opts
4002 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4004 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]'
4007 (sysv5uw7*|unix_sv*)
4008 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc)
4009 if test "$GCC" != yes; then
4010 CC_SHARED_OPTS='-KPIC'
4012 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@'
4015 CC_SHARED_OPTS='unknown'
4016 MK_SHARED_LIB='echo unknown'
4020 # This works if the last tokens in $MK_SHARED_LIB are the -o target.
4021 case "$cf_cv_shlib_version" in
4023 case "$MK_SHARED_LIB" in
4025 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes
4028 AC_MSG_WARN(ignored --with-shlib-version)
4034 if test -n "$cf_try_cflags"
4036 cat > conftest.$ac_ext <<EOF
4037 #line __oline__ "${as_me:-configure}"
4039 int main(int argc, char *argv[[]])
4042 return (argv[[argc-1]] == 0) ;
4045 cf_save_CFLAGS="$CFLAGS"
4046 for cf_opt in $cf_try_cflags
4048 CFLAGS="$cf_save_CFLAGS -$cf_opt"
4049 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works)
4050 if AC_TRY_EVAL(ac_compile); then
4052 cf_save_CFLAGS="$CFLAGS"
4057 CFLAGS="$cf_save_CFLAGS"
4061 # RPATH_LIST is a colon-separated list of directories
4062 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}"
4063 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}"
4065 test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations"
4067 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS)
4068 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB)
4070 AC_SUBST(CC_SHARED_OPTS)
4071 AC_SUBST(LD_RPATH_OPT)
4072 AC_SUBST(LD_SHARED_OPTS)
4073 AC_SUBST(MK_SHARED_LIB)
4074 AC_SUBST(RM_SHARED_OPTS)
4076 AC_SUBST(LINK_PROGS)
4077 AC_SUBST(LINK_TESTS)
4079 AC_SUBST(EXTRA_LDFLAGS)
4080 AC_SUBST(LOCAL_LDFLAGS)
4081 AC_SUBST(LOCAL_LDFLAGS2)
4083 AC_SUBST(INSTALL_LIB)
4084 AC_SUBST(RPATH_LIST)
4086 dnl ---------------------------------------------------------------------------
4087 dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43
4088 dnl ----------------
4089 dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for
4090 dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar)
4093 dnl $1 is the default that should be used for "$cf_cv_shlib_version".
4094 dnl If missing, use "rel".
4095 define([CF_SHARED_SONAME],
4097 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1)
4098 if test "$cf_cv_shlib_version" = rel; then
4099 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}'
4101 cf_cv_shared_soname='`basename $[@]`'
4104 dnl ---------------------------------------------------------------------------
4105 dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52
4107 dnl Remove "-g" option from the compiler options
4108 AC_DEFUN([CF_STRIP_G_OPT],
4109 [$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl
4110 dnl ---------------------------------------------------------------------------
4111 dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06
4113 dnl Construct a search-list for a nonstandard header/lib-file
4114 dnl $1 = the variable to return as result
4115 dnl $2 = the package name
4116 dnl $3 = the subdirectory, e.g., bin, include or lib
4117 AC_DEFUN([CF_SUBDIR_PATH],
4121 CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE)
4123 for cf_subdir_prefix in \
4131 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix)
4134 dnl ---------------------------------------------------------------------------
4135 dnl CF_TERM_HEADER version: 5 updated: 2020/03/19 20:23:48
4137 dnl Look for term.h, which is part of X/Open curses. It defines the interface
4138 dnl to terminfo database. Usually it is in the same include-path as curses.h,
4139 dnl but some packagers change this, breaking various applications.
4140 AC_DEFUN([CF_TERM_HEADER],[
4141 AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[
4142 case ${cf_cv_ncurses_header} in
4143 (*/ncurses.h|*/ncursesw.h)
4144 cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'`
4147 cf_term_header=term.h
4151 for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h"
4153 AC_TRY_COMPILE([#include <stdio.h>
4154 #include <${cf_cv_ncurses_header:-curses.h}>
4156 ],[int x = auto_left_margin; (void)x],[
4157 cf_cv_term_header="$cf_test"],[
4158 cf_cv_term_header=unknown
4160 test "$cf_cv_term_header" != unknown && break
4164 # Set definitions to allow ifdef'ing to accommodate subdirectories
4166 case $cf_cv_term_header in
4168 AC_DEFINE(HAVE_TERM_H,1,[Define to 1 if we have term.h])
4172 case $cf_cv_term_header in
4174 AC_DEFINE(HAVE_NCURSES_TERM_H,1,[Define to 1 if we have ncurses/term.h])
4177 AC_DEFINE(HAVE_NCURSESW_TERM_H,1,[Define to 1 if we have ncursesw/term.h])
4181 dnl ---------------------------------------------------------------------------
4182 dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32
4184 dnl Define a top_builddir symbol, for applications that need an absolute path.
4185 AC_DEFUN([CF_TOP_BUILDDIR],
4187 top_builddir=ifelse($1,,`pwd`,$1)
4188 AC_SUBST(top_builddir)
4190 dnl ---------------------------------------------------------------------------
4191 dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13
4192 dnl -------------------
4193 dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we
4194 dnl can define it successfully.
4195 AC_DEFUN([CF_TRY_XOPEN_SOURCE],[
4196 AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[
4200 #include <sys/types.h>
4202 #ifndef _XOPEN_SOURCE
4205 [cf_cv_xopen_source=no],
4206 [cf_save="$CPPFLAGS"
4207 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE)
4211 #include <sys/types.h>
4213 #ifdef _XOPEN_SOURCE
4216 [cf_cv_xopen_source=no],
4217 [cf_cv_xopen_source=$cf_XOPEN_SOURCE])
4222 if test "$cf_cv_xopen_source" != no ; then
4223 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE)
4224 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE)
4225 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source"
4226 CF_ADD_CFLAGS($cf_temp_xopen_source)
4229 dnl ---------------------------------------------------------------------------
4230 dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59
4232 dnl Make an uppercase version of a variable
4233 dnl $1=uppercase($2)
4234 AC_DEFUN([CF_UPPER],
4236 $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%`
4238 dnl ---------------------------------------------------------------------------
4239 dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51
4241 dnl Check for multibyte support, and if not found, utf8 compatibility library
4242 AC_DEFUN([CF_UTF8_LIB],
4244 AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[
4245 cf_save_LIBS="$LIBS"
4247 #include <stdlib.h>],[putwc(0,0);],
4248 [cf_cv_utf8_lib=yes],
4250 #include <libutf8.h>],[putwc(0,0);],utf8,
4251 [cf_cv_utf8_lib=add-on],
4252 [cf_cv_utf8_lib=no])
4255 # HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between
4257 if test "$cf_cv_utf8_lib" = "add-on" ; then
4258 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h])
4259 CF_ADD_INCDIR($cf_cv_header_path_utf8)
4260 CF_ADD_LIBDIR($cf_cv_library_path_utf8)
4261 CF_ADD_LIBS($cf_cv_library_file_utf8)
4264 dnl ---------------------------------------------------------------------------
4265 dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12
4267 dnl Use AC_VERBOSE w/o the warnings
4268 AC_DEFUN([CF_VERBOSE],
4269 [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG
4272 dnl ---------------------------------------------------------------------------
4273 dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06
4275 dnl Check for compiler-support for weak symbols.
4276 dnl This works with "recent" gcc.
4277 AC_DEFUN([CF_WEAK_SYMBOLS],[
4278 AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[
4281 #include <stdio.h>],
4283 #if defined(__GNUC__)
4284 # if defined __USE_ISOC99
4285 # define _cat_pragma(exp) _Pragma(#exp)
4286 # define _weak_pragma(exp) _cat_pragma(weak name)
4288 # define _weak_pragma(exp)
4290 # define _declare(name) __extension__ extern __typeof__(name) name
4291 # define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak))
4295 ],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no])
4298 dnl ---------------------------------------------------------------------------
4299 dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58
4300 dnl --------------------
4301 dnl Command-line option to specify the Ada95 compiler.
4302 AC_DEFUN([CF_WITH_ADA_COMPILER],[
4303 AC_MSG_CHECKING(for ada-compiler)
4304 AC_ARG_WITH(ada-compiler,
4305 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)],
4306 [cf_ada_compiler=$withval],
4307 [cf_ada_compiler=gnatmake])
4308 AC_SUBST(cf_ada_compiler)
4309 AC_MSG_RESULT($cf_ada_compiler)
4311 dnl ---------------------------------------------------------------------------
4312 dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58
4313 dnl -------------------
4314 dnl Command-line option to specify where Ada includes will install.
4315 AC_DEFUN([CF_WITH_ADA_INCLUDE],[
4316 AC_MSG_CHECKING(for ada-include)
4317 CF_WITH_PATH(ada-include,
4318 [ --with-ada-include=DIR Ada includes are in DIR],
4320 PREFIX/share/ada/adainclude,
4321 [$]prefix/share/ada/adainclude)
4322 AC_SUBST(ADA_INCLUDE)
4323 AC_MSG_RESULT($ADA_INCLUDE)
4325 dnl ---------------------------------------------------------------------------
4326 dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41
4327 dnl -------------------
4328 dnl CF_WITH_ADA_LIBNAME
4329 dnl -------------------
4330 dnl Command-line option to specify how to name the resulting Ada library.
4331 dnl $1 = default value
4332 AC_DEFUN([CF_WITH_ADA_LIBNAME],[
4333 AC_MSG_CHECKING(for ada-libname)
4334 AC_ARG_WITH(ada-libname,
4335 [ --with-ada-libname=XXX override default Ada library-name],
4336 ADA_LIBNAME=[$]withval,
4338 case "x$ADA_LIBNAME" in
4343 AC_SUBST(ADA_LIBNAME)
4344 AC_MSG_RESULT($ADA_LIBNAME)
4346 dnl ---------------------------------------------------------------------------
4347 dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58
4348 dnl -------------------
4349 dnl Command-line option to specify where Ada objects will install.
4350 AC_DEFUN([CF_WITH_ADA_OBJECTS],[
4351 AC_MSG_CHECKING(for ada-objects)
4352 CF_WITH_PATH(ada-objects,
4353 [ --with-ada-objects=DIR Ada objects are in DIR],
4355 PREFIX/lib/ada/adalib,
4356 [$]prefix/lib/ada/adalib)
4357 AC_SUBST(ADA_OBJECTS)
4358 AC_MSG_RESULT($ADA_OBJECTS)
4360 dnl ---------------------------------------------------------------------------
4361 dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35
4362 dnl ---------------------
4363 dnl Command-line option to specify if an Ada95 shared-library should be built,
4364 dnl and optionally what its soname should be.
4365 AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[
4366 AC_REQUIRE([CF_GNAT_PROJECTS])
4367 AC_MSG_CHECKING(if an Ada95 shared-library should be built)
4368 AC_ARG_WITH(ada-sharedlib,
4369 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)],
4370 [with_ada_sharedlib=$withval],
4371 [with_ada_sharedlib=no])
4372 AC_MSG_RESULT($with_ada_sharedlib)
4374 if test "x$with_ada_sharedlib" != xno
4376 if test "x$cf_gnat_projects" != xyes
4378 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported)
4379 with_ada_sharedlib=no
4383 ADA_SHAREDLIB='lib$(LIB_NAME).so.1'
4384 MAKE_ADA_SHAREDLIB="#"
4386 if test "x$with_ada_sharedlib" != xno
4389 if test "x$with_ada_sharedlib" != xyes
4391 ADA_SHAREDLIB="$with_ada_sharedlib"
4395 AC_SUBST(ADA_SHAREDLIB)
4396 AC_SUBST(MAKE_ADA_SHAREDLIB)
4398 dnl ---------------------------------------------------------------------------
4399 dnl CF_WITH_CURSES_DIR version: 3 updated: 2010/11/20 17:02:38
4400 dnl ------------------
4401 dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses
4403 AC_DEFUN([CF_WITH_CURSES_DIR],[
4405 AC_MSG_CHECKING(for specific curses-directory)
4406 AC_ARG_WITH(curses-dir,
4407 [ --with-curses-dir=DIR directory in which (n)curses is installed],
4408 [cf_cv_curses_dir=$withval],
4409 [cf_cv_curses_dir=no])
4410 AC_MSG_RESULT($cf_cv_curses_dir)
4412 if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" )
4414 CF_PATH_SYNTAX(withval)
4415 if test -d "$cf_cv_curses_dir"
4417 CF_ADD_INCDIR($cf_cv_curses_dir/include)
4418 CF_ADD_LIBDIR($cf_cv_curses_dir/lib)
4422 dnl ---------------------------------------------------------------------------
4423 dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10
4424 dnl ------------------
4425 dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no
4426 dnl "lib" prefix, e.g., because it used the dll naming convention.
4428 dnl $1 = variable to set
4429 AC_DEFUN([CF_WITH_LIB_PREFIX],
4431 AC_MSG_CHECKING(if you want to have a library-prefix)
4432 AC_ARG_WITH(lib-prefix,
4433 [ --with-lib-prefix override library-prefix],
4434 [with_lib_prefix=$withval],
4435 [with_lib_prefix=auto])
4436 AC_MSG_RESULT($with_lib_prefix)
4438 if test $with_lib_prefix = auto
4441 elif test $with_lib_prefix = no
4445 LIB_PREFIX=$with_lib_prefix
4448 dnl ---------------------------------------------------------------------------
4449 dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19
4451 dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just
4452 dnl defaulting to yes/no.
4454 dnl $1 = option name
4456 dnl $3 = environment variable to set
4457 dnl $4 = default value, shown in the help-message, must be a constant
4458 dnl $5 = default value, if it's an expression & cannot be in the help-message
4460 AC_DEFUN([CF_WITH_PATH],
4461 [AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),,
4462 ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl
4463 if ifelse([$5],,true,[test -n "$5"]) ; then
4464 CF_PATH_SYNTAX(withval)
4469 dnl ---------------------------------------------------------------------------
4470 dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56
4471 dnl -------------------------
4472 dnl Allow the choice of the pkg-config library directory to be overridden.
4473 AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[
4477 AC_MSG_CHECKING(for pkg-config library directory)
4480 AC_MSG_CHECKING(for $PKG_CONFIG library directory)
4484 PKG_CONFIG_LIBDIR=no
4485 AC_ARG_WITH(pkg-config-libdir,
4486 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files],
4487 [PKG_CONFIG_LIBDIR=$withval],
4488 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes])
4490 case x$PKG_CONFIG_LIBDIR in
4494 # Look for the library directory using the same prefix as the executable
4495 if test "x$PKG_CONFIG" = xnone
4499 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'`
4502 # If you don't like using the default architecture, you have to specify the
4503 # intended library directory and corresponding compiler/linker options.
4505 # This case allows for Debian's 2014-flavor of multiarch, along with the
4506 # most common variations before that point. Some other variants spell the
4507 # directory differently, e.g., "pkg-config", and put it in unusual places.
4508 # pkg-config has always been poorly standardized, which is ironic...
4509 case x`(arch) 2>/dev/null` in
4512 $cf_path/lib/*64-linux-gnu \
4520 $cf_path/lib/*-linux-gnu \
4529 for cf_config in $cf_search_path
4531 CF_VERBOSE(checking $cf_config/pkgconfig)
4532 if test -d $cf_config/pkgconfig
4534 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig
4535 AC_MSG_CHECKING(done)
4544 if test "x$PKG_CONFIG_LIBDIR" != xno ; then
4545 AC_MSG_RESULT($PKG_CONFIG_LIBDIR)
4548 AC_SUBST(PKG_CONFIG_LIBDIR)
4550 dnl ---------------------------------------------------------------------------
4551 dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57
4553 dnl Check for POSIX thread library.
4554 AC_DEFUN([CF_WITH_PTHREAD],
4556 AC_MSG_CHECKING(if you want to link with the pthread library)
4557 AC_ARG_WITH(pthread,
4558 [ --with-pthread use POSIX thread library],
4559 [with_pthread=$withval],
4561 AC_MSG_RESULT($with_pthread)
4563 if test "$with_pthread" != no ; then
4564 AC_CHECK_HEADER(pthread.h,[
4565 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header])
4567 for cf_lib_pthread in pthread c_r
4569 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library)
4570 cf_save_LIBS="$LIBS"
4571 CF_ADD_LIB($cf_lib_pthread)
4573 #include <pthread.h>
4575 int rc = pthread_create(0,0,0,0);
4576 int r2 = pthread_mutexattr_settype(0, 0);
4577 ],[with_pthread=yes],[with_pthread=no])
4578 LIBS="$cf_save_LIBS"
4579 AC_MSG_RESULT($with_pthread)
4580 test "$with_pthread" = yes && break
4583 if test "$with_pthread" = yes ; then
4584 CF_ADD_LIB($cf_lib_pthread)
4585 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library])
4587 AC_MSG_ERROR(Cannot link with pthread library)
4592 dnl ---------------------------------------------------------------------------
4593 dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12
4595 dnl For testing, override the derived host system-type which is used to decide
4596 dnl things such as the linker commands used to build shared libraries. This is
4597 dnl normally chosen automatically based on the type of system which you are
4598 dnl building on. We use it for testing the configure script.
4600 dnl This is different from the --host option: it is used only for testing parts
4601 dnl of the configure script which would not be reachable with --host since that
4602 dnl relies on the build environment being real, rather than mocked up.
4603 AC_DEFUN([CF_WITH_SYSTYPE],[
4604 CF_CHECK_CACHE([AC_CANONICAL_SYSTEM])
4605 AC_ARG_WITH(system-type,
4606 [ --with-system-type=XXX test: override derived host system-type],
4607 [AC_MSG_WARN(overriding system type to $withval)
4608 cf_cv_system_name=$withval
4612 dnl ---------------------------------------------------------------------------
4613 dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17
4615 dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions,
4616 dnl or adapt to the vendor's definitions to get equivalent functionality,
4617 dnl without losing the common non-POSIX features.
4620 dnl $1 is the nominal value for _XOPEN_SOURCE
4621 dnl $2 is the nominal value for _POSIX_C_SOURCE
4622 AC_DEFUN([CF_XOPEN_SOURCE],[
4623 AC_REQUIRE([AC_CANONICAL_HOST])
4624 AC_REQUIRE([CF_POSIX_VISIBLE])
4626 if test "$cf_cv_posix_visible" = no; then
4628 cf_XOPEN_SOURCE=ifelse([$1],,500,[$1])
4629 cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2])
4634 cf_xopen_source="-D_ALL_SOURCE"
4640 cf_xopen_source="-D_APPLE_C_SOURCE"
4643 cf_xopen_source="-D_DARWIN_C_SOURCE"
4646 (freebsd*|dragonfly*|midnightbsd*)
4647 # 5.x headers associate
4648 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L
4649 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L
4650 cf_POSIX_C_SOURCE=200112L
4652 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE"
4655 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500"
4658 cf_xopen_source="-D_HPUX_SOURCE"
4661 cf_xopen_source="-D_SGI_SOURCE"
4664 (linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin)
4665 CF_GNU_SOURCE($cf_XOPEN_SOURCE)
4668 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this...
4671 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types
4673 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4676 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw
4679 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw
4680 cf_xopen_source="-D_BSD_SOURCE"
4684 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw
4687 cf_xopen_source="-D_OSF_SOURCE"
4690 cf_xopen_source="-D_QNX_SOURCE"
4693 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer
4696 cf_xopen_source="-D__EXTENSIONS__"
4697 cf_cv_xopen_source=broken
4699 (sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2)
4705 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE)
4709 if test -n "$cf_xopen_source" ; then
4710 CF_ADD_CFLAGS($cf_xopen_source,true)
4713 dnl In anything but the default case, we may have system-specific setting
4714 dnl which is still not guaranteed to provide all of the entrypoints that
4715 dnl _XOPEN_SOURCE would yield.
4716 if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then
4717 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set)
4718 AC_TRY_COMPILE([#include <stdlib.h>],[
4719 #ifndef _XOPEN_SOURCE
4722 [cf_XOPEN_SOURCE_set=yes],
4723 [cf_XOPEN_SOURCE_set=no])
4724 AC_MSG_RESULT($cf_XOPEN_SOURCE_set)
4725 if test $cf_XOPEN_SOURCE_set = yes
4727 AC_TRY_COMPILE([#include <stdlib.h>],[
4728 #if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE
4731 [cf_XOPEN_SOURCE_set_ok=yes],
4732 [cf_XOPEN_SOURCE_set_ok=no])
4733 if test $cf_XOPEN_SOURCE_set_ok = no
4735 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested)
4741 fi # cf_cv_posix_visible