1dnl*************************************************************************** 2dnl Copyright 2018-2023,2024 Thomas E. Dickey * 3dnl Copyright 1998-2017,2018 Free Software Foundation, Inc. * 4dnl * 5dnl Permission is hereby granted, free of charge, to any person obtaining a * 6dnl copy of this software and associated documentation files (the * 7dnl "Software"), to deal in the Software without restriction, including * 8dnl without limitation the rights to use, copy, modify, merge, publish, * 9dnl distribute, distribute with modifications, sublicense, and/or sell * 10dnl copies of the Software, and to permit persons to whom the Software is * 11dnl furnished to do so, subject to the following conditions: * 12dnl * 13dnl The above copyright notice and this permission notice shall be included * 14dnl in all copies or substantial portions of the Software. * 15dnl * 16dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 17dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 18dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 19dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 20dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 21dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 22dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 23dnl * 24dnl Except as contained in this notice, the name(s) of the above copyright * 25dnl holders shall not be used in advertising or otherwise to promote the * 26dnl sale, use or other dealings in this Software without prior written * 27dnl authorization. * 28dnl*************************************************************************** 29dnl 30dnl Author: Thomas E. Dickey 1995-on 31dnl 32dnl $Id: aclocal.m4,v 1.1069 2024/03/30 22:15:45 tom Exp $ 33dnl Macros used in NCURSES auto-configuration script. 34dnl 35dnl These macros are maintained separately from NCURSES. The copyright on 36dnl this file applies to the aggregation of macros and does not affect use of 37dnl these macros in other applications. 38dnl 39dnl See these pages for additional information: 40dnl https://invisible-island.net/autoconf/ 41dnl https://invisible-island.net/autoconf/my-autoconf.html 42dnl 43dnl --------------------------------------------------------------------------- 44dnl --------------------------------------------------------------------------- 45dnl AM_LANGINFO_CODESET version: 7 updated: 2023/01/11 04:05:23 46dnl ------------------- 47dnl Inserted as requested by gettext 0.10.40 48dnl File from /usr/share/aclocal 49dnl codeset.m4 50dnl ==================== 51dnl serial AM1 52dnl 53dnl From Bruno Haible. 54AC_DEFUN([AM_LANGINFO_CODESET], 55[ 56AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset, 57 [AC_TRY_LINK([ 58$ac_includes_default 59#include <langinfo.h>], 60 [char* cs = nl_langinfo(CODESET); (void)cs], 61 am_cv_langinfo_codeset=yes, 62 am_cv_langinfo_codeset=no) 63 ]) 64 if test "$am_cv_langinfo_codeset" = yes; then 65 AC_DEFINE(HAVE_LANGINFO_CODESET, 1, 66 [Define if you have <langinfo.h> and nl_langinfo(CODESET).]) 67 fi 68])dnl 69dnl --------------------------------------------------------------------------- 70dnl CF_ABI_DEFAULTS version: 5 updated: 2023/10/21 08:54:23 71dnl --------------- 72dnl Provide configure-script defaults for different ncurses ABIs. 73AC_DEFUN([CF_ABI_DEFAULTS],[ 74AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION]) 75 76# ABI 5 defaults: 77cf_dft_ccharw_max=5 78cf_dft_chtype=auto 79cf_dft_ext_colors=no 80cf_dft_ext_const=no 81cf_dft_ext_mouse=no 82cf_dft_ext_putwin=no 83cf_dft_ext_spfuncs=no 84cf_dft_filter_syms=no 85cf_dft_interop=no 86cf_dft_mmask_t=auto 87cf_dft_opaque_curses=no 88cf_dft_ordinate_type=short 89cf_dft_signed_char=no 90cf_dft_tparm_arg=long 91cf_dft_widec=no 92cf_dft_with_lp64=no 93 94# ABI 6 default differences from ABI 5: 95case x$cf_cv_abi_default in 96(x[[6789]]) 97 cf_dft_chtype=uint32_t 98 cf_dft_ext_colors=yes 99 cf_dft_ext_const=yes 100 cf_dft_ext_mouse=yes 101 cf_dft_ext_putwin=yes 102 cf_dft_ext_spfuncs=yes 103 cf_dft_filter_syms=yes 104 cf_dft_interop=yes 105 cf_dft_mmask_t=uint32_t 106 cf_dft_opaque_curses=yes 107 cf_dft_tparm_arg=intptr_t 108 cf_dft_widec=yes 109 cf_dft_with_lp64=yes 110 ;; 111esac 112 113# ABI 7 default differences from ABI 6: 114case x$cf_cv_abi_default in 115(x[[789]]) 116 cf_dft_ccharw_max=6 117 cf_dft_mmask_t=uint64_t 118 cf_dft_ordinate_type=int 119 cf_dft_signed_char=yes 120 # also: remove the wgetch-events feature in ABI 7 121 ;; 122esac 123])dnl 124dnl --------------------------------------------------------------------------- 125dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49 126dnl ------------------ 127dnl Conditionally generate script according to whether we're using a given autoconf. 128dnl 129dnl $1 = version to compare against 130dnl $2 = code to use if AC_ACVERSION is at least as high as $1. 131dnl $3 = code to use if AC_ACVERSION is older than $1. 132define([CF_ACVERSION_CHECK], 133[ 134ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl 135ifdef([m4_version_compare], 136[m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])], 137[CF_ACVERSION_COMPARE( 138AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])), 139AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl 140dnl --------------------------------------------------------------------------- 141dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53 142dnl -------------------- 143dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1, 144dnl MAJOR2, MINOR2, TERNARY2, 145dnl PRINTABLE2, not FOUND, FOUND) 146define([CF_ACVERSION_COMPARE], 147[ifelse(builtin([eval], [$2 < $5]), 1, 148[ifelse([$8], , ,[$8])], 149[ifelse([$9], , ,[$9])])])dnl 150dnl --------------------------------------------------------------------------- 151dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07 152dnl ------------------- 153dnl Construct the list of include-options for the C programs in the Ada95 154dnl binding. 155AC_DEFUN([CF_ADA_INCLUDE_DIRS], 156[ 157ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS" 158if test "$srcdir" != "."; then 159 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS" 160fi 161if test "$GCC" != yes; then 162 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 163elif test "$includedir" != "/usr/include"; then 164 if test "$includedir" = '${prefix}/include' ; then 165 if test x$prefix != x/usr ; then 166 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 167 fi 168 else 169 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 170 fi 171fi 172AC_SUBST(ACPPFLAGS) 173])dnl 174dnl --------------------------------------------------------------------------- 175dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18 176dnl --------------- 177dnl Add to $ADAFLAGS, which is substituted into makefile and scripts. 178AC_DEFUN([CF_ADD_ADAFLAGS],[ 179 ADAFLAGS="$ADAFLAGS $1" 180 AC_SUBST(ADAFLAGS) 181])dnl 182dnl --------------------------------------------------------------------------- 183dnl CF_ADD_CFLAGS version: 15 updated: 2020/12/31 10:54:15 184dnl ------------- 185dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS 186dnl $1 = flags to add 187dnl $2 = if given makes this macro verbose. 188dnl 189dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, 190dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily 191dnl confused by the quotes (which require backslashes to keep them usable). 192AC_DEFUN([CF_ADD_CFLAGS], 193[ 194cf_fix_cppflags=no 195cf_new_cflags= 196cf_new_cppflags= 197cf_new_extra_cppflags= 198 199for cf_add_cflags in $1 200do 201case "$cf_fix_cppflags" in 202(no) 203 case "$cf_add_cflags" in 204 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) 205 case "$cf_add_cflags" in 206 (-D*) 207 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'` 208 209 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \ 210 && test -z "${cf_tst_cflags}" \ 211 && cf_fix_cppflags=yes 212 213 if test "$cf_fix_cppflags" = yes ; then 214 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 215 continue 216 elif test "${cf_tst_cflags}" = "\"'" ; then 217 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 218 continue 219 fi 220 ;; 221 esac 222 case "$CPPFLAGS" in 223 (*$cf_add_cflags) 224 ;; 225 (*) 226 case "$cf_add_cflags" in 227 (-D*) 228 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'` 229 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags) 230 ;; 231 esac 232 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags) 233 ;; 234 esac 235 ;; 236 (*) 237 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags) 238 ;; 239 esac 240 ;; 241(yes) 242 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 243 244 cf_tst_cflags=`echo "${cf_add_cflags}" |sed -e 's/^[[^"]]*"'\''//'` 245 246 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \ 247 && test -z "${cf_tst_cflags}" \ 248 && cf_fix_cppflags=no 249 ;; 250esac 251done 252 253if test -n "$cf_new_cflags" ; then 254 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) 255 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags) 256fi 257 258if test -n "$cf_new_cppflags" ; then 259 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) 260 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags) 261fi 262 263if test -n "$cf_new_extra_cppflags" ; then 264 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)]) 265 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags) 266fi 267 268AC_SUBST(EXTRA_CPPFLAGS) 269 270])dnl 271dnl --------------------------------------------------------------------------- 272dnl CF_ADD_CXXFLAGS version: 1 updated: 2020/04/04 16:16:13 273dnl --------------- 274dnl Copy non-preprocessor flags to $CXXFLAGS, preprocessor flags to $CPPFLAGS 275dnl The second parameter if given makes this macro verbose. 276dnl 277dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, 278dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily 279dnl confused by the quotes (which require backslashes to keep them usable). 280AC_DEFUN([CF_ADD_CXXFLAGS], 281[ 282cf_save_CXXFLAGS="$CFLAGS" 283CFLAGS="$CXXFLAGS" 284CF_ADD_CFLAGS($1 ifelse($2,,,[,$2])) 285CXXFLAGS="$CFLAGS" 286CFLAGS="$cf_save_CXXFLAGS" 287])dnl 288dnl --------------------------------------------------------------------------- 289dnl CF_ADD_INCDIR version: 17 updated: 2021/09/04 06:35:04 290dnl ------------- 291dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it is 292dnl redundant. We don't normally need to add -I/usr/local/include for gcc, 293dnl but old versions (and some misinstalled ones) need that. To make things 294dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to 295dnl the include-path). 296AC_DEFUN([CF_ADD_INCDIR], 297[ 298if test -n "$1" ; then 299 for cf_add_incdir in $1 300 do 301 while test "$cf_add_incdir" != /usr/include 302 do 303 if test -d "$cf_add_incdir" 304 then 305 cf_have_incdir=no 306 if test -n "$CFLAGS$CPPFLAGS" ; then 307 # a loop is needed to ensure we can add subdirs of existing dirs 308 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do 309 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then 310 cf_have_incdir=yes; break 311 fi 312 done 313 fi 314 315 if test "$cf_have_incdir" = no ; then 316 if test "$cf_add_incdir" = /usr/local/include ; then 317 if test "$GCC" = yes 318 then 319 cf_save_CPPFLAGS=$CPPFLAGS 320 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir) 321 AC_TRY_COMPILE([#include <stdio.h>], 322 [printf("Hello")], 323 [], 324 [cf_have_incdir=yes]) 325 CPPFLAGS=$cf_save_CPPFLAGS 326 fi 327 fi 328 fi 329 330 if test "$cf_have_incdir" = no ; then 331 CF_VERBOSE(adding $cf_add_incdir to include-path) 332 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir" 333 334 cf_top_incdir=`echo "$cf_add_incdir" | sed -e 's%/include/.*$%/include%'` 335 test "$cf_top_incdir" = "$cf_add_incdir" && break 336 cf_add_incdir="$cf_top_incdir" 337 else 338 break 339 fi 340 else 341 break 342 fi 343 done 344 done 345fi 346])dnl 347dnl --------------------------------------------------------------------------- 348dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05 349dnl ---------- 350dnl Add a library, used to enforce consistency. 351dnl 352dnl $1 = library to add, without the "-l" 353dnl $2 = variable to update (default $LIBS) 354AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl 355dnl --------------------------------------------------------------------------- 356dnl CF_ADD_LIBDIR version: 11 updated: 2020/12/31 20:19:42 357dnl ------------- 358dnl Adds to the library-path 359dnl 360dnl Some machines have trouble with multiple -L options. 361dnl 362dnl $1 is the (list of) directory(s) to add 363dnl $2 is the optional name of the variable to update (default LDFLAGS) 364dnl 365AC_DEFUN([CF_ADD_LIBDIR], 366[ 367if test -n "$1" ; then 368 for cf_add_libdir in $1 369 do 370 if test "$cf_add_libdir" = /usr/lib ; then 371 : 372 elif test -d "$cf_add_libdir" 373 then 374 cf_have_libdir=no 375 if test -n "$LDFLAGS$LIBS" ; then 376 # a loop is needed to ensure we can add subdirs of existing dirs 377 for cf_test_libdir in $LDFLAGS $LIBS ; do 378 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then 379 cf_have_libdir=yes; break 380 fi 381 done 382 fi 383 if test "$cf_have_libdir" = no ; then 384 CF_VERBOSE(adding $cf_add_libdir to library-path) 385 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])" 386 fi 387 fi 388 done 389fi 390])dnl 391dnl --------------------------------------------------------------------------- 392dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33 393dnl ----------- 394dnl Add one or more libraries, used to enforce consistency. Libraries are 395dnl prepended to an existing list, since their dependencies are assumed to 396dnl already exist in the list. 397dnl 398dnl $1 = libraries to add, with the "-l", etc. 399dnl $2 = variable to update (default $LIBS) 400AC_DEFUN([CF_ADD_LIBS],[ 401cf_add_libs="[$]ifelse($2,,LIBS,[$2])" 402# reverse order 403cf_add_0lib= 404for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done 405# filter duplicates 406for cf_add_1lib in $cf_add_0lib; do 407 for cf_add_2lib in $cf_add_libs; do 408 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then 409 cf_add_1lib= 410 break 411 fi 412 done 413 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs" 414done 415ifelse($2,,LIBS,[$2])="$cf_add_libs" 416])dnl 417dnl --------------------------------------------------------------------------- 418dnl CF_ADD_SUBDIR_PATH version: 5 updated: 2020/12/31 20:19:42 419dnl ------------------ 420dnl Append to a search-list for a nonstandard header/lib-file 421dnl $1 = the variable to return as result 422dnl $2 = the package name 423dnl $3 = the subdirectory, e.g., bin, include or lib 424dnl $4 = the directory under which we will test for subdirectories 425dnl $5 = a directory that we do not want $4 to match 426AC_DEFUN([CF_ADD_SUBDIR_PATH], 427[ 428test "x$4" != "x$5" && \ 429test -d "$4" && \ 430ifelse([$5],NONE,,[{ test -z "$5" || test "x$5" = xNONE || test "x$4" != "x$5"; } &&]) { 431 test -n "$verbose" && echo " ... testing for $3-directories under $4" 432 test -d "$4/$3" && $1="[$]$1 $4/$3" 433 test -d "$4/$3/$2" && $1="[$]$1 $4/$3/$2" 434 test -d "$4/$3/$2/$3" && $1="[$]$1 $4/$3/$2/$3" 435 test -d "$4/$2/$3" && $1="[$]$1 $4/$2/$3" 436 test -d "$4/$2/$3/$2" && $1="[$]$1 $4/$2/$3/$2" 437} 438])dnl 439dnl --------------------------------------------------------------------------- 440dnl CF_APPEND_CFLAGS version: 3 updated: 2021/09/05 17:25:40 441dnl ---------------- 442dnl Use CF_ADD_CFLAGS after first checking for potential redefinitions. 443dnl $1 = flags to add 444dnl $2 = if given makes this macro verbose. 445define([CF_APPEND_CFLAGS], 446[ 447for cf_add_cflags in $1 448do 449 case "x$cf_add_cflags" in 450 (x-[[DU]]*) 451 CF_REMOVE_CFLAGS($cf_add_cflags,CFLAGS,[$2]) 452 CF_REMOVE_CFLAGS($cf_add_cflags,CPPFLAGS,[$2]) 453 ;; 454 esac 455 CF_ADD_CFLAGS([$cf_add_cflags],[$2]) 456done 457])dnl 458dnl --------------------------------------------------------------------------- 459dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55 460dnl -------------- 461dnl use this macro for appending text without introducing an extra blank at 462dnl the beginning 463define([CF_APPEND_TEXT], 464[ 465 test -n "[$]$1" && $1="[$]$1 " 466 $1="[$]{$1}$2" 467])dnl 468dnl --------------------------------------------------------------------------- 469dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 470dnl -------------- 471dnl Allow user to disable a normally-on option. 472AC_DEFUN([CF_ARG_DISABLE], 473[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl 474dnl --------------------------------------------------------------------------- 475dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 476dnl ------------- 477dnl Allow user to enable a normally-off option. 478AC_DEFUN([CF_ARG_ENABLE], 479[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl 480dnl --------------------------------------------------------------------------- 481dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14 482dnl ------------- 483dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus 484dnl values. 485dnl 486dnl Parameters: 487dnl $1 = option name 488dnl $2 = help-string 489dnl $3 = action to perform if option is not default 490dnl $4 = action if perform if option is default 491dnl $5 = default option value (either 'yes' or 'no') 492AC_DEFUN([CF_ARG_OPTION], 493[AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes) 494 if test "$enableval" != "$5" ; then 495ifelse([$3],,[ :]dnl 496,[ $3]) ifelse([$4],,,[ 497 else 498 $4]) 499 fi],[enableval=$5 ifelse([$4],,,[ 500 $4 501])dnl 502])])dnl 503dnl --------------------------------------------------------------------------- 504dnl CF_AR_FLAGS version: 9 updated: 2021/01/01 13:31:04 505dnl ----------- 506dnl Check for suitable "ar" (archiver) options for updating an archive. 507dnl 508dnl In particular, handle some obsolete cases where the "-" might be omitted, 509dnl as well as a workaround for breakage of make's archive rules by the GNU 510dnl binutils "ar" program. 511AC_DEFUN([CF_AR_FLAGS],[ 512AC_REQUIRE([CF_PROG_AR]) 513 514AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[ 515 case "$cf_cv_system_name" in 516 (*-msvc*) 517 cf_cv_ar_flags='' 518 cat >mk_static_lib.sh <<-EOF 519 #!$SHELL 520 MSVC_BIN="[$]AR" 521 out="\[$]1" 522 shift 523 exec \[$]MSVC_BIN -out:"\[$]out" \[$]@ 524 EOF 525 chmod +x mk_static_lib.sh 526 AR=`pwd`/mk_static_lib.sh 527 ;; 528 (*) 529 cf_cv_ar_flags=unknown 530 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv 531 do 532 533 # check if $ARFLAGS already contains this choice 534 if test "x$ARFLAGS" != "x" ; then 535 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"` 536 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then 537 cf_cv_ar_flags= 538 break 539 fi 540 fi 541 542 rm -f "conftest.$ac_cv_objext" 543 rm -f conftest.a 544 545 cat >"conftest.$ac_ext" <<EOF 546#line __oline__ "configure" 547int testdata[[3]] = { 123, 456, 789 }; 548EOF 549 if AC_TRY_EVAL(ac_compile) ; then 550 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC 551 $AR $ARFLAGS "$cf_ar_flags" conftest.a "conftest.$ac_cv_objext" 2>&AC_FD_CC 1>/dev/null 552 if test -f conftest.a ; then 553 cf_cv_ar_flags="$cf_ar_flags" 554 break 555 fi 556 else 557 CF_VERBOSE(cannot compile test-program) 558 break 559 fi 560 done 561 rm -f conftest.a "conftest.$ac_ext" "conftest.$ac_cv_objext" 562 ;; 563 esac 564]) 565 566if test -n "$ARFLAGS" ; then 567 if test -n "$cf_cv_ar_flags" ; then 568 ARFLAGS="$ARFLAGS $cf_cv_ar_flags" 569 fi 570else 571 ARFLAGS=$cf_cv_ar_flags 572fi 573 574AC_SUBST(ARFLAGS) 575]) 576dnl --------------------------------------------------------------------------- 577dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04 578dnl ----------------- 579dnl Check if awk can handle big strings using printf. Some older versions of 580dnl awk choke on large strings passed via "%s". 581dnl 582dnl $1 = desired string size 583dnl $2 = variable to set with result 584AC_DEFUN([CF_AWK_BIG_PRINTF], 585[ 586 case x$AWK in 587 (x) 588 eval $2=no 589 ;; 590 (*) 591 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \ 592 | $AWK '{ printf "%d\n", length([$]0); }' 2>/dev/null | $AWK 'BEGIN { eqls=0; recs=0; } { recs++; if ([$]0 == 12000) eqls++; } END { if (recs != 1 || eqls != 1) exit 1; }' 2>/dev/null >/dev/null ) ; then 593 eval $2=yes 594 else 595 eval $2=no 596 fi 597 ;; 598 esac 599])dnl 600dnl --------------------------------------------------------------------------- 601dnl CF_BOOL_DECL version: 9 updated: 2023/12/03 09:21:34 602dnl ------------ 603dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some 604dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc 605dnl 2.6.3 does, in anticipation of the ANSI C++ standard. 606dnl 607dnl Treat the configuration-variable specially here, since we're directly 608dnl substituting its value (i.e., 1/0). 609dnl 610dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool 611AC_DEFUN([CF_BOOL_DECL], 612[ 613AC_MSG_CHECKING(if we should include stdbool.h) 614 615AC_CACHE_VAL(cf_cv_header_stdbool_h,[ 616 AC_TRY_COMPILE([],[bool foo = false; (void)foo], 617 [cf_cv_header_stdbool_h=0], 618 [AC_TRY_COMPILE([ 619#ifndef __BEOS__ 620#include <stdbool.h> 621#endif 622],[bool foo = false; (void)foo], 623 [cf_cv_header_stdbool_h=1], 624 [cf_cv_header_stdbool_h=0])])]) 625 626if test "$cf_cv_header_stdbool_h" = 1 627then AC_MSG_RESULT(yes) 628else AC_MSG_RESULT(no) 629fi 630 631AC_MSG_CHECKING([for builtin bool type]) 632 633AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[ 634 AC_TRY_COMPILE([ 635#include <stdio.h> 636#include <sys/types.h> 637],[bool x = false; (void)x], 638 [ifelse($1,,cf_cv_builtin_bool,[$1])=1], 639 [ifelse($1,,cf_cv_builtin_bool,[$1])=0]) 640 ]) 641 642if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1 643then AC_MSG_RESULT(yes) 644else AC_MSG_RESULT(no) 645fi 646])dnl 647dnl --------------------------------------------------------------------------- 648dnl CF_BOOL_SIZE version: 20 updated: 2023/02/18 17:41:25 649dnl ------------ 650dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type). 651dnl Don't bother looking for bool.h, since it has been deprecated. 652dnl 653dnl If the current compiler is C rather than C++, we get the bool definition 654dnl from <stdbool.h>. 655AC_DEFUN([CF_BOOL_SIZE], 656[ 657AC_CHECK_SIZEOF(bool,,[ 658$ac_includes_default 659 660#if defined(__cplusplus) 661 662#ifdef HAVE_GXX_BUILTIN_H 663#include <g++/builtin.h> 664#elif HAVE_GPP_BUILTIN_H 665#include <gpp/builtin.h> 666#elif HAVE_BUILTIN_H 667#include <builtin.h> 668#endif 669 670#else 671 672#if $cf_cv_header_stdbool_h 673#include <stdbool.h> 674#endif 675 676#endif 677]) 678 679AC_CACHE_CHECK(for type of bool, cf_cv_type_of_bool,[ 680 rm -f cf_test.out 681 AC_TRY_RUN([ 682$ac_includes_default 683 684#if defined(__cplusplus) 685 686#ifdef HAVE_GXX_BUILTIN_H 687#include <g++/builtin.h> 688#elif HAVE_GPP_BUILTIN_H 689#include <gpp/builtin.h> 690#elif HAVE_BUILTIN_H 691#include <builtin.h> 692#endif 693 694#else 695 696#if $cf_cv_header_stdbool_h 697#include <stdbool.h> 698#endif 699 700#endif 701 702int main(void) 703{ 704 FILE *fp = fopen("cf_test.out", "w"); 705 if (fp != 0) { 706 bool x = true; 707 if ((bool)(-x) >= 0) 708 fputs("unsigned ", fp); 709 if (sizeof(x) == sizeof(int)) fputs("int", fp); 710 else if (sizeof(x) == sizeof(char)) fputs("char", fp); 711 else if (sizeof(x) == sizeof(short))fputs("short",fp); 712 else if (sizeof(x) == sizeof(long)) fputs("long", fp); 713 fclose(fp); 714 } 715 ${cf_cv_main_return:-return}(0); 716} 717 ], 718 [cf_cv_type_of_bool=`cat cf_test.out` 719 if test -z "$cf_cv_type_of_bool"; then 720 cf_cv_type_of_bool=unknown 721 fi], 722 [cf_cv_type_of_bool=unknown], 723 [ 724 case x$ac_cv_sizeof_bool in 725 (x1) cf_cv_type_of_bool="unsigned char";; 726 (x2) cf_cv_type_of_bool="unsigned short";; 727 (x4) cf_cv_type_of_bool="unsigned int";; 728 (x8) cf_cv_type_of_bool="unsigned long";; 729 (*) cf_cv_type_of_bool=unknown;; 730 esac 731 ]) 732 rm -f cf_test.out 733]) 734 735if test "$cf_cv_type_of_bool" = unknown ; then 736 case .$NCURSES_BOOL in 737 (.auto|.) NCURSES_BOOL=unsigned;; 738 esac 739 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool) 740 cf_cv_type_of_bool=$NCURSES_BOOL 741fi 742])dnl 743dnl --------------------------------------------------------------------------- 744dnl CF_BUILD_CC version: 11 updated: 2022/12/04 15:40:08 745dnl ----------- 746dnl If we're cross-compiling, allow the user to override the tools and their 747dnl options. The configure script is oriented toward identifying the host 748dnl compiler, etc., but we need a build compiler to generate parts of the 749dnl source. 750dnl 751dnl $1 = default for $CPPFLAGS 752dnl $2 = default for $LIBS 753AC_DEFUN([CF_BUILD_CC],[ 754CF_ACVERSION_CHECK(2.52,, 755 [AC_REQUIRE([CF_PROG_EXT])]) 756if test "$cross_compiling" = yes ; then 757 758 # defaults that we might want to override 759 : ${BUILD_CFLAGS:=''} 760 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'} 761 : ${BUILD_LDFLAGS:=''} 762 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'} 763 : ${BUILD_EXEEXT:='$x'} 764 : ${BUILD_OBJEXT:='o'} 765 766 AC_ARG_WITH(build-cc, 767 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)], 768 [BUILD_CC="$withval"], 769 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)]) 770 AC_MSG_CHECKING(for native build C compiler) 771 AC_MSG_RESULT($BUILD_CC) 772 773 AC_MSG_CHECKING(for native build C preprocessor) 774 AC_ARG_WITH(build-cpp, 775 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)], 776 [BUILD_CPP="$withval"], 777 [BUILD_CPP='${BUILD_CC} -E']) 778 AC_MSG_RESULT($BUILD_CPP) 779 780 AC_MSG_CHECKING(for native build C flags) 781 AC_ARG_WITH(build-cflags, 782 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)], 783 [BUILD_CFLAGS="$withval"]) 784 AC_MSG_RESULT($BUILD_CFLAGS) 785 786 AC_MSG_CHECKING(for native build C preprocessor-flags) 787 AC_ARG_WITH(build-cppflags, 788 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)], 789 [BUILD_CPPFLAGS="$withval"]) 790 AC_MSG_RESULT($BUILD_CPPFLAGS) 791 792 AC_MSG_CHECKING(for native build linker-flags) 793 AC_ARG_WITH(build-ldflags, 794 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)], 795 [BUILD_LDFLAGS="$withval"]) 796 AC_MSG_RESULT($BUILD_LDFLAGS) 797 798 AC_MSG_CHECKING(for native build linker-libraries) 799 AC_ARG_WITH(build-libs, 800 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})], 801 [BUILD_LIBS="$withval"]) 802 AC_MSG_RESULT($BUILD_LIBS) 803 804 # this assumes we're on Unix. 805 BUILD_EXEEXT= 806 BUILD_OBJEXT=o 807 808 : ${BUILD_CC:='${CC}'} 809 810 AC_MSG_CHECKING(if the build-compiler "$BUILD_CC" works) 811 812 cf_save_crossed=$cross_compiling 813 cf_save_ac_link=$ac_link 814 cross_compiling=no 815 cf_build_cppflags=$BUILD_CPPFLAGS 816 test "$cf_build_cppflags" = "#" && cf_build_cppflags= 817 ac_link='$BUILD_CC -o "conftest$ac_exeext" $BUILD_CFLAGS $cf_build_cppflags $BUILD_LDFLAGS "conftest.$ac_ext" $BUILD_LIBS >&AS_MESSAGE_LOG_FD' 818 819 AC_TRY_RUN([#include <stdio.h> 820 int main(int argc, char *argv[]) 821 { 822 ${cf_cv_main_return:-return}(argc < 0 || argv == 0 || argv[0] == 0); 823 } 824 ], 825 cf_ok_build_cc=yes, 826 cf_ok_build_cc=no, 827 cf_ok_build_cc=unknown) 828 829 cross_compiling=$cf_save_crossed 830 ac_link=$cf_save_ac_link 831 832 AC_MSG_RESULT($cf_ok_build_cc) 833 834 if test "$cf_ok_build_cc" != yes 835 then 836 AC_MSG_ERROR([Cross-build requires two compilers. 837Use --with-build-cc to specify the native compiler.]) 838 fi 839 840else 841 : ${BUILD_CC:='${CC}'} 842 : ${BUILD_CPP:='${CPP}'} 843 : ${BUILD_CFLAGS:='${CFLAGS}'} 844 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'} 845 : ${BUILD_LDFLAGS:='${LDFLAGS}'} 846 : ${BUILD_LIBS:='${LIBS}'} 847 : ${BUILD_EXEEXT:='$x'} 848 : ${BUILD_OBJEXT:='o'} 849fi 850 851AC_SUBST(BUILD_CC) 852AC_SUBST(BUILD_CPP) 853AC_SUBST(BUILD_CFLAGS) 854AC_SUBST(BUILD_CPPFLAGS) 855AC_SUBST(BUILD_LDFLAGS) 856AC_SUBST(BUILD_LIBS) 857AC_SUBST(BUILD_EXEEXT) 858AC_SUBST(BUILD_OBJEXT) 859])dnl 860dnl --------------------------------------------------------------------------- 861dnl CF_C11_NORETURN version: 4 updated: 2023/02/18 17:41:25 862dnl --------------- 863AC_DEFUN([CF_C11_NORETURN], 864[ 865AC_MSG_CHECKING(if you want to use C11 _Noreturn feature) 866CF_ARG_ENABLE(stdnoreturn, 867 [ --enable-stdnoreturn enable C11 _Noreturn feature for diagnostics], 868 [enable_stdnoreturn=yes], 869 [enable_stdnoreturn=no]) 870AC_MSG_RESULT($enable_stdnoreturn) 871 872if test $enable_stdnoreturn = yes; then 873AC_CACHE_CHECK([for C11 _Noreturn feature], cf_cv_c11_noreturn, 874 [AC_TRY_COMPILE([ 875$ac_includes_default 876#include <stdnoreturn.h> 877static _Noreturn void giveup(void) { exit(0); } 878 ], 879 [if (feof(stdin)) giveup()], 880 cf_cv_c11_noreturn=yes, 881 cf_cv_c11_noreturn=no) 882 ]) 883else 884 cf_cv_c11_noreturn=no, 885fi 886 887if test "$cf_cv_c11_noreturn" = yes; then 888 AC_DEFINE(HAVE_STDNORETURN_H, 1,[Define if <stdnoreturn.h> header is available and working]) 889 AC_DEFINE_UNQUOTED(STDC_NORETURN,_Noreturn,[Define if C11 _Noreturn keyword is supported]) 890 HAVE_STDNORETURN_H=1 891else 892 HAVE_STDNORETURN_H=0 893fi 894 895AC_SUBST(HAVE_STDNORETURN_H) 896AC_SUBST(STDC_NORETURN) 897])dnl 898dnl --------------------------------------------------------------------------- 899dnl CF_CC_ENV_FLAGS version: 11 updated: 2023/02/20 11:15:46 900dnl --------------- 901dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content 902dnl into CC. This will not help with broken scripts that wrap the compiler 903dnl with options, but eliminates a more common category of user confusion. 904dnl 905dnl In particular, it addresses the problem of being able to run the C 906dnl preprocessor in a consistent manner. 907dnl 908dnl Caveat: this also disallows blanks in the pathname for the compiler, but 909dnl the nuisance of having inconsistent settings for compiler and preprocessor 910dnl outweighs that limitation. 911AC_DEFUN([CF_CC_ENV_FLAGS], 912[ 913# This should have been defined by AC_PROG_CC 914: "${CC:=cc}" 915 916AC_MSG_CHECKING(\$CFLAGS variable) 917case "x$CFLAGS" in 918(*-[[IUD]]*) 919 AC_MSG_RESULT(broken) 920 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options) 921 cf_flags="$CFLAGS" 922 CFLAGS= 923 for cf_arg in $cf_flags 924 do 925 CF_ADD_CFLAGS($cf_arg) 926 done 927 ;; 928(*) 929 AC_MSG_RESULT(ok) 930 ;; 931esac 932 933AC_MSG_CHECKING(\$CC variable) 934case "$CC" in 935(*[[\ \ ]]-*) 936 AC_MSG_RESULT(broken) 937 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options) 938 # humor him... 939 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'` 940 cf_flags=`echo "$CC" | sed -e "s%^$cf_prog%%"` 941 CC="$cf_prog" 942 for cf_arg in $cf_flags 943 do 944 case "x$cf_arg" in 945 (x-[[IUDfgOW]]*) 946 CF_ADD_CFLAGS($cf_arg) 947 ;; 948 (*) 949 CC="$CC $cf_arg" 950 ;; 951 esac 952 done 953 CF_VERBOSE(resulting CC: '$CC') 954 CF_VERBOSE(resulting CFLAGS: '$CFLAGS') 955 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS') 956 ;; 957(*) 958 AC_MSG_RESULT(ok) 959 ;; 960esac 961])dnl 962dnl --------------------------------------------------------------------------- 963dnl CF_CFG_DEFAULTS version: 16 updated: 2021/01/04 19:33:05 964dnl --------------- 965dnl Determine the default configuration into which we'll install ncurses. This 966dnl can be overridden by the user's command-line options. There's two items to 967dnl look for: 968dnl 1. the prefix (e.g., /usr) 969dnl 2. the header files (e.g., /usr/include/ncurses) 970dnl We'll look for a previous installation of ncurses and use the same defaults. 971dnl 972dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and 973dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's 974dnl programs from a vendor's. 975AC_DEFUN([CF_CFG_DEFAULTS], 976[AC_REQUIRE([AC_PROG_FGREP])dnl 977 978AC_MSG_CHECKING(for prefix) 979if test "x$prefix" = "xNONE" ; then 980 case "$cf_cv_system_name" in 981 # non-vendor systems don't have a conflict 982 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*) 983 prefix=/usr 984 ;; 985 (*) prefix=$ac_default_prefix 986 ;; 987 esac 988fi 989AC_MSG_RESULT($prefix) 990 991if test "x$prefix" = "xNONE" ; then 992AC_MSG_CHECKING(for default include-directory) 993test -n "$verbose" && echo 1>&AC_FD_MSG 994for cf_symbol in \ 995 "$includedir" \ 996 "$includedir/ncurses" \ 997 "$prefix/include" \ 998 "$prefix/include/ncurses" \ 999 /usr/local/include \ 1000 /usr/local/include/ncurses \ 1001 /usr/include \ 1002 /usr/include/ncurses 1003do 1004 cf_dir=`eval echo "$cf_symbol"` 1005 if test -f "$cf_dir/curses.h" ; then 1006 if ( ${FGREP-fgrep} NCURSES_VERSION "$cf_dir/curses.h" >/dev/null 2>&1 ) ; then 1007 includedir="$cf_symbol" 1008 test -n "$verbose" && echo $ECHO_N " found " 1>&AC_FD_MSG 1009 break 1010 fi 1011 fi 1012 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG 1013done 1014AC_MSG_RESULT($includedir) 1015fi 1016])dnl 1017dnl --------------------------------------------------------------------------- 1018dnl CF_CGETENT version: 7 updated: 2023/02/18 17:41:25 1019dnl ---------- 1020dnl Check if the terminal-capability database functions are available. If not, 1021dnl ncurses has a much-reduced version. 1022AC_DEFUN([CF_CGETENT],[ 1023AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[ 1024AC_TRY_LINK([ 1025$ac_includes_default],[ 1026 char temp[128]; 1027 char *buf = temp; 1028 char *db_array = temp; 1029 cgetent(&buf, &db_array, "vt100"); 1030 cgetcap(buf, "tc", '='); 1031 cgetmatch(buf, "tc"); 1032 ], 1033 [cf_cv_cgetent=yes], 1034 [cf_cv_cgetent=no]) 1035]) 1036 1037if test "$cf_cv_cgetent" = yes 1038then 1039 AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent]) 1040AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[ 1041AC_TRY_LINK([ 1042#pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers" 1043$ac_includes_default],[ 1044 char temp[128]; 1045 char *buf = temp; 1046#ifndef _NETBSD_SOURCE /* given, since April 2004 in stdlib.h */ 1047 const char *db_array = temp; 1048 cgetent(&buf, &db_array, "vt100"); 1049#endif 1050 cgetcap(buf, "tc", '='); 1051 cgetmatch(buf, "tc"); 1052 ], 1053 [cf_cv_cgetent_const=yes], 1054 [cf_cv_cgetent_const=no]) 1055]) 1056 if test "$cf_cv_cgetent_const" = yes 1057 then 1058 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations]) 1059 fi 1060fi 1061])dnl 1062dnl --------------------------------------------------------------------------- 1063dnl CF_CHECK_CACHE version: 13 updated: 2020/12/31 10:54:15 1064dnl -------------- 1065dnl Check if we're accidentally using a cache from a different machine. 1066dnl Derive the system name, as a check for reusing the autoconf cache. 1067dnl 1068dnl If we've packaged config.guess and config.sub, run that (since it does a 1069dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow 1070dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM 1071dnl which is useful in cross-compiles. 1072dnl 1073dnl Note: we would use $ac_config_sub, but that is one of the places where 1074dnl autoconf 2.5x broke compatibility with autoconf 2.13 1075AC_DEFUN([CF_CHECK_CACHE], 1076[ 1077if test -f "$srcdir/config.guess" || test -f "$ac_aux_dir/config.guess" ; then 1078 ifelse([$1],,[AC_CANONICAL_HOST],[$1]) 1079 system_name="$host_os" 1080else 1081 system_name="`(uname -s -r) 2>/dev/null`" 1082 if test -z "$system_name" ; then 1083 system_name="`(hostname) 2>/dev/null`" 1084 fi 1085fi 1086test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.]) 1087AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) 1088 1089test -z "$system_name" && system_name="$cf_cv_system_name" 1090test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) 1091 1092if test ".$system_name" != ".$cf_cv_system_name" ; then 1093 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) 1094 AC_MSG_ERROR("Please remove config.cache and try again.") 1095fi 1096])dnl 1097dnl --------------------------------------------------------------------------- 1098dnl CF_CHECK_ENVIRON version: 5 updated: 2023/02/18 17:41:25 1099dnl ---------------- 1100dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ' 1101dnl variable. Define a DECL_xxx symbol if we must declare it ourselves. 1102dnl 1103dnl $1 = the name to check 1104dnl $2 = the assumed type 1105AC_DEFUN([CF_CHECK_ENVIRON], 1106[ 1107AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ 1108 AC_TRY_COMPILE([ 1109$ac_includes_default], 1110 ifelse([$2],,void*,[$2]) x = (ifelse([$2],,void*,[$2])) $1; (void)x, 1111 [cf_cv_dcl_$1=yes], 1112 [cf_cv_dcl_$1=no]) 1113]) 1114 1115if test "$cf_cv_dcl_$1" = no ; then 1116 CF_UPPER(cf_result,decl_$1) 1117 AC_DEFINE_UNQUOTED($cf_result) 1118fi 1119 1120# It's possible (for near-UNIX clones) that the data doesn't exist 1121CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2])) 1122])dnl 1123dnl --------------------------------------------------------------------------- 1124dnl CF_CHECK_ERRNO version: 14 updated: 2023/02/18 17:41:25 1125dnl -------------- 1126dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g., 1127dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it 1128dnl ourselves. 1129dnl 1130dnl $1 = the name to check 1131dnl $2 = the assumed type 1132AC_DEFUN([CF_CHECK_ERRNO], 1133[ 1134AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ 1135 AC_TRY_COMPILE([ 1136$ac_includes_default 1137#include <errno.h> ], 1138 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1; (void)x, 1139 [cf_cv_dcl_$1=yes], 1140 [cf_cv_dcl_$1=no]) 1141]) 1142 1143if test "$cf_cv_dcl_$1" = no ; then 1144 CF_UPPER(cf_result,decl_$1) 1145 AC_DEFINE_UNQUOTED($cf_result) 1146fi 1147 1148# It's possible (for near-UNIX clones) that the data doesn't exist 1149CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2])) 1150])dnl 1151dnl --------------------------------------------------------------------------- 1152dnl CF_CHECK_EXTERN_DATA version: 5 updated: 2021/09/04 06:35:04 1153dnl -------------------- 1154dnl Check for existence of external data in the current set of libraries. If 1155dnl we can modify it, it is real enough. 1156dnl $1 = the name to check 1157dnl $2 = its type 1158AC_DEFUN([CF_CHECK_EXTERN_DATA], 1159[ 1160AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[ 1161 AC_TRY_LINK([ 1162#undef $1 1163extern $2 $1; 1164], 1165 [$1 = 2], 1166 [cf_cv_have_$1=yes], 1167 [cf_cv_have_$1=no]) 1168]) 1169 1170if test "$cf_cv_have_$1" = yes ; then 1171 CF_UPPER(cf_result,have_$1) 1172 AC_DEFINE_UNQUOTED($cf_result) 1173fi 1174 1175])dnl 1176dnl --------------------------------------------------------------------------- 1177dnl CF_CHECK_FVISIBILITY version: 2 updated: 2020/04/04 16:16:13 1178dnl -------------------- 1179dnl Check whether the compiler understands -fvisibility=hidden 1180dnl 1181dnl $1 = compiler 1182dnl $2 = compiler-flags variable name 1183dnl $3 = cache variable to set 1184AC_DEFUN([CF_CHECK_FVISIBILITY],[ 1185AC_CACHE_CHECK(if $1 -fvisibility=hidden option works,$3,[ 1186 cf_save_cflags="[$]$2" 1187 $2="[$]$2 -fvisibility=hidden" 1188 AC_TRY_LINK([ 1189__attribute__ ((visibility("default"))) int somefunc() {return 42;} 1190 ],[ 1191 if (somefunc()) return 1; 1192], 1193 [$3=yes], 1194 [$3=no]) 1195 $2=$cf_save_cflags 1196]) 1197])dnl 1198dnl --------------------------------------------------------------------------- 1199dnl CF_CHECK_GETENV version: 4 updated: 2023/12/03 10:18:09 1200dnl --------------- 1201dnl Check if repeated getenv calls return the same pointer, e.g., it does not 1202dnl discard the previous pointer when returning a new one. 1203AC_DEFUN([CF_CHECK_GETENV], 1204[ 1205AC_REQUIRE([CF_CHECK_ENVIRON]) 1206AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) ) 1207AC_CHECK_FUNCS( putenv setenv strdup ) 1208AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[ 1209AC_TRY_RUN([ 1210$ac_includes_default 1211 1212#if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ) 1213extern char **environ; /* POSIX, but some systems are not... */ 1214#endif 1215 1216#if defined(HAVE_STRDUP) 1217#define str_alloc(s) strdup(s) 1218#else 1219#define str_alloc(s) strcpy(malloc(strlen(s) + 1, s)) 1220#endif 1221 1222static void set_value(const char *name, const char *value) 1223{ 1224#if defined(HAVE_SETENV) 1225 setenv(name, value, 1); 1226#elif defined(HAVE_PUTENV) 1227 char buffer[1024]; 1228 sprintf(buffer, "%s=%s", name, value); 1229 putenv(str_alloc(buffer)); 1230#else 1231#error neither putenv/setenv found 1232#endif 1233} 1234int main(void) 1235{ 1236 int pass; 1237 size_t numenv, limit, j; 1238 char **mynames; 1239 char **myvalues; 1240 char **mypointer; 1241 char *equals; 1242 for (numenv = 0; environ[numenv]; ++numenv) ; 1243 limit = numenv + 10; 1244 mynames = (char **) calloc(limit + 1, sizeof(char *)); 1245 myvalues = (char **) calloc(limit + 1, sizeof(char *)); 1246 mypointer = (char **) calloc(limit + 1, sizeof(char *)); 1247#if defined(HAVE_ENVIRON) 1248 for (j = 0; environ[j]; ++j) { 1249 mynames[j] = str_alloc(environ[j]); 1250 equals = strchr(mynames[j], '='); 1251 if (equals != 0) { 1252 *equals++ = '\\0'; 1253 myvalues[j] = str_alloc(equals); 1254 } else { 1255 myvalues[j] = str_alloc(""); 1256 } 1257 } 1258#endif 1259 for (j = numenv; j < limit; ++j) { 1260 char name[80]; 1261 char value[80]; 1262 size_t found; 1263 size_t k = 0; 1264 do { 1265 size_t jk; 1266 found = 0; 1267 sprintf(name, "TERM%lu", (unsigned long) k); 1268 for (jk = 0; jk < j; ++jk) { 1269 if (!strcmp(name, mynames[jk])) { 1270 found = 1; 1271 ++k; 1272 break; 1273 } 1274 } 1275 } while (found); 1276 sprintf(value, "%lu:%p", (unsigned long) k, (void*)&mynames[j]); 1277 set_value(name, value); 1278 mynames[j] = str_alloc(name); 1279 myvalues[j] = str_alloc(value); 1280 } 1281 for (pass = 0; pass < 3; ++pass) { 1282 for (j = 0; j < limit; ++j) { 1283 char *value = getenv(mynames[j]); 1284 if (pass) { 1285 if (value == 0) { 1286 fprintf(stderr, "getenv returned null for %s\\n", mynames[j]); 1287 ${cf_cv_main_return:-return}(1); 1288 } else if (value != mypointer[j]) { 1289 fprintf(stderr, "getenv returned different pointer for %s\\n", mynames[j]); 1290 ${cf_cv_main_return:-return}(1); 1291 } else if (strcmp(value, myvalues[j])) { 1292 fprintf(stderr, "getenv returned different value for %s\\n", mynames[j]); 1293 ${cf_cv_main_return:-return}(1); 1294 } 1295 } else { 1296 size_t k; 1297 mypointer[j] = value; 1298 for (k = 0; k < j; ++k) { 1299 if (mypointer[j] == mypointer[k]) { 1300 fprintf(stderr, "getenv returned same pointer for %s and %s\\n", mynames[j], mynames[k]); 1301 ${cf_cv_main_return:-return}(1); 1302 } 1303 } 1304 } 1305 } 1306 } 1307 ${cf_cv_main_return:-return}(0); 1308} 1309], 1310[cf_cv_consistent_getenv=yes], 1311[cf_cv_consistent_getenv=no], 1312[cf_cv_consistent_getenv=unknown]) 1313]) 1314 1315if test "x$cf_cv_consistent_getenv" = xno 1316then 1317 AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name]) 1318fi 1319])dnl 1320dnl --------------------------------------------------------------------------- 1321dnl CF_CHECK_GNAT_VERSION version: 4 updated: 2021/01/01 13:31:04 1322dnl --------------------- 1323AC_DEFUN([CF_CHECK_GNAT_VERSION], 1324[ 1325AC_REQUIRE([CF_GNAT_VERSION]) 1326case "$cf_cv_gnat_version" in 1327(3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]]) 1328 cf_cv_prog_gnat_correct=yes 1329 ;; 1330(*) 1331 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.) 1332 cf_cv_prog_gnat_correct=no 1333 ;; 1334esac 1335]) 1336dnl --------------------------------------------------------------------------- 1337dnl CF_CHECK_GPM_WGETCH version: 6 updated: 2021/01/04 18:48:01 1338dnl ------------------- 1339dnl Check if GPM is already linked with curses. If so - and if the linkage 1340dnl is not "weak" - warn about this because it can create problems linking 1341dnl applications with ncurses. 1342AC_DEFUN([CF_CHECK_GPM_WGETCH],[ 1343AC_REQUIRE([AC_PROG_EGREP])dnl 1344 1345AC_CHECK_LIB(gpm,Gpm_Wgetch,[ 1346 1347AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[ 1348cf_cv_check_gpm_wgetch=unknown 1349if test "$cross_compiling" != yes ; then 1350 1351cat >conftest.$ac_ext <<CF_EOF 1352#include <gpm.h> 1353int main(void) 1354{ 1355 Gpm_Wgetch(); 1356 ${cf_cv_main_return:-return}(0); 1357} 1358CF_EOF 1359 1360 cf_save_LIBS="$LIBS" 1361 # This only works if we can look at the symbol table. If a shared 1362 # library is stripped for install, we cannot use that. So we're forced 1363 # to rely on the static library, noting that some packagers may not 1364 # include it. 1365 LIBS="-static -lgpm -dynamic $LIBS" 1366 if AC_TRY_EVAL(ac_compile) ; then 1367 if AC_TRY_EVAL(ac_link) ; then 1368 cf_cv_check_gpm_wgetch="`nm \"conftest$ac_exeext\" | ${EGREP-egrep} '\<wgetch\>' | ${EGREP-egrep} '\<[[vVwW]]\>'`" 1369 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes 1370 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no 1371 fi 1372 fi 1373 rm -rf ./conftest* 1374 LIBS="$cf_save_LIBS" 1375fi 1376]) 1377 1378if test "$cf_cv_check_gpm_wgetch" != yes ; then 1379 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ) 1380fi 1381])])dnl 1382dnl --------------------------------------------------------------------------- 1383dnl CF_CHECK_LIBSSP version: 1 updated: 2021/10/30 10:40:19 1384dnl --------------- 1385dnl Check if libssp is needed, e.g., to work around misconfigured libraries 1386dnl used in cross-compiling to MinGW. 1387AC_DEFUN([CF_CHECK_LIBSSP],[ 1388AC_CACHE_CHECK(if ssp library is needed,cf_cv_need_libssp,[ 1389AC_TRY_LINK([ 1390#include <sys/types.h> 1391#include <dirent.h> 1392],[ 1393 DIR *dp = opendir("."); 1394],cf_cv_need_libssp=no,[ 1395 cf_save_LIBS="$LIBS" 1396 LIBS="$LIBS -lssp" 1397 AC_TRY_LINK([ 1398#include <sys/types.h> 1399#include <dirent.h> 1400 ],[ 1401 DIR *dp = opendir("."); 1402 ],cf_cv_need_libssp=yes, 1403 cf_cv_need_libssp=maybe) 1404 LIBS="$cf_save_LIBS" 1405])dnl 1406]) 1407 1408if test "x$cf_cv_need_libssp" = xyes 1409then 1410 CF_ADD_LIB(ssp) 1411fi 1412])dnl 1413dnl --------------------------------------------------------------------------- 1414dnl CF_CHECK_LIBTOOL_VERSION version: 2 updated: 2021/05/01 16:24:34 1415dnl ------------------------ 1416dnl Show the version of libtool 1417dnl 1418dnl Save the version in a cache variable - this is not entirely a good thing, 1419dnl but the version string from libtool is very ugly, and for bug reports it 1420dnl might be useful to have the original string. 1421dnl 1422dnl There is an imitation in OpenBSD, which has no apparent use other than to 1423dnl deny that it is GNU libtool. Just ignore it. 1424AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[ 1425if test -n "$LIBTOOL" && test "$LIBTOOL" != none 1426then 1427 AC_MSG_CHECKING(version of $LIBTOOL) 1428 CF_LIBTOOL_VERSION 1429 AC_MSG_RESULT($cf_cv_libtool_version) 1430 if test -n "$cf_cv_libtool_version" 1431 then 1432 cf_check_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' -e 's,[[()]],...,g' -e 's,[[ ]],-,g' -e '2,$d'` 1433 case "x$cf_check_libtool_version" in 1434 (*...GNU-libtool...*) 1435 ;; 1436 (*) 1437 AC_MSG_ERROR(This is not GNU libtool) 1438 ;; 1439 esac 1440 else 1441 AC_MSG_ERROR(No version found for $LIBTOOL) 1442 fi 1443else 1444 AC_MSG_ERROR(GNU libtool has not been found) 1445fi 1446])dnl 1447dnl --------------------------------------------------------------------------- 1448dnl CF_CHECK_WCHAR_H version: 5 updated: 2023/12/03 09:21:34 1449dnl ---------------- 1450dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED 1451AC_DEFUN([CF_CHECK_WCHAR_H],[ 1452AC_CHECK_HEADERS( \ 1453wchar.h \ 1454wctype.h \ 1455) 1456AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[ 1457AC_TRY_COMPILE( 1458[ 1459$ac_includes_default 1460#ifdef HAVE_WCHAR_H 1461#include <wchar.h> 1462#endif 1463#ifdef HAVE_WCTYPE_H 1464#include <wctype.h> 1465#endif 1466],[ 1467 wint_t foo = 0; 1468 int bar = iswpunct(foo); (void) bar], 1469 [cf_cv_wchar_h_okay=yes], 1470 [cf_cv_wchar_h_okay=no])]) 1471 1472if test "$cf_cv_wchar_h_okay" = no 1473then 1474 CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED) 1475fi 1476])dnl 1477dnl --------------------------------------------------------------------------- 1478dnl CF_CHECK_WCWIDTH_GRAPHICS version: 4 updated: 2023/12/03 10:17:07 1479dnl ------------------------- 1480dnl Most "modern" terminal emulators are based to some degree on VT100, and 1481dnl should support line-drawing. Even with Unicode. There is a problem. 1482dnl 1483dnl While most of the VT100 graphics characters were incorporated into Unicode, 1484dnl all of those were combined into a page of useful graphics characters. 1485dnl 1486dnl So far, so good. 1487dnl 1488dnl However, while they are useful, there are other considerations. CJK 1489dnl is (because of poor device resolution) often rendered as double-width 1490dnl characters. So... for these generally-useful characters, what should 1491dnl be the width (to make them consistent with adjacent characters)? 1492dnl 1493dnl The obvious choice would have been to make this locale-dependent, and use 1494dnl wcwidth() to tell applications what the actual width is. That was too 1495dnl obvious. Instead, we have a slew of "ambiguous-width" characters. 1496dnl See for example 1497dnl http://www.unicode.org/reports/tr11/tr11-29.html 1498dnl http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html 1499dnl 1500dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists 1501dnl more than 22,000 characters, with 1281 of those as ambiguous-width. For 1502dnl instance, it lists half (44/96) of the Latin-1 characters as 1503dnl ambiguous-width. Also, all of the box-characters at 0x2500 are ambiguous. 1504dnl 1505dnl What this means for the implementor is that on some systems wcwidth() can 1506dnl give bad advice. On Solaris, some of the ambiguous widths are returned as 1507dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing 1508dnl characters). These do not necessarily match the behavior of the terminal 1509dnl emulator. xterm, for instance, does an optional startup check to find if 1510dnl this problem (or similar) exists with the system's locale tables, rejecting 1511dnl them if they are too unreliable. 1512AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[ 1513AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[ 1514cat >conftest.in <<CF_EOF 1515- VT100 symbols 15160x250c upper left corner 15170x2514 lower left corner 15180x2510 upper right corner 15190x2518 lower right corner 15200x251c tee pointing left 15210x2524 tee pointing right 15220x2534 tee pointing up 15230x252c tee pointing down 15240x2500 horizontal line 15250x2502 vertical line 15260x253c large plus or crossover 15270x23ba scan line 1 15280x23bd scan line 9 15290x25c6 diamond 15300x2592 checker board (stipple) 15310x00b0 degree symbol 15320x00b1 plus/minus 15330x00b7 bullet 1534- Teletype 5410v1 symbols 15350x2190 arrow pointing left 15360x2192 arrow pointing right 15370x2193 arrow pointing down 15380x2191 arrow pointing up 15390x2592 board of squares 15400x2603 lantern symbol 15410x25ae solid square block 1542- these defaults were invented for ncurses 15430x23bb scan line 3 15440x23bc scan line 7 15450x2264 less-than-or-equal-to 15460x2265 greater-than-or-equal-to 15470x03c0 greek pi 15480x2260 not-equal 15490x00a3 pound-sterling symbol 1550- thick-line-drawing 15510x250f upper left corner 15520x2517 lower left corner 15530x2513 upper right corner 15540x251b lower right corner 15550x2523 tee pointing left 15560x252b tee pointing right 15570x253b tee pointing up 15580x2533 tee pointing down 15590x2501 horizontal line 15600x2503 vertical line 15610x254b large plus or crossover 1562- double-line-drawing 15630x2554 upper left corner 15640x255a lower left corner 15650x2557 upper right corner 15660x255d lower right corner 15670x2563 tee pointing left 15680x2560 tee pointing right 15690x2569 tee pointing up 15700x2566 tee pointing down 15710x2550 horizontal line 15720x2551 vertical line 15730x256c large plus or crossover 1574CF_EOF 1575AC_TRY_RUN([ 1576$ac_includes_default 1577 1578#include <locale.h> 1579#include <wchar.h> 1580 1581#define MY_LEN 80 1582 1583int 1584main(void) 1585{ 1586 FILE *fp; 1587 unsigned value; 1588 char buffer[MY_LEN + 1]; 1589 char notes[MY_LEN + 1]; 1590 int totals = 0; 1591 int passed = 0; 1592 1593 if (setlocale(LC_ALL, "en_US.UTF8") || 1594 setlocale(LC_ALL, "en_US.UTF-8") || 1595 setlocale(LC_ALL, "en_US.utf8") || 1596 setlocale(LC_ALL, "en_US.utf-8")) { 1597 if ((fp = fopen("conftest.in", "r")) != 0) { 1598 while (fgets(buffer, MY_LEN, fp) != 0) { 1599 if (*buffer == '-') { 1600 fprintf(stderr, "\\t%s", buffer); 1601 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) { 1602 ++totals; 1603 if (wcwidth((int)value) == 1) 1604 ++passed; 1605 fprintf(stderr, "%d\\t%s", wcwidth((int)value), buffer); 1606 } else { 1607 fprintf(stderr, "?\\t%s", buffer); 1608 } 1609 } 1610 } 1611 } 1612 fprintf(stderr, "%d/%d passed wcwidth/graphics check\\n", passed, totals); 1613 return (totals == passed) ? 0 : 1; 1614} 1615], 1616[cf_cv_wcwidth_graphics=yes], 1617[cf_cv_wcwidth_graphics=no], 1618[cf_cv_wcwidth_graphics=unknown]) 1619]) 1620])dnl 1621dnl --------------------------------------------------------------------------- 1622dnl CF_CLANG_COMPILER version: 9 updated: 2023/02/18 17:41:25 1623dnl ----------------- 1624dnl Check if the given compiler is really clang. clang's C driver defines 1625dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does 1626dnl not ignore some gcc options. 1627dnl 1628dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to 1629dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from 1630dnl the wrappers for gcc and g++ warnings. 1631dnl 1632dnl $1 = GCC (default) or GXX 1633dnl $2 = CLANG_COMPILER (default) 1634dnl $3 = CFLAGS (default) or CXXFLAGS 1635AC_DEFUN([CF_CLANG_COMPILER],[ 1636ifelse([$2],,CLANG_COMPILER,[$2])=no 1637 1638if test "$ifelse([$1],,[$1],GCC)" = yes ; then 1639 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler) 1640 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" 1641 AC_TRY_COMPILE([],[ 1642#ifdef __clang__ 1643#else 1644#error __clang__ is not defined 1645#endif 1646],[ifelse([$2],,CLANG_COMPILER,[$2])=yes 1647],[]) 1648 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" 1649 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2])) 1650fi 1651 1652CLANG_VERSION=none 1653 1654if test "x$ifelse([$2],,CLANG_COMPILER,[$2])" = "xyes" ; then 1655 case "$CC" in 1656 (c[[1-9]][[0-9]]|*/c[[1-9]][[0-9]]) 1657 AC_MSG_WARN(replacing broken compiler alias $CC) 1658 CFLAGS="$CFLAGS -std=`echo "$CC" | sed -e 's%.*/%%'`" 1659 CC=clang 1660 ;; 1661 esac 1662 1663 AC_MSG_CHECKING(version of $CC) 1664 CLANG_VERSION="`$CC --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(CLANG[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" 1665 test -z "$CLANG_VERSION" && CLANG_VERSION=unknown 1666 AC_MSG_RESULT($CLANG_VERSION) 1667 1668 for cf_clang_opt in \ 1669 -Qunused-arguments \ 1670 -Wno-error=implicit-function-declaration 1671 do 1672 AC_MSG_CHECKING(if option $cf_clang_opt works) 1673 cf_save_CFLAGS="$CFLAGS" 1674 CFLAGS="$CFLAGS $cf_clang_opt" 1675 AC_TRY_LINK([ 1676 #include <stdio.h>],[ 1677 printf("hello!\\n");],[ 1678 cf_clang_optok=yes],[ 1679 cf_clang_optok=no]) 1680 AC_MSG_RESULT($cf_clang_optok) 1681 CFLAGS="$cf_save_CFLAGS" 1682 if test "$cf_clang_optok" = yes; then 1683 CF_VERBOSE(adding option $cf_clang_opt) 1684 CF_APPEND_TEXT(CFLAGS,$cf_clang_opt) 1685 fi 1686 done 1687fi 1688]) 1689dnl --------------------------------------------------------------------------- 1690dnl CF_CONST_X_STRING version: 8 updated: 2023/12/01 17:22:50 1691dnl ----------------- 1692dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most 1693dnl character-strings. 1694dnl 1695dnl It is ambiguous because the specification accommodated the pre-ANSI 1696dnl compilers bundled by more than one vendor in lieu of providing a standard C 1697dnl compiler other than by costly add-ons. Because of this, the specification 1698dnl did not take into account the use of const for telling the compiler that 1699dnl string literals would be in readonly memory. 1700dnl 1701dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to 1702dnl let the compiler decide how to represent Xt's strings which were #define'd. 1703dnl That does not solve the problem of using the block of Xt's strings which 1704dnl are compiled into the library (and is less efficient than one might want). 1705dnl 1706dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both 1707dnl when compiling the library and compiling using the library, to tell the 1708dnl compiler that String is const. 1709AC_DEFUN([CF_CONST_X_STRING], 1710[ 1711AC_REQUIRE([AC_PATH_XTRA]) 1712 1713CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING]) 1714 1715AC_TRY_COMPILE( 1716[ 1717#include <stdlib.h> 1718#include <X11/Intrinsic.h> 1719], 1720[String foo = malloc(1); free((void*)foo)],[ 1721 1722AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[ 1723 AC_TRY_COMPILE( 1724 [ 1725#undef _CONST_X_STRING 1726#define _CONST_X_STRING /* X11R7.8 (perhaps) */ 1727#undef XTSTRINGDEFINES /* X11R5 and later */ 1728#include <stdlib.h> 1729#include <X11/Intrinsic.h> 1730 ],[String foo = malloc(1); *foo = 0],[ 1731 cf_cv_const_x_string=no 1732 ],[ 1733 cf_cv_const_x_string=yes 1734 ]) 1735]) 1736 1737CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING]) 1738 1739case "$cf_cv_const_x_string" in 1740(no) 1741 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES) 1742 ;; 1743(*) 1744 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING) 1745 ;; 1746esac 1747 1748]) 1749])dnl 1750dnl --------------------------------------------------------------------------- 1751dnl CF_CPP_OVERRIDE version: 1 updated: 2022/08/20 16:07:10 1752dnl --------------- 1753dnl Check if the C++ compiler accepts the override keyword. This is a C++-11 1754dnl feature. 1755AC_DEFUN([CF_CPP_OVERRIDE], 1756[ 1757if test -n "$CXX"; then 1758AC_CACHE_CHECK(if $CXX accepts override keyword,cf_cv_cpp_override,[ 1759 AC_LANG_SAVE 1760 AC_LANG_CPLUSPLUS 1761 AC_TRY_RUN([ 1762 1763class base 1764{ 1765public: 1766 virtual int foo(float x) = 0; 1767}; 1768 1769 1770class derived: public base 1771{ 1772public: 1773 int foo(float x) override { return x != 0.0 ? 1 : 0; } 1774}; 1775 1776int main(void) { } 1777], 1778 [cf_cv_cpp_override=yes], 1779 [cf_cv_cpp_override=no], 1780 [cf_cv_cpp_override=unknown]) 1781 AC_LANG_RESTORE 1782]) 1783fi 1784test "$cf_cv_cpp_override" = yes && AC_DEFINE(CPP_HAS_OVERRIDE,1,[Define to 1 if C++ has override keyword]) 1785])dnl 1786dnl --------------------------------------------------------------------------- 1787dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25 1788dnl ----------------- 1789dnl Check if the C++ compiler accepts duplicate parameter initialization. This 1790dnl is a late feature for the standard and is not in some recent compilers 1791dnl (1999/9/11). 1792AC_DEFUN([CF_CPP_PARAM_INIT], 1793[ 1794if test -n "$CXX"; then 1795AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[ 1796 AC_LANG_SAVE 1797 AC_LANG_CPLUSPLUS 1798 AC_TRY_RUN([ 1799class TEST { 1800private: 1801 int value; 1802public: 1803 TEST(int x = 1); 1804 ~TEST(); 1805}; 1806 1807TEST::TEST(int x = 1) // some compilers do not like second initializer 1808{ 1809 value = x; 1810} 1811int main(void) { } 1812], 1813 [cf_cv_cpp_param_init=yes], 1814 [cf_cv_cpp_param_init=no], 1815 [cf_cv_cpp_param_init=unknown]) 1816 AC_LANG_RESTORE 1817]) 1818fi 1819test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization]) 1820])dnl 1821dnl --------------------------------------------------------------------------- 1822dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21 1823dnl ------------------ 1824dnl Check if the C++ compiler accepts static_cast in generics. This appears to 1825dnl not be supported in g++ before 3.0 1826AC_DEFUN([CF_CPP_STATIC_CAST], 1827[ 1828if test -n "$CXX"; then 1829 1830AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[ 1831 AC_LANG_SAVE 1832 AC_LANG_CPLUSPLUS 1833 1834 AC_TRY_COMPILE([ 1835class NCursesPanel 1836{ 1837public: 1838 NCursesPanel(int nlines, 1839 int ncols, 1840 int begin_y = 0, 1841 int begin_x = 0) 1842 { 1843 } 1844 NCursesPanel(); 1845 ~NCursesPanel(); 1846}; 1847 1848template<class T> class NCursesUserPanel : public NCursesPanel 1849{ 1850public: 1851 NCursesUserPanel (int nlines, 1852 int ncols, 1853 int begin_y = 0, 1854 int begin_x = 0, 1855 const T* p_UserData = static_cast<T*>(0)) 1856 : NCursesPanel (nlines, ncols, begin_y, begin_x) 1857 { 1858 }; 1859 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel() 1860 { 1861 }; 1862 1863 virtual ~NCursesUserPanel() {}; 1864}; 1865],[ 1866 const char* p_UserData = static_cast<char*>(0)], 1867 [cf_cv_cpp_static_cast=yes], 1868 [cf_cv_cpp_static_cast=no]) 1869 1870 AC_LANG_RESTORE 1871]) 1872 1873fi 1874 1875test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast]) 1876])dnl 1877dnl --------------------------------------------------------------------------- 1878dnl CF_CXX_AR_FLAGS version: 3 updated: 2021/01/01 13:31:04 1879dnl --------------- 1880dnl Setup special archiver flags for given compilers. 1881AC_DEFUN([CF_CXX_AR_FLAGS],[ 1882 CXX_AR='$(AR)' 1883 CXX_ARFLAGS='$(ARFLAGS)' 1884 case "$cf_cv_system_name" in 1885 (irix*) 1886 if test "$GXX" != yes ; then 1887 CXX_AR='$(CXX)' 1888 CXX_ARFLAGS='-ar -o' 1889 fi 1890 ;; 1891 (sco3.2v5*) 1892 CXXLDFLAGS="-u main" 1893 ;; 1894 (solaris2*) 1895 if test "$GXX" != yes ; then 1896 CXX_AR='$(CXX)' 1897 CXX_ARFLAGS='-xar -o' 1898 fi 1899 ;; 1900 esac 1901 AC_SUBST(CXXLDFLAGS) 1902 AC_SUBST(CXX_AR) 1903 AC_SUBST(CXX_ARFLAGS) 1904])dnl 1905dnl --------------------------------------------------------------------------- 1906dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13 1907dnl ------------------------- 1908dnl For c++, check if iostream uses "std::" namespace. 1909AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[ 1910AC_CHECK_HEADERS(iostream) 1911if test x"$ac_cv_header_iostream" = xyes ; then 1912 AC_MSG_CHECKING(if iostream uses std-namespace) 1913 AC_TRY_COMPILE([ 1914#include <iostream> 1915using std::endl; 1916using std::cerr;],[ 1917cerr << "testing" << endl; 1918],[cf_iostream_namespace=yes],[cf_iostream_namespace=no]) 1919 AC_MSG_RESULT($cf_iostream_namespace) 1920 if test "$cf_iostream_namespace" = yes ; then 1921 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream]) 1922 fi 1923fi 1924])dnl 1925dnl --------------------------------------------------------------------------- 1926dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36 1927dnl ----------- 1928dnl Check if the C compiler supports "inline". 1929dnl $1 is the name of a shell variable to set if inline is supported 1930dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size 1931AC_DEFUN([CF_C_INLINE],[ 1932AC_REQUIRE([CF_GCC_VERSION]) 1933AC_C_INLINE 1934$1= 1935if test "$ac_cv_c_inline" != no ; then 1936 $1=inline 1937 if test "$INTEL_COMPILER" = yes 1938 then 1939 : 1940 elif test "$CLANG_COMPILER" = yes 1941 then 1942 : 1943 elif test "$GCC" = yes 1944 then 1945 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[ 1946 cf_save_CFLAGS=$CFLAGS 1947 CFLAGS="$CFLAGS --param max-inline-insns-single=$2" 1948 AC_TRY_COMPILE([inline int foo(void) { return 1; }], 1949 [${cf_cv_main_return:-return} foo()], 1950 [cf_cv_gcc_inline=yes], 1951 [cf_cv_gcc_inline=no]) 1952 CFLAGS=$cf_save_CFLAGS 1953 ]) 1954 if test "$cf_cv_gcc_inline" = yes ; then 1955 CF_ADD_CFLAGS([--param max-inline-insns-single=$2]) 1956 fi 1957 fi 1958fi 1959AC_SUBST($1) 1960])dnl 1961dnl --------------------------------------------------------------------------- 1962dnl CF_DIRNAME version: 5 updated: 2020/12/31 20:19:42 1963dnl ---------- 1964dnl "dirname" is not portable, so we fake it with a shell script. 1965AC_DEFUN([CF_DIRNAME],[$1=`echo "$2" | sed -e 's%/[[^/]]*$%%'`])dnl 1966dnl --------------------------------------------------------------------------- 1967dnl CF_DIRS_TO_MAKE version: 4 updated: 2021/01/01 13:31:04 1968dnl --------------- 1969AC_DEFUN([CF_DIRS_TO_MAKE], 1970[ 1971DIRS_TO_MAKE="lib" 1972for cf_item in $cf_list_models 1973do 1974 CF_OBJ_SUBDIR($cf_item,cf_subdir) 1975 for cf_item2 in $DIRS_TO_MAKE 1976 do 1977 test "$cf_item2" = "$cf_subdir" && break 1978 done 1979 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir" 1980done 1981for cf_dir in $DIRS_TO_MAKE 1982do 1983 test ! -d "$cf_dir" && mkdir "$cf_dir" 1984done 1985AC_SUBST(DIRS_TO_MAKE) 1986])dnl 1987dnl --------------------------------------------------------------------------- 1988dnl CF_DISABLE_ECHO version: 14 updated: 2021/09/04 06:35:04 1989dnl --------------- 1990dnl You can always use "make -n" to see the actual options, but it is hard to 1991dnl pick out/analyze warning messages when the compile-line is long. 1992dnl 1993dnl Sets: 1994dnl ECHO_LT - symbol to control if libtool is verbose 1995dnl ECHO_LD - symbol to prefix "cc -o" lines 1996dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) 1997dnl SHOW_CC - symbol to put before explicit "cc -c" lines 1998dnl ECHO_CC - symbol to put before any "cc" line 1999dnl 2000AC_DEFUN([CF_DISABLE_ECHO],[ 2001AC_MSG_CHECKING(if you want to see long compiling messages) 2002CF_ARG_DISABLE(echo, 2003 [ --disable-echo do not display "compiling" commands], 2004 [ 2005 ECHO_LT='--silent' 2006 ECHO_LD='@echo linking [$]@;' 2007 RULE_CC='@echo compiling [$]<' 2008 SHOW_CC='@echo compiling [$]@' 2009 ECHO_CC='@' 2010],[ 2011 ECHO_LT='' 2012 ECHO_LD='' 2013 RULE_CC='' 2014 SHOW_CC='' 2015 ECHO_CC='' 2016]) 2017AC_MSG_RESULT($enableval) 2018AC_SUBST(ECHO_LT) 2019AC_SUBST(ECHO_LD) 2020AC_SUBST(RULE_CC) 2021AC_SUBST(SHOW_CC) 2022AC_SUBST(ECHO_CC) 2023])dnl 2024dnl --------------------------------------------------------------------------- 2025dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00 2026dnl ------------------------ 2027AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[ 2028AC_MSG_CHECKING(if we want to use GNAT projects) 2029CF_ARG_DISABLE(gnat-projects, 2030 [ --disable-gnat-projects test: disable GNAT projects even if usable], 2031 [enable_gnat_projects=no], 2032 [enable_gnat_projects=yes]) 2033AC_MSG_RESULT($enable_gnat_projects) 2034])dnl 2035dnl --------------------------------------------------------------------------- 2036dnl CF_DISABLE_LEAKS version: 9 updated: 2021/04/03 16:41:50 2037dnl ---------------- 2038dnl Combine no-leak checks with the libraries or tools that are used for the 2039dnl checks. 2040AC_DEFUN([CF_DISABLE_LEAKS],[ 2041 2042AC_REQUIRE([CF_WITH_DMALLOC]) 2043AC_REQUIRE([CF_WITH_DBMALLOC]) 2044AC_REQUIRE([CF_WITH_VALGRIND]) 2045 2046AC_MSG_CHECKING(if you want to perform memory-leak testing) 2047AC_ARG_ENABLE(leaks, 2048 [ --disable-leaks test: free permanent memory, analyze leaks], 2049 [enable_leaks=$enableval], 2050 [enable_leaks=yes]) 2051dnl with_no_leaks is more readable... 2052if test "x$enable_leaks" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi 2053AC_MSG_RESULT($with_no_leaks) 2054 2055if test "$enable_leaks" = no ; then 2056 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.]) 2057 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.]) 2058fi 2059])dnl 2060dnl --------------------------------------------------------------------------- 2061dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04 2062dnl -------------------------- 2063dnl Check if we should use the libtool 1.5 feature "-version-number" instead of 2064dnl the older "-version-info" feature. The newer feature allows us to use 2065dnl version numbering on shared libraries which make them compatible with 2066dnl various systems. 2067AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION], 2068[ 2069AC_MSG_CHECKING(if libtool -version-number should be used) 2070CF_ARG_DISABLE(libtool-version, 2071 [ --disable-libtool-version enable to use libtool's incompatible naming scheme], 2072 [cf_libtool_version=no], 2073 [cf_libtool_version=yes]) 2074AC_MSG_RESULT($cf_libtool_version) 2075 2076if test "$cf_libtool_version" = yes ; then 2077 LIBTOOL_VERSION="-version-number" 2078else 2079 LIBTOOL_VERSION="-version-info" 2080 case "x$VERSION" in 2081 (x) 2082 AC_MSG_WARN(VERSION was not set) 2083 ;; 2084 (x*.*.*) 2085 ABI_VERSION="$VERSION" 2086 CF_VERBOSE(ABI_VERSION: $ABI_VERSION) 2087 ;; 2088 (x*:*:*) 2089 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'` 2090 CF_VERBOSE(ABI_VERSION: $ABI_VERSION) 2091 ;; 2092 (*) 2093 AC_MSG_WARN(unexpected VERSION value: $VERSION) 2094 ;; 2095 esac 2096fi 2097 2098AC_SUBST(ABI_VERSION) 2099AC_SUBST(LIBTOOL_VERSION) 2100])dnl 2101dnl --------------------------------------------------------------------------- 2102dnl CF_DISABLE_RPATH_HACK version: 3 updated: 2021/01/05 20:14:44 2103dnl --------------------- 2104dnl The rpath-hack makes it simpler to build programs, particularly with the 2105dnl *BSD ports which may have essential libraries in unusual places. But it 2106dnl can interfere with building an executable for the base system. Use this 2107dnl option in that case. 2108AC_DEFUN([CF_DISABLE_RPATH_HACK], 2109[ 2110AC_MSG_CHECKING(if rpath-hack should be disabled) 2111CF_ARG_DISABLE(rpath-hack, 2112 [ --disable-rpath-hack don't add rpath options for additional libraries], 2113 [enable_rpath_hack=no], 2114 [enable_rpath_hack=yes]) 2115dnl TODO - drop cf_disable_rpath_hack 2116if test "x$enable_rpath_hack" = xno; then cf_disable_rpath_hack=yes; else cf_disable_rpath_hack=no; fi 2117AC_MSG_RESULT($cf_disable_rpath_hack) 2118 2119if test "$enable_rpath_hack" = yes ; then 2120 CF_RPATH_HACK 2121fi 2122]) 2123dnl --------------------------------------------------------------------------- 2124dnl CF_ENABLE_BROKEN_LINKER version: 2 updated: 2021/01/02 17:09:14 2125dnl ----------------------- 2126dnl Some linkers cannot reference a data-only object. Cygwin used to be one. 2127dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need 2128dnl an unconditional feature. 2129AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[ 2130 2131AC_MSG_CHECKING(if you want broken-linker support code) 2132AC_ARG_ENABLE(broken_linker, 2133 [ --enable-broken_linker compile with broken-linker support code], 2134 [with_broken_linker=$enableval], 2135 [with_broken_linker=no]) 2136AC_MSG_RESULT($with_broken_linker) 2137 2138: "${BROKEN_LINKER:=0}" 2139if test "x$with_broken_linker" = xyes ; then 2140 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules]) 2141 BROKEN_LINKER=1 2142fi 2143AC_SUBST(BROKEN_LINKER) 2144])dnl 2145dnl --------------------------------------------------------------------------- 2146dnl CF_ENABLE_PC_FILES version: 16 updated: 2021/11/20 12:48:37 2147dnl ------------------ 2148dnl This is the "--enable-pc-files" option, which is available if there is a 2149dnl pkg-config configuration on the local machine. 2150AC_DEFUN([CF_ENABLE_PC_FILES],[ 2151AC_REQUIRE([CF_PKG_CONFIG]) 2152AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR]) 2153 2154if test "x$PKG_CONFIG" != xnone 2155then 2156 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG) 2157else 2158 AC_MSG_CHECKING(if we should install .pc files) 2159fi 2160 2161AC_ARG_ENABLE(pc-files, 2162 [ --enable-pc-files generate and install .pc files for pkg-config], 2163 [enable_pc_files=$enableval], 2164 [enable_pc_files=no]) 2165AC_MSG_RESULT($enable_pc_files) 2166 2167if test "x$enable_pc_files" != xno 2168then 2169 MAKE_PC_FILES= 2170 case "x$PKG_CONFIG_LIBDIR" in 2171 (xno|xnone|xyes|x) 2172 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found) 2173 ;; 2174 (*) 2175 cf_pkg_config_libdir="$PKG_CONFIG_LIBDIR" 2176 CF_PATH_SYNTAX(cf_pkg_config_libdir) 2177 ;; 2178 esac 2179else 2180 MAKE_PC_FILES="#" 2181fi 2182AC_SUBST(MAKE_PC_FILES) 2183])dnl 2184dnl --------------------------------------------------------------------------- 2185dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42 2186dnl --------------- 2187dnl Check if the rpath option should be used, setting cache variable 2188dnl cf_cv_enable_rpath if so. 2189AC_DEFUN([CF_ENABLE_RPATH], 2190[ 2191AC_MSG_CHECKING(if rpath option should be used) 2192AC_ARG_ENABLE(rpath, 2193[ --enable-rpath use rpath option when generating shared libraries], 2194[cf_cv_enable_rpath=$enableval], 2195[cf_cv_enable_rpath=no]) 2196AC_MSG_RESULT($cf_cv_enable_rpath) 2197])dnl 2198dnl --------------------------------------------------------------------------- 2199dnl CF_ENABLE_STRING_HACKS version: 6 updated: 2021/01/05 19:23:48 2200dnl ---------------------- 2201dnl On a few platforms, the compiler and/or loader nags with untruthful 2202dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect, 2203dnl and implying that most uses of the recommended alternatives are correct. 2204dnl 2205dnl Factually speaking, no one has actually counted the number of uses of these 2206dnl functions versus the total of incorrect uses. Samples of a few thousand 2207dnl instances are meaningless compared to the hundreds of millions of lines of 2208dnl existing C code. 2209dnl 2210dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some 2211dnl platforms, in implementations of varying quality. Likewise, snprintf is 2212dnl standard - but evolved through phases, and older implementations are likely 2213dnl to yield surprising results, as documented in manpages on various systems. 2214AC_DEFUN([CF_ENABLE_STRING_HACKS], 2215[ 2216AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings) 2217AC_ARG_ENABLE(string-hacks, 2218 [ --enable-string-hacks work around bogus compiler/loader warnings], 2219 [enable_string_hacks=$enableval], 2220 [enable_string_hacks=no]) 2221AC_MSG_RESULT($enable_string_hacks) 2222 2223if test "x$enable_string_hacks" = "xyes"; then 2224 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings]) 2225 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings) 2226 AC_CHECK_FUNC(strlcat,[ 2227 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function]) 2228 ],[ 2229 AC_CHECK_LIB(bsd,strlcat,[ 2230 CF_ADD_LIB(bsd) 2231 AC_CHECK_HEADERS(bsd/string.h) 2232 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function]) 2233 ]) 2234 ]) 2235 AC_CHECK_FUNCS( strlcpy snprintf ) 2236fi 2237])dnl 2238dnl --------------------------------------------------------------------------- 2239dnl CF_ENABLE_WARNINGS version: 9 updated: 2021/01/05 19:40:50 2240dnl ------------------ 2241dnl Configure-option to enable gcc warnings 2242dnl 2243dnl $1 = extra options to add, if supported 2244dnl $2 = option for checking attributes. By default, this is done when 2245dnl warnings are enabled. For other values: 2246dnl yes: always do this, e.g., to use in generated library-headers 2247dnl no: never do this 2248AC_DEFUN([CF_ENABLE_WARNINGS],[ 2249if test "$GCC" = yes || test "$GXX" = yes 2250then 2251CF_FIX_WARNINGS(CFLAGS) 2252CF_FIX_WARNINGS(CPPFLAGS) 2253CF_FIX_WARNINGS(LDFLAGS) 2254AC_MSG_CHECKING(if you want to turn on gcc warnings) 2255CF_ARG_ENABLE(warnings, 2256 [ --enable-warnings test: turn on gcc compiler warnings], 2257 [enable_warnings=yes], 2258 [enable_warnings=no]) 2259AC_MSG_RESULT($enable_warnings) 2260if test "$enable_warnings" = "yes" 2261then 2262 ifelse($2,,[CF_GCC_ATTRIBUTES]) 2263 CF_GCC_WARNINGS($1) 2264fi 2265ifelse($2,yes,[CF_GCC_ATTRIBUTES]) 2266fi 2267])dnl 2268dnl --------------------------------------------------------------------------- 2269dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39 2270dnl -------- 2271dnl Check if 'errno' is declared in <errno.h> 2272AC_DEFUN([CF_ERRNO], 2273[ 2274CF_CHECK_ERRNO(errno) 2275])dnl 2276dnl --------------------------------------------------------------------------- 2277dnl CF_ETIP_DEFINES version: 7 updated: 2023/10/28 11:59:01 2278dnl --------------- 2279dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between 2280dnl math.h and builtin.h, only for ncurses 2281AC_DEFUN([CF_ETIP_DEFINES], 2282[ 2283AC_MSG_CHECKING(for special defines needed for etip.h) 2284cf_save_CXXFLAGS="$CXXFLAGS" 2285cf_result="none" 2286 2287# etip.h includes ncurses.h which includes ncurses_dll.h 2288# But ncurses_dll.h is generated - fix here. 2289test -d include || mkdir include 2290test -f include/ncurses_dll.h || sed -e 's/@NCURSES_WRAP_PREFIX@/'$NCURSES_WRAP_PREFIX'/g' "${srcdir}/include/ncurses_dll.h.in" >include/ncurses_dll.h 2291 2292for cf_math in "" MATH_H 2293do 2294for cf_excp in "" MATH_EXCEPTION 2295do 2296 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include" 2297 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}" 2298 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}" 2299AC_TRY_COMPILE([ 2300#include <etip.h.in> 2301],[],[ 2302 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math}) 2303 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp}) 2304 cf_result="$cf_math $cf_excp" 2305 break 2 2306],[]) 2307done 2308done 2309AC_MSG_RESULT([${cf_result:-(none)}]) 2310CXXFLAGS="$cf_save_CXXFLAGS" 2311]) 2312dnl --------------------------------------------------------------------------- 2313dnl CF_FIND_LINKAGE version: 22 updated: 2020/12/31 20:19:42 2314dnl --------------- 2315dnl Find a library (specifically the linkage used in the code fragment), 2316dnl searching for it if it is not already in the library path. 2317dnl See also CF_ADD_SEARCHPATH. 2318dnl 2319dnl Parameters (4-on are optional): 2320dnl $1 = headers for library entrypoint 2321dnl $2 = code fragment for library entrypoint 2322dnl $3 = the library name without the "-l" option or ".so" suffix. 2323dnl $4 = action to perform if successful (default: update CPPFLAGS, etc) 2324dnl $5 = action to perform if not successful 2325dnl $6 = module name, if not the same as the library name 2326dnl $7 = extra libraries 2327dnl 2328dnl Sets these variables: 2329dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found 2330dnl $cf_cv_header_path_$3 - include-directory if needed 2331dnl $cf_cv_library_path_$3 - library-directory if needed 2332dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3 2333AC_DEFUN([CF_FIND_LINKAGE],[ 2334 2335# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these 2336# will be set on completion of the AC_TRY_LINK below. 2337cf_cv_header_path_$3= 2338cf_cv_library_path_$3= 2339 2340CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)]) 2341 2342cf_save_LIBS="$LIBS" 2343 2344AC_TRY_LINK([$1],[$2],[ 2345 cf_cv_find_linkage_$3=yes 2346 cf_cv_header_path_$3=/usr/include 2347 cf_cv_library_path_$3=/usr/lib 2348],[ 2349 2350LIBS="-l$3 $7 $cf_save_LIBS" 2351 2352AC_TRY_LINK([$1],[$2],[ 2353 cf_cv_find_linkage_$3=yes 2354 cf_cv_header_path_$3=/usr/include 2355 cf_cv_library_path_$3=/usr/lib 2356 cf_cv_library_file_$3="-l$3" 2357],[ 2358 cf_cv_find_linkage_$3=no 2359 LIBS="$cf_save_LIBS" 2360 2361 CF_VERBOSE(find linkage for $3 library) 2362 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)]) 2363 2364 cf_save_CPPFLAGS="$CPPFLAGS" 2365 cf_test_CPPFLAGS="$CPPFLAGS" 2366 2367 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6])) 2368 for cf_cv_header_path_$3 in $cf_search 2369 do 2370 if test -d "$cf_cv_header_path_$3" ; then 2371 CF_VERBOSE(... testing $cf_cv_header_path_$3) 2372 CPPFLAGS="$cf_save_CPPFLAGS" 2373 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3) 2374 AC_TRY_COMPILE([$1],[$2],[ 2375 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3) 2376 cf_cv_find_linkage_$3=maybe 2377 cf_test_CPPFLAGS="$CPPFLAGS" 2378 break],[ 2379 CPPFLAGS="$cf_save_CPPFLAGS" 2380 ]) 2381 fi 2382 done 2383 2384 if test "$cf_cv_find_linkage_$3" = maybe ; then 2385 2386 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)]) 2387 2388 cf_save_LIBS="$LIBS" 2389 cf_save_LDFLAGS="$LDFLAGS" 2390 2391 ifelse([$6],,,[ 2392 CPPFLAGS="$cf_test_CPPFLAGS" 2393 LIBS="-l$3 $7 $cf_save_LIBS" 2394 AC_TRY_LINK([$1],[$2],[ 2395 CF_VERBOSE(... found $3 library in system) 2396 cf_cv_find_linkage_$3=yes]) 2397 CPPFLAGS="$cf_save_CPPFLAGS" 2398 LIBS="$cf_save_LIBS" 2399 ]) 2400 2401 if test "$cf_cv_find_linkage_$3" != yes ; then 2402 CF_LIBRARY_PATH(cf_search,$3) 2403 for cf_cv_library_path_$3 in $cf_search 2404 do 2405 if test -d "$cf_cv_library_path_$3" ; then 2406 CF_VERBOSE(... testing $cf_cv_library_path_$3) 2407 CPPFLAGS="$cf_test_CPPFLAGS" 2408 LIBS="-l$3 $7 $cf_save_LIBS" 2409 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3" 2410 AC_TRY_LINK([$1],[$2],[ 2411 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3) 2412 cf_cv_find_linkage_$3=yes 2413 cf_cv_library_file_$3="-l$3" 2414 break],[ 2415 CPPFLAGS="$cf_save_CPPFLAGS" 2416 LIBS="$cf_save_LIBS" 2417 LDFLAGS="$cf_save_LDFLAGS" 2418 ]) 2419 fi 2420 done 2421 CPPFLAGS="$cf_save_CPPFLAGS" 2422 LDFLAGS="$cf_save_LDFLAGS" 2423 fi 2424 2425 else 2426 cf_cv_find_linkage_$3=no 2427 fi 2428 ],$7) 2429]) 2430 2431LIBS="$cf_save_LIBS" 2432 2433if test "$cf_cv_find_linkage_$3" = yes ; then 2434ifelse([$4],,[ 2435 CF_ADD_INCDIR($cf_cv_header_path_$3) 2436 CF_ADD_LIBDIR($cf_cv_library_path_$3) 2437 CF_ADD_LIB($3) 2438],[$4]) 2439else 2440ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5]) 2441fi 2442])dnl 2443dnl --------------------------------------------------------------------------- 2444dnl CF_FIND_SUB_INCDIR version: 3 updated: 2021/01/01 13:31:04 2445dnl ------------------ 2446dnl Find an include-directory with the given leaf-name. This is useful for 2447dnl example with FreeBSD ports, which use this convention to distinguish 2448dnl different versions of the same port. 2449AC_DEFUN([CF_FIND_SUB_INCDIR],[ 2450 CF_SUBDIR_PATH(cf_search,$1,include) 2451 for cf_item in $cf_search 2452 do 2453 case "$cf_item" in 2454 (*/$1) 2455 CF_ADD_INCDIR($cf_item) 2456 ;; 2457 esac 2458 done 2459])dnl 2460dnl --------------------------------------------------------------------------- 2461dnl CF_FIND_SUB_LIBDIR version: 3 updated: 2021/01/01 13:31:04 2462dnl ------------------ 2463dnl Find a library-directory with the given leaf-name. This is useful for 2464dnl example with FreeBSD ports, which use this convention to distinguish 2465dnl different versions of the same port. 2466AC_DEFUN([CF_FIND_SUB_LIBDIR],[ 2467 CF_SUBDIR_PATH(cf_search,$1,lib) 2468 for cf_item in $cf_search 2469 do 2470 case "$cf_item" in 2471 (*/$1) 2472 CF_ADD_LIBDIR($cf_item) 2473 ;; 2474 esac 2475 done 2476])dnl 2477dnl --------------------------------------------------------------------------- 2478dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04 2479dnl ----------------- 2480dnl make ADAFLAGS consistent with CFLAGS 2481AC_DEFUN([CF_FIXUP_ADAFLAGS],[ 2482 AC_MSG_CHECKING(optimization options for ADAFLAGS) 2483 case "$CFLAGS" in 2484 (*-g*) 2485 CF_ADD_ADAFLAGS(-g) 2486 ;; 2487 esac 2488 case "$CFLAGS" in 2489 (*-O*) 2490 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'` 2491 CF_ADD_ADAFLAGS($cf_O_flag) 2492 ;; 2493 esac 2494 AC_MSG_RESULT($ADAFLAGS) 2495])dnl 2496dnl --------------------------------------------------------------------------- 2497dnl CF_FIX_WARNINGS version: 4 updated: 2021/12/16 18:22:31 2498dnl --------------- 2499dnl Warning flags do not belong in CFLAGS, CPPFLAGS, etc. Any of gcc's 2500dnl "-Werror" flags can interfere with configure-checks. Those go into 2501dnl EXTRA_CFLAGS. 2502dnl 2503dnl $1 = variable name to repair 2504define([CF_FIX_WARNINGS],[ 2505if test "$GCC" = yes || test "$GXX" = yes 2506then 2507 case [$]$1 in 2508 (*-Werror=*) 2509 cf_temp_flags= 2510 for cf_temp_scan in [$]$1 2511 do 2512 case "x$cf_temp_scan" in 2513 (x-Werror=format*) 2514 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan) 2515 ;; 2516 (x-Werror=*) 2517 CF_APPEND_TEXT(EXTRA_CFLAGS,$cf_temp_scan) 2518 ;; 2519 (*) 2520 CF_APPEND_TEXT(cf_temp_flags,$cf_temp_scan) 2521 ;; 2522 esac 2523 done 2524 if test "x[$]$1" != "x$cf_temp_flags" 2525 then 2526 CF_VERBOSE(repairing $1: [$]$1) 2527 $1="$cf_temp_flags" 2528 CF_VERBOSE(... fixed [$]$1) 2529 CF_VERBOSE(... extra $EXTRA_CFLAGS) 2530 fi 2531 ;; 2532 esac 2533fi 2534AC_SUBST(EXTRA_CFLAGS) 2535])dnl 2536dnl --------------------------------------------------------------------------- 2537dnl CF_FOPEN_BIN_R version: 3 updated: 2023/01/05 18:05:46 2538dnl -------------- 2539dnl Check if fopen works when the "b" (binary) flag is added to the mode 2540dnl parameter. POSIX ignores the "b", which c89 specified. Some very old 2541dnl systems do not accept it. 2542AC_DEFUN([CF_FOPEN_BIN_R],[ 2543AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[ 2544 AC_TRY_RUN([ 2545$ac_includes_default 2546 2547int main(void) 2548{ 2549 FILE *fp = fopen("conftest.tmp", "wb"); 2550 int rc = 0; 2551 if (fp != 0) { 2552 int p, q; 2553 for (p = 0; p < 256; ++p) { 2554 fputc(p, fp); 2555 } 2556 fclose(fp); 2557 fp = fopen("conftest.tmp", "rb"); 2558 if (fp != 0) { 2559 for (p = 0; p < 256; ++p) { 2560 q = fgetc(fp); 2561 if (q != p) { 2562 rc = 1; 2563 break; 2564 } 2565 } 2566 } else { 2567 rc = 1; 2568 } 2569 } else { 2570 rc = 1; 2571 } 2572 ${cf_cv_main_return:-return} (rc); 2573} 2574], 2575 [cf_cv_fopen_bin_r=yes], 2576 [cf_cv_fopen_bin_r=no], 2577 [cf_cv_fopen_bin_r=unknown]) 2578]) 2579test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode]) 2580])dnl 2581dnl --------------------------------------------------------------------------- 2582dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09 2583dnl -------------- 2584dnl Forget that we saw the given tool. 2585AC_DEFUN([CF_FORGET_TOOL],[ 2586unset ac_cv_prog_ac_ct_$1 2587unset ac_ct_$1 2588unset $1 2589])dnl 2590dnl --------------------------------------------------------------------------- 2591dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44 2592dnl ------------- 2593dnl Test for dlsym() and related functions, as well as libdl. 2594dnl 2595dnl Sets 2596dnl $cf_have_dlsym 2597dnl $cf_have_libdl 2598AC_DEFUN([CF_FUNC_DLSYM],[ 2599cf_have_dlsym=no 2600AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[ 2601 2602cf_have_libdl=no 2603AC_CHECK_LIB(dl,dlsym,[ 2604 cf_have_dlsym=yes 2605 cf_have_libdl=yes])]) 2606 2607if test "$cf_have_dlsym" = yes ; then 2608 test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) } 2609 2610 AC_MSG_CHECKING(whether able to link to dl*() functions) 2611 AC_TRY_LINK([#include <dlfcn.h>],[ 2612 void *obj; 2613 if ((obj = dlopen("filename", 0)) != 0) { 2614 if (dlsym(obj, "symbolname") == 0) { 2615 dlclose(obj); 2616 } 2617 }],[ 2618 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[ 2619 AC_MSG_ERROR(Cannot link test program for libdl)]) 2620 AC_MSG_RESULT(ok) 2621else 2622 AC_MSG_ERROR(Cannot find dlsym function) 2623fi 2624]) 2625dnl --------------------------------------------------------------------------- 2626dnl CF_FUNC_GETTIME version: 2 updated: 2023/02/25 08:45:56 2627dnl --------------- 2628dnl Check for gettimeofday or clock_gettime. In 2023, the former is still more 2629dnl widely supported, but "deprecated" (2008), so we will use the latter if it 2630dnl is available, to reduce compiler warnings. 2631AC_DEFUN([CF_FUNC_GETTIME],[ 2632AC_CACHE_CHECK(for clock_gettime,cf_cv_func_clock_gettime,[ 2633 AC_TRY_LINK([#include <time.h>], 2634 [struct timespec ts; 2635 int rc = clock_gettime(CLOCK_REALTIME, &ts); (void) rc; (void)ts], 2636 [cf_cv_func_clock_gettime=yes], 2637 [cf_cv_func_clock_gettime=no]) 2638]) 2639 2640if test "$cf_cv_func_clock_gettime" = yes 2641then 2642 AC_DEFINE(HAVE_CLOCK_GETTIME,1,[Define to 1 if we have clock_gettime function]) 2643else 2644AC_CHECK_FUNC(gettimeofday, 2645 AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]),[ 2646 2647AC_CHECK_LIB(bsd, gettimeofday, 2648 AC_DEFINE(HAVE_GETTIMEOFDAY,1,[Define to 1 if we have gettimeofday function]) 2649 CF_ADD_LIB(bsd))])dnl CLIX: bzero, select, gettimeofday 2650fi 2651])dnl 2652dnl --------------------------------------------------------------------------- 2653dnl CF_FUNC_GETTTYNAM version: 2 updated: 2023/01/05 18:06:28 2654dnl ----------------- 2655dnl Check if the 4.3BSD function getttyname exists, as well as if <ttyent.h> 2656dnl defines the _PATH_TTYS symbol. If the corresponding file exists, but the 2657dnl other checks fail, just define HAVE_PATH_TTYS. 2658AC_DEFUN([CF_FUNC_GETTTYNAM],[ 2659AC_CACHE_CHECK(if _PATH_TTYS is defined in ttyent.h,cf_cv_PATH_TTYS,[ 2660AC_TRY_COMPILE([ 2661#include <stdio.h> 2662#include <ttyent.h>],[ 2663FILE *fp = fopen(_PATH_TTYS, "r"); (void)fp], 2664 [cf_cv_PATH_TTYS=yes], 2665 [cf_cv_PATH_TTYS=no])]) 2666 2667if test $cf_cv_PATH_TTYS = no 2668then 2669 for cf_ttys in /etc/ttytype /etc/ttys 2670 do 2671 if test -f $cf_ttys 2672 then 2673 cf_cv_PATH_TTYS=maybe 2674 AC_DEFINE(_PATH_TTYS,$cf_ttys,[define to pathname of file containing mapping from tty name to terminal type]) 2675 break 2676 fi 2677 done 2678fi 2679 2680if test $cf_cv_PATH_TTYS != no 2681then 2682 AC_CACHE_CHECK(if _PATH_TTYS file exists,cf_cv_have_PATH_TTYS,[ 2683 AC_TRY_RUN([ 2684$ac_includes_default 2685 2686#include <ttyent.h> 2687 2688int main(void) { 2689 FILE *fp = fopen(_PATH_TTYS, "r"); 2690 ${cf_cv_main_return:-return} (fp == 0); 2691}], 2692 [cf_cv_have_PATH_TTYS=yes], 2693 [cf_cv_have_PATH_TTYS=no], 2694 [cf_cv_have_PATH_TTYS=unknown])]) 2695 test "$cf_cv_have_PATH_TTYS" = no && cf_cv_PATH_TTYS=no 2696fi 2697 2698if test $cf_cv_PATH_TTYS != no 2699then 2700 AC_DEFINE(HAVE_PATH_TTYS,1,[define to 1 if system can map tty name to terminal type]) 2701 AC_CACHE_CHECK(for getttynam,cf_cv_func_getttynam,[ 2702 AC_TRY_LINK([#include <ttyent.h>], 2703 [struct ttyent *fp = getttynam("/dev/tty"); (void)fp], 2704 [cf_cv_func_getttynam=yes], 2705 [cf_cv_func_getttynam=no])]) 2706 test "$cf_cv_func_getttynam" = yes && AC_DEFINE(HAVE_GETTTYNAM) 2707fi 2708])dnl 2709dnl --------------------------------------------------------------------------- 2710dnl CF_FUNC_MEMMOVE version: 10 updated: 2023/01/05 18:51:28 2711dnl --------------- 2712dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither 2713dnl is found, add our own version of memmove to the list of objects. 2714AC_DEFUN([CF_FUNC_MEMMOVE], 2715[ 2716AC_CHECK_FUNC(memmove,,[ 2717AC_CHECK_FUNC(bcopy,[ 2718 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ 2719 AC_TRY_RUN([ 2720$ac_includes_default 2721 2722int main(void) { 2723 static char data[] = "abcdefghijklmnopqrstuwwxyz"; 2724 char temp[40]; 2725 bcopy(data, temp, sizeof(data)); 2726 bcopy(temp+10, temp, 15); 2727 bcopy(temp+5, temp+15, 10); 2728 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); 2729} 2730 ], 2731 [cf_cv_good_bcopy=yes], 2732 [cf_cv_good_bcopy=no], 2733 [cf_cv_good_bcopy=unknown]) 2734 ]) 2735 ],[cf_cv_good_bcopy=no]) 2736 if test "$cf_cv_good_bcopy" = yes ; then 2737 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable]) 2738 else 2739 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable]) 2740 fi 2741])])dnl 2742dnl --------------------------------------------------------------------------- 2743dnl CF_FUNC_NANOSLEEP version: 6 updated: 2023/01/05 18:51:33 2744dnl ----------------- 2745dnl Check for existence of workable nanosleep() function. Some systems, e.g., 2746dnl AIX 4.x, provide a non-working version. 2747AC_DEFUN([CF_FUNC_NANOSLEEP],[ 2748AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[ 2749AC_TRY_RUN([ 2750$ac_includes_default 2751 2752#include <errno.h> 2753#include <time.h> 2754 2755#ifdef HAVE_SYS_TIME_H 2756#include <sys/time.h> 2757#endif 2758 2759int main(void) { 2760 struct timespec ts1, ts2; 2761 int code; 2762 ts1.tv_sec = 0; 2763 ts1.tv_nsec = 750000000; 2764 ts2.tv_sec = 0; 2765 ts2.tv_nsec = 0; 2766 errno = 0; 2767 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */ 2768 ${cf_cv_main_return:-return}(code != 0); 2769} 2770], 2771 [cf_cv_func_nanosleep=yes], 2772 [cf_cv_func_nanosleep=no], 2773 [cf_cv_func_nanosleep=unknown])]) 2774 2775test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()]) 2776]) 2777dnl --------------------------------------------------------------------------- 2778dnl CF_FUNC_OPENPTY version: 7 updated: 2023/12/03 09:21:34 2779dnl --------------- 2780dnl Check for openpty() function, along with <pty.h> header. It may need the 2781dnl "util" library as well. 2782AC_DEFUN([CF_FUNC_OPENPTY], 2783[ 2784AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no) 2785AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[ 2786 cf_save_LIBS="$LIBS" 2787 test "$cf_cv_lib_util" = yes && { CF_ADD_LIB(util) } 2788 for cf_header in pty.h libutil.h util.h 2789 do 2790 AC_TRY_LINK([ 2791#include <$cf_header> 2792],[ 2793 int x = openpty((int *)0, (int *)0, (char *)0, 2794 (struct termios *)0, (struct winsize *)0); 2795 (void)x; 2796],[ 2797 cf_cv_func_openpty=$cf_header 2798 break 2799],[ 2800 cf_cv_func_openpty=no 2801]) 2802 done 2803 LIBS="$cf_save_LIBS" 2804]) 2805])dnl 2806dnl --------------------------------------------------------------------------- 2807dnl CF_FUNC_POLL version: 11 updated: 2023/01/05 18:51:40 2808dnl ------------ 2809dnl See if the poll function really works. Some platforms have poll(), but 2810dnl it does not work for terminals or files. 2811AC_DEFUN([CF_FUNC_POLL],[ 2812tty >/dev/null 2>&1 || { AC_CHECK_FUNCS(posix_openpt) } 2813AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[ 2814AC_TRY_RUN([ 2815$ac_includes_default 2816 2817#include <fcntl.h> 2818 2819#ifdef HAVE_POLL_H 2820#include <poll.h> 2821#else 2822#include <sys/poll.h> 2823#endif 2824 2825int main(void) { 2826 struct pollfd myfds; 2827 int ret; 2828 2829 /* check for Darwin bug with respect to "devices" */ 2830 myfds.fd = open("/dev/null", 1); /* O_WRONLY */ 2831 if (myfds.fd < 0) 2832 myfds.fd = 0; 2833 myfds.events = POLLIN; 2834 myfds.revents = 0; 2835 2836 ret = poll(&myfds, 1, 100); 2837 2838 if (ret < 0 || (myfds.revents & POLLNVAL)) { 2839 ret = -1; 2840 } else { 2841 int fd = 0; 2842 if (!isatty(fd)) { 2843 fd = open("/dev/tty", 2); /* O_RDWR */ 2844 } 2845#ifdef HAVE_POSIX_OPENPT 2846 if (fd < 0) { 2847 fd = posix_openpt(O_RDWR); 2848 } 2849#endif 2850 2851 if (fd >= 0) { 2852 /* also check with standard input */ 2853 myfds.fd = fd; 2854 myfds.events = POLLIN; 2855 myfds.revents = 0; 2856 ret = poll(&myfds, 1, 100); 2857 } else { 2858 ret = -1; 2859 } 2860 } 2861 ${cf_cv_main_return:-return}(ret < 0); 2862}], 2863 [cf_cv_working_poll=yes], 2864 [cf_cv_working_poll=no], 2865 [cf_cv_working_poll=unknown])]) 2866test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work]) 2867])dnl 2868dnl --------------------------------------------------------------------------- 2869dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13 2870dnl --------------- 2871dnl Some old/broken variations define tcgetattr() only as a macro in 2872dnl termio(s).h 2873AC_DEFUN([CF_FUNC_TERMIOS],[ 2874AC_REQUIRE([CF_STRUCT_TERMIOS]) 2875AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[ 2876AC_TRY_LINK([ 2877#include <sys/types.h> 2878#ifdef HAVE_UNISTD_H 2879#include <unistd.h> 2880#endif 2881#ifdef HAVE_TERMIOS_H 2882#include <termios.h> 2883#define TTY struct termios 2884#else 2885#ifdef HAVE_TERMIO_H 2886#include <termio.h> 2887#define TTY struct termio 2888#endif 2889#endif 2890],[ 2891TTY foo; 2892tcgetattr(1, &foo);], 2893[cf_cv_have_tcgetattr=yes], 2894[cf_cv_have_tcgetattr=no])]) 2895test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr]) 2896])dnl 2897dnl --------------------------------------------------------------------------- 2898dnl CF_FUNC_VSSCANF version: 8 updated: 2023/12/03 19:09:59 2899dnl --------------- 2900dnl Check for vsscanf() function, which is in c9x but generally not in earlier 2901dnl versions of C. It can often be simulated by other functions on older 2902dnl systems (where FILE is not opaque). 2903AC_DEFUN([CF_FUNC_VSSCANF], 2904[ 2905AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[ 2906AC_TRY_LINK([ 2907#include <stdarg.h> 2908#include <stdio.h> 2909 2910static void 2911myfunc(const char *str, const char *fmt, ...) 2912{ 2913 va_list ap; 2914 va_start(ap, fmt); 2915 vsscanf(str, fmt, ap); 2916 va_end(ap); 2917} 2918],[ 2919 myfunc("55", "%d"); 2920],[cf_cv_func_vsscanf=vsscanf],[ 2921AC_TRY_LINK([ 2922#include <stdarg.h> 2923#include <stdio.h>],[ 2924 FILE strbuf; 2925 char *str = "from"; 2926 2927 strbuf._flag = _IOREAD; 2928 strbuf._ptr = strbuf._base = (unsigned char *) str; 2929 strbuf._cnt = strlen(str); 2930 strbuf._file = _NFILE; 2931 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[ 2932AC_TRY_LINK([ 2933#include <stdarg.h> 2934#include <stdio.h>],[ 2935 FILE strbuf; 2936 char *str = "from"; 2937 2938 strbuf._flag = _IOREAD; 2939 strbuf._ptr = strbuf._base = (unsigned char *) str; 2940 strbuf._cnt = strlen(str); 2941 strbuf._file = _NFILE; 2942 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[ 2943cf_cv_func_vsscanf=no])])])]) 2944 2945case "$cf_cv_func_vsscanf" in 2946(vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);; 2947(vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);; 2948(_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);; 2949esac 2950 2951])dnl 2952dnl --------------------------------------------------------------------------- 2953dnl CF_GCC_ATTRIBUTES version: 24 updated: 2021/03/20 12:00:25 2954dnl ----------------- 2955dnl Test for availability of useful gcc __attribute__ directives to quiet 2956dnl compiler warnings. Though useful, not all are supported -- and contrary 2957dnl to documentation, unrecognized directives cause older compilers to barf. 2958AC_DEFUN([CF_GCC_ATTRIBUTES], 2959[AC_REQUIRE([AC_PROG_FGREP])dnl 2960AC_REQUIRE([CF_C11_NORETURN])dnl 2961 2962if test "$GCC" = yes || test "$GXX" = yes 2963then 2964cat > conftest.i <<EOF 2965#ifndef GCC_PRINTF 2966#define GCC_PRINTF 0 2967#endif 2968#ifndef GCC_SCANF 2969#define GCC_SCANF 0 2970#endif 2971#ifndef GCC_NORETURN 2972#define GCC_NORETURN /* nothing */ 2973#endif 2974#ifndef GCC_UNUSED 2975#define GCC_UNUSED /* nothing */ 2976#endif 2977EOF 2978if test "$GCC" = yes 2979then 2980 AC_CHECKING([for $CC __attribute__ directives]) 2981cat > "conftest.$ac_ext" <<EOF 2982#line __oline__ "${as_me:-configure}" 2983#include <stdio.h> 2984#include "confdefs.h" 2985#include "conftest.h" 2986#include "conftest.i" 2987#if GCC_PRINTF 2988#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var))) 2989#else 2990#define GCC_PRINTFLIKE(fmt,var) /*nothing*/ 2991#endif 2992#if GCC_SCANF 2993#define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var))) 2994#else 2995#define GCC_SCANFLIKE(fmt,var) /*nothing*/ 2996#endif 2997extern void wow(char *,...) GCC_SCANFLIKE(1,2); 2998extern GCC_NORETURN void oops(char *,...) GCC_PRINTFLIKE(1,2); 2999extern GCC_NORETURN void foo(void); 3000int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { (void)argc; (void)argv; return 0; } 3001EOF 3002 cf_printf_attribute=no 3003 cf_scanf_attribute=no 3004 for cf_attribute in scanf printf unused noreturn 3005 do 3006 CF_UPPER(cf_ATTRIBUTE,$cf_attribute) 3007 cf_directive="__attribute__(($cf_attribute))" 3008 echo "checking for $CC $cf_directive" 1>&AC_FD_CC 3009 3010 case "$cf_attribute" in 3011 (printf) 3012 cf_printf_attribute=yes 3013 cat >conftest.h <<EOF 3014#define GCC_$cf_ATTRIBUTE 1 3015EOF 3016 ;; 3017 (scanf) 3018 cf_scanf_attribute=yes 3019 cat >conftest.h <<EOF 3020#define GCC_$cf_ATTRIBUTE 1 3021EOF 3022 ;; 3023 (*) 3024 cat >conftest.h <<EOF 3025#define GCC_$cf_ATTRIBUTE $cf_directive 3026EOF 3027 ;; 3028 esac 3029 3030 if AC_TRY_EVAL(ac_compile); then 3031 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute) 3032 cat conftest.h >>confdefs.h 3033 case "$cf_attribute" in 3034 (noreturn) 3035 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc]) 3036 ;; 3037 (printf) 3038 cf_value='/* nothing */' 3039 if test "$cf_printf_attribute" != no ; then 3040 cf_value='__attribute__((format(printf,fmt,var)))' 3041 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.]) 3042 fi 3043 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc]) 3044 ;; 3045 (scanf) 3046 cf_value='/* nothing */' 3047 if test "$cf_scanf_attribute" != no ; then 3048 cf_value='__attribute__((format(scanf,fmt,var)))' 3049 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.]) 3050 fi 3051 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc]) 3052 ;; 3053 (unused) 3054 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc]) 3055 ;; 3056 esac 3057 fi 3058 done 3059else 3060 ${FGREP-fgrep} define conftest.i >>confdefs.h 3061fi 3062rm -rf ./conftest* 3063fi 3064])dnl 3065dnl --------------------------------------------------------------------------- 3066dnl CF_GCC_VERSION version: 9 updated: 2023/03/05 14:30:13 3067dnl -------------- 3068dnl Find version of gcc, and (because icc/clang pretend to be gcc without being 3069dnl compatible), attempt to determine if icc/clang is actually used. 3070AC_DEFUN([CF_GCC_VERSION],[ 3071AC_REQUIRE([AC_PROG_CC]) 3072GCC_VERSION=none 3073if test "$GCC" = yes ; then 3074 AC_MSG_CHECKING(version of $CC) 3075 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" 3076 test -z "$GCC_VERSION" && GCC_VERSION=unknown 3077 AC_MSG_RESULT($GCC_VERSION) 3078fi 3079CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS) 3080CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS) 3081])dnl 3082dnl --------------------------------------------------------------------------- 3083dnl CF_GCC_WARNINGS version: 41 updated: 2021/01/01 16:53:59 3084dnl --------------- 3085dnl Check if the compiler supports useful warning options. There's a few that 3086dnl we don't use, simply because they're too noisy: 3087dnl 3088dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) 3089dnl -Winline (usually not worthwhile) 3090dnl -Wredundant-decls (system headers make this too noisy) 3091dnl -Wtraditional (combines too many unrelated messages, only a few useful) 3092dnl -Wwrite-strings (too noisy, but should review occasionally). This 3093dnl is enabled for ncurses using "--enable-const". 3094dnl -pedantic 3095dnl 3096dnl Parameter: 3097dnl $1 is an optional list of gcc warning flags that a particular 3098dnl application might want to use, e.g., "no-unused" for 3099dnl -Wno-unused 3100dnl Special: 3101dnl If $with_ext_const is "yes", add a check for -Wwrite-strings 3102dnl 3103AC_DEFUN([CF_GCC_WARNINGS], 3104[ 3105AC_REQUIRE([CF_GCC_VERSION]) 3106if test "x$have_x" = xyes; then CF_CONST_X_STRING fi 3107cat > "conftest.$ac_ext" <<EOF 3108#line __oline__ "${as_me:-configure}" 3109int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; } 3110EOF 3111if test "$INTEL_COMPILER" = yes 3112then 3113# The "-wdXXX" options suppress warnings: 3114# remark #1419: external declaration in primary source file 3115# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 3116# remark #1684: conversion from pointer to same-sized integral type (potential portability problem) 3117# remark #193: zero used for undefined preprocessing identifier 3118# remark #593: variable "curs_sb_left_arrow" was set but never used 3119# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits 3120# remark #869: parameter "tw" was never referenced 3121# remark #981: operands are evaluated in unspecified order 3122# warning #279: controlling expression is constant 3123 3124 AC_CHECKING([for $CC warning options]) 3125 cf_save_CFLAGS="$CFLAGS" 3126 EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall" 3127 for cf_opt in \ 3128 wd1419 \ 3129 wd1683 \ 3130 wd1684 \ 3131 wd193 \ 3132 wd593 \ 3133 wd279 \ 3134 wd810 \ 3135 wd869 \ 3136 wd981 3137 do 3138 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" 3139 if AC_TRY_EVAL(ac_compile); then 3140 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3141 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" 3142 fi 3143 done 3144 CFLAGS="$cf_save_CFLAGS" 3145elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown" 3146then 3147 AC_CHECKING([for $CC warning options]) 3148 cf_save_CFLAGS="$CFLAGS" 3149 cf_warn_CONST="" 3150 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings" 3151 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs" 3152 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings= 3153 for cf_opt in W Wall \ 3154 Wbad-function-cast \ 3155 Wcast-align \ 3156 Wcast-qual \ 3157 Wdeclaration-after-statement \ 3158 Wextra \ 3159 Winline \ 3160 Wmissing-declarations \ 3161 Wmissing-prototypes \ 3162 Wnested-externs \ 3163 Wpointer-arith \ 3164 Wshadow \ 3165 Wstrict-prototypes \ 3166 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1 3167 do 3168 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" 3169 if AC_TRY_EVAL(ac_compile); then 3170 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3171 case "$cf_opt" in 3172 (Winline) 3173 case "$GCC_VERSION" in 3174 ([[34]].*) 3175 CF_VERBOSE(feature is broken in gcc $GCC_VERSION) 3176 continue;; 3177 esac 3178 ;; 3179 (Wpointer-arith) 3180 case "$GCC_VERSION" in 3181 ([[12]].*) 3182 CF_VERBOSE(feature is broken in gcc $GCC_VERSION) 3183 continue;; 3184 esac 3185 ;; 3186 esac 3187 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" 3188 fi 3189 done 3190 CFLAGS="$cf_save_CFLAGS" 3191fi 3192rm -rf ./conftest* 3193 3194AC_SUBST(EXTRA_CFLAGS) 3195])dnl 3196dnl --------------------------------------------------------------------------- 3197dnl CF_GETOPT_HEADER version: 8 updated: 2021/06/19 19:16:16 3198dnl ---------------- 3199dnl Check for getopt's variables which are commonly defined in stdlib.h, 3200dnl unistd.h or (nonstandard) in getopt.h 3201AC_DEFUN([CF_GETOPT_HEADER], 3202[ 3203AC_HAVE_HEADERS(unistd.h getopt.h) 3204AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[ 3205cf_cv_getopt_header=none 3206for cf_header in stdio.h stdlib.h unistd.h getopt.h 3207do 3208AC_TRY_COMPILE([ 3209#include <$cf_header>], 3210[int x = optind; char *y = optarg; (void)x; (void)y], 3211[cf_cv_getopt_header=$cf_header 3212 break]) 3213done 3214]) 3215if test "$cf_cv_getopt_header" != none ; then 3216 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header]) 3217fi 3218if test "$cf_cv_getopt_header" = getopt.h ; then 3219 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h]) 3220fi 3221])dnl 3222dnl --------------------------------------------------------------------------- 3223dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25 3224dnl ----------------- 3225AC_DEFUN([CF_GNATPREP_OPT_T],[ 3226AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[ 3227cf_cv_gnatprep_opt_t=no 3228gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes 3229]) 3230test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS" 3231AC_SUBST(GNATPREP_OPTS) 3232])dnl 3233dnl --------------------------------------------------------------------------- 3234dnl CF_GNAT_GENERICS version: 7 updated: 2021/01/01 13:31:04 3235dnl ---------------- 3236AC_DEFUN([CF_GNAT_GENERICS], 3237[ 3238AC_REQUIRE([CF_GNAT_VERSION]) 3239 3240AC_MSG_CHECKING(if GNAT supports generics) 3241case "$cf_cv_gnat_version" in 3242(3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|[[1-9]][[0-9]].[[0-9]]*|20[[0-9]][[0-9]]) 3243 cf_gnat_generics=yes 3244 ;; 3245(*) 3246 cf_gnat_generics=no 3247 ;; 3248esac 3249AC_MSG_RESULT($cf_gnat_generics) 3250 3251if test "$cf_gnat_generics" = yes 3252then 3253 cf_compile_generics=generics 3254 cf_generic_objects="\${GENOBJS}" 3255else 3256 cf_compile_generics= 3257 cf_generic_objects= 3258fi 3259 3260AC_SUBST(cf_compile_generics) 3261AC_SUBST(cf_generic_objects) 3262])dnl 3263dnl --------------------------------------------------------------------------- 3264dnl CF_GNAT_PROJECTS version: 13 updated: 2021/01/02 17:09:14 3265dnl ---------------- 3266dnl GNAT projects are configured with ".gpr" project files. 3267dnl GNAT libraries are a further development, using the project feature. 3268AC_DEFUN([CF_GNAT_PROJECTS], 3269[ 3270AC_REQUIRE([CF_GNAT_VERSION]) 3271AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS]) 3272 3273cf_gnat_libraries=no 3274cf_gnat_projects=no 3275 3276if test "$enable_gnat_projects" != no ; then 3277AC_MSG_CHECKING(if GNAT supports project files) 3278case "$cf_cv_gnat_version" in 3279(3.[[0-9]]*) 3280 ;; 3281(*) 3282 case "$cf_cv_system_name" in 3283 (cygwin*|msys*) 3284 ;; 3285 (*) 3286 rm -rf ./conftest* ./*~conftest* 3287 if mkdir conftest.src conftest.bin conftest.lib 3288 then 3289 cd conftest.src 3290 rm -rf ./conftest* ./*~conftest* 3291 cat >>library.gpr <<CF_EOF 3292project Library is 3293 Kind := External ("LIB_KIND"); 3294 for Library_Name use "ConfTest"; 3295 for Object_Dir use "."; 3296 for Library_ALI_Dir use External("LIBRARY_DIR"); 3297 for Library_Version use External ("SONAME"); 3298 for Library_Kind use Kind; 3299 for Library_Dir use External("BUILD_DIR"); 3300 Source_Dir := External ("SOURCE_DIR"); 3301 for Source_Dirs use (Source_Dir); 3302end Library; 3303CF_EOF 3304 cat >>confpackage.ads <<CF_EOF 3305package ConfPackage is 3306 procedure conftest; 3307end ConfPackage; 3308CF_EOF 3309 cat >>confpackage.adb <<CF_EOF 3310with Text_IO; 3311package body ConfPackage is 3312 procedure conftest is 3313 begin 3314 Text_IO.Put ("Hello World"); 3315 Text_IO.New_Line; 3316 end conftest; 3317end ConfPackage; 3318CF_EOF 3319 if ( "$cf_ada_make" $ADAFLAGS \ 3320 -Plibrary.gpr \ 3321 -XBUILD_DIR="`cd ../conftest.bin;pwd`" \ 3322 -XLIBRARY_DIR="`cd ../conftest.lib;pwd`" \ 3323 -XSOURCE_DIR="`pwd`" \ 3324 -XSONAME=libConfTest.so.1 \ 3325 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then 3326 cf_gnat_projects=yes 3327 fi 3328 cd .. 3329 fi 3330 if test -f conftest.lib/confpackage.ali 3331 then 3332 cf_gnat_libraries=yes 3333 fi 3334 rm -rf ./conftest* ./*~conftest* 3335 ;; 3336 esac 3337 ;; 3338esac 3339AC_MSG_RESULT($cf_gnat_projects) 3340fi # enable_gnat_projects 3341 3342if test "$cf_gnat_projects" = yes 3343then 3344 AC_MSG_CHECKING(if GNAT supports libraries) 3345 AC_MSG_RESULT($cf_gnat_libraries) 3346fi 3347 3348USE_OLD_MAKERULES="" 3349USE_GNAT_PROJECTS="#" 3350USE_GNAT_MAKE_GPR="#" 3351USE_GNAT_GPRBUILD="#" 3352 3353if test "$cf_gnat_projects" = yes 3354then 3355 USE_OLD_MAKERULES="#" 3356 USE_GNAT_PROJECTS="" 3357 if test "$cf_cv_VERSION_GPRBUILD" != no 3358 then 3359 USE_GNAT_GPRBUILD="" 3360 elif test "$cf_cv_VERSION_GNATMAKE" != no 3361 then 3362 USE_GNAT_MAKE_GPR="" 3363 else 3364 AC_MSG_WARN(use old makefile rules since tools are missing) 3365 fi 3366fi 3367 3368if test "$cf_gnat_libraries" = yes 3369then 3370 USE_GNAT_LIBRARIES="" 3371else 3372 USE_GNAT_LIBRARIES="#" 3373fi 3374 3375AC_SUBST(USE_OLD_MAKERULES) 3376AC_SUBST(USE_GNAT_PROJECTS) 3377AC_SUBST(USE_GNAT_LIBRARIES) 3378AC_SUBST(USE_GNAT_MAKE_GPR) 3379AC_SUBST(USE_GNAT_GPRBUILD) 3380])dnl 3381dnl --------------------------------------------------------------------------- 3382dnl CF_GNAT_SIGINT version: 2 updated: 2021/01/01 13:31:04 3383dnl -------------- 3384dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it 3385dnl is noted that gnat may compile a tasking unit even for configurations which 3386dnl fail at runtime. 3387AC_DEFUN([CF_GNAT_SIGINT],[ 3388AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[ 3389CF_GNAT_TRY_LINK([with Ada.Interrupts.Names; 3390 3391package ConfTest is 3392 3393 pragma Warnings (Off); -- the next pragma exists since 3.11p 3394 pragma Unreserve_All_Interrupts; 3395 pragma Warnings (On); 3396 3397 protected Process is 3398 procedure Stop; 3399 function Continue return Boolean; 3400 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT); 3401 private 3402 Done : Boolean := False; 3403 end Process; 3404 3405end ConfTest;], 3406[package body ConfTest is 3407 protected body Process is 3408 procedure Stop is 3409 begin 3410 Done := True; 3411 end Stop; 3412 function Continue return Boolean is 3413 begin 3414 return not Done; 3415 end Continue; 3416 end Process; 3417end ConfTest;], 3418 [cf_cv_gnat_sigint=yes], 3419 [cf_cv_gnat_sigint=no])]) 3420 3421if test "$cf_cv_gnat_sigint" = yes ; then 3422 USE_GNAT_SIGINT="" 3423else 3424 USE_GNAT_SIGINT="#" 3425fi 3426AC_SUBST(USE_GNAT_SIGINT) 3427])dnl 3428dnl --------------------------------------------------------------------------- 3429dnl CF_GNAT_TRY_LINK version: 4 updated: 2021/01/01 13:31:04 3430dnl ---------------- 3431dnl Verify that a test program compiles/links with GNAT. 3432dnl $cf_ada_make is set to the program that compiles/links 3433dnl $ADAFLAGS may be set to the GNAT flags. 3434dnl 3435dnl $1 is the text of the spec 3436dnl $2 is the text of the body 3437dnl $3 is the shell command to execute if successful 3438dnl $4 is the shell command to execute if not successful 3439AC_DEFUN([CF_GNAT_TRY_LINK], 3440[ 3441rm -rf ./conftest* ./*~conftest* 3442cat >>conftest.ads <<CF_EOF 3443$1 3444CF_EOF 3445cat >>conftest.adb <<CF_EOF 3446$2 3447CF_EOF 3448if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then 3449ifelse($3,, :,[ $3]) 3450ifelse($4,,,[else 3451 $4]) 3452fi 3453rm -rf ./conftest* ./*~conftest* 3454])dnl 3455dnl --------------------------------------------------------------------------- 3456dnl CF_GNAT_TRY_RUN version: 6 updated: 2021/01/01 13:31:04 3457dnl --------------- 3458dnl Verify that a test program compiles and runs with GNAT 3459dnl $cf_ada_make is set to the program that compiles/links 3460dnl $ADAFLAGS may be set to the GNAT flags. 3461dnl 3462dnl $1 is the text of the spec 3463dnl $2 is the text of the body 3464dnl $3 is the shell command to execute if successful 3465dnl $4 is the shell command to execute if not successful 3466AC_DEFUN([CF_GNAT_TRY_RUN], 3467[ 3468rm -rf ./conftest* ./*~conftest* 3469cat >>conftest.ads <<CF_EOF 3470$1 3471CF_EOF 3472cat >>conftest.adb <<CF_EOF 3473$2 3474CF_EOF 3475if ( "$cf_ada_make" $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then 3476 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then 3477ifelse($3,, :,[ $3]) 3478ifelse($4,,,[ else 3479 $4]) 3480 fi 3481ifelse($4,,,[else 3482 $4]) 3483fi 3484rm -rf ./conftest* ./*~conftest* 3485])dnl 3486dnl --------------------------------------------------------------------------- 3487dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54 3488dnl --------------- 3489dnl $1 = cache variable to update 3490dnl $2 = program name 3491dnl Verify version of GNAT or related tool 3492AC_DEFUN([CF_GNAT_VERSION], 3493[ 3494AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[ 3495cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \ 3496 grep '[[0-9]].[[0-9]][[0-9]]*' |\ 3497 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'` 3498]) 3499test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no 3500ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version]) 3501])dnl 3502dnl --------------------------------------------------------------------------- 3503dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41 3504dnl ------------- 3505dnl Check if we must define _GNU_SOURCE to get a reasonable value for 3506dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect 3507dnl (or misfeature) of glibc2, which breaks portability of many applications, 3508dnl since it is interwoven with GNU extensions. 3509dnl 3510dnl Well, yes we could work around it... 3511dnl 3512dnl Parameters: 3513dnl $1 is the nominal value for _XOPEN_SOURCE 3514AC_DEFUN([CF_GNU_SOURCE], 3515[ 3516cf_gnu_xopen_source=ifelse($1,,500,$1) 3517 3518AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[ 3519AC_TRY_COMPILE([#include <sys/types.h>],[ 3520 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0 3521 return 0; 3522 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0 3523 return 0; 3524 #else 3525 # error not GNU C library 3526 #endif], 3527 [cf_cv_gnu_library=yes], 3528 [cf_cv_gnu_library=no]) 3529]) 3530 3531if test x$cf_cv_gnu_library = xyes; then 3532 3533 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE 3534 # was changed to help a little. newlib incorporated the change about 4 3535 # years later. 3536 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[ 3537 cf_save="$CPPFLAGS" 3538 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE) 3539 AC_TRY_COMPILE([#include <sys/types.h>],[ 3540 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2) 3541 return 0; 3542 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3) 3543 return 0; 3544 #else 3545 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old 3546 #endif], 3547 [cf_cv_gnu_library_219=yes], 3548 [cf_cv_gnu_library_219=no]) 3549 CPPFLAGS="$cf_save" 3550 ]) 3551 3552 if test "x$cf_cv_gnu_library_219" = xyes; then 3553 cf_save="$CPPFLAGS" 3554 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[ 3555 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source) 3556 AC_TRY_COMPILE([ 3557 #include <limits.h> 3558 #include <sys/types.h> 3559 ],[ 3560 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1) 3561 return 0; 3562 #else 3563 # error GNU C library is too old 3564 #endif], 3565 [cf_cv_gnu_dftsrc_219=yes], 3566 [cf_cv_gnu_dftsrc_219=no]) 3567 ]) 3568 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save" 3569 else 3570 cf_cv_gnu_dftsrc_219=maybe 3571 fi 3572 3573 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then 3574 3575 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[ 3576 AC_TRY_COMPILE([#include <sys/types.h>],[ 3577 #ifndef _XOPEN_SOURCE 3578 #error expected _XOPEN_SOURCE to be defined 3579 #endif], 3580 [cf_cv_gnu_source=no], 3581 [cf_save="$CPPFLAGS" 3582 CF_ADD_CFLAGS(-D_GNU_SOURCE) 3583 AC_TRY_COMPILE([#include <sys/types.h>],[ 3584 #ifdef _XOPEN_SOURCE 3585 #error expected _XOPEN_SOURCE to be undefined 3586 #endif], 3587 [cf_cv_gnu_source=no], 3588 [cf_cv_gnu_source=yes]) 3589 CPPFLAGS="$cf_save" 3590 ]) 3591 ]) 3592 3593 if test "$cf_cv_gnu_source" = yes 3594 then 3595 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[ 3596 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE) 3597 AC_TRY_COMPILE([#include <sys/types.h>],[ 3598 #ifdef _DEFAULT_SOURCE 3599 #error expected _DEFAULT_SOURCE to be undefined 3600 #endif], 3601 [cf_cv_default_source=no], 3602 [cf_cv_default_source=yes]) 3603 ]) 3604 if test "$cf_cv_default_source" = yes 3605 then 3606 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE) 3607 fi 3608 fi 3609 fi 3610 3611fi 3612])dnl 3613dnl --------------------------------------------------------------------------- 3614dnl CF_GPP_LIBRARY version: 13 updated: 2021/01/01 13:31:04 3615dnl -------------- 3616dnl If we're trying to use g++, test if libg++ is installed (a rather common 3617dnl problem :-). If we have the compiler but no library, we'll be able to 3618dnl configure, but won't be able to build the c++ demo program. 3619AC_DEFUN([CF_GPP_LIBRARY], 3620[ 3621cf_cxx_library=unknown 3622case "$cf_cv_system_name" in 3623(os2*) 3624 cf_gpp_libname=gpp 3625 ;; 3626(*) 3627 cf_gpp_libname=g++ 3628 ;; 3629esac 3630if test "$GXX" = yes; then 3631 AC_MSG_CHECKING([for lib$cf_gpp_libname]) 3632 cf_save="$LIBS" 3633 CF_ADD_LIB($cf_gpp_libname) 3634 AC_TRY_LINK([ 3635#include <$cf_gpp_libname/builtin.h> 3636 ], 3637 [two_arg_error_handler_t foo2 = lib_error_handler], 3638 [cf_cxx_library=yes 3639 CF_ADD_LIB($cf_gpp_libname,CXXLIBS) 3640 if test "$cf_gpp_libname" = cpp ; then 3641 AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h]) 3642 else 3643 AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h]) 3644 fi], 3645 [AC_TRY_LINK([ 3646#include <builtin.h> 3647 ], 3648 [two_arg_error_handler_t foo2 = lib_error_handler], 3649 [cf_cxx_library=yes 3650 CF_ADD_LIB($cf_gpp_libname,CXXLIBS) 3651 AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])], 3652 [cf_cxx_library=no])]) 3653 LIBS="$cf_save" 3654 AC_MSG_RESULT($cf_cxx_library) 3655fi 3656])dnl 3657dnl --------------------------------------------------------------------------- 3658dnl CF_GXX_VERSION version: 9 updated: 2023/03/05 14:30:13 3659dnl -------------- 3660dnl Check for version of g++ 3661AC_DEFUN([CF_GXX_VERSION],[ 3662AC_REQUIRE([AC_PROG_CPP]) 3663GXX_VERSION=none 3664if test "$GXX" = yes; then 3665 AC_MSG_CHECKING(version of ${CXX:-g++}) 3666 GXX_VERSION="`${CXX:-g++} --version 2>/dev/null | sed -e '2,$d' -e 's/^[[^(]]*([[^)]][[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" 3667 if test -z "$GXX_VERSION" 3668 then 3669 GXX_VERSION=unknown 3670 GXX=no 3671 fi 3672 AC_MSG_RESULT($GXX_VERSION) 3673fi 3674])dnl 3675dnl --------------------------------------------------------------------------- 3676dnl CF_GXX_WARNINGS version: 11 updated: 2021/01/08 16:50:55 3677dnl --------------- 3678dnl Check if the compiler supports useful warning options. 3679dnl 3680dnl Most of gcc's options apply to g++, except: 3681dnl -Wbad-function-cast 3682dnl -Wmissing-declarations 3683dnl -Wnested-externs 3684dnl 3685dnl Omit a few (for now): 3686dnl -Winline 3687dnl 3688dnl Parameter: 3689dnl $1 is an optional list of g++ warning flags that a particular 3690dnl application might want to use, e.g., "no-unused" for 3691dnl -Wno-unused 3692dnl Special: 3693dnl If $with_ext_const is "yes", add a check for -Wwrite-strings 3694dnl 3695AC_DEFUN([CF_GXX_WARNINGS], 3696[ 3697 3698CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS) 3699CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS) 3700 3701AC_REQUIRE([CF_GXX_VERSION]) 3702 3703AC_LANG_SAVE 3704AC_LANG_CPLUSPLUS 3705 3706cat > conftest.$ac_ext <<EOF 3707#line __oline__ "configure" 3708int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; } 3709EOF 3710 3711if test "$INTEL_CPLUSPLUS" = yes 3712then 3713# The "-wdXXX" options suppress warnings: 3714# remark #1419: external declaration in primary source file 3715# remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 3716# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 3717# remark #1684: conversion from pointer to same-sized integral type (potential portability problem) 3718# remark #193: zero used for undefined preprocessing identifier 3719# remark #593: variable "curs_sb_left_arrow" was set but never used 3720# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits 3721# remark #869: parameter "tw" was never referenced 3722# remark #981: operands are evaluated in unspecified order 3723# warning #269: invalid format string conversion 3724 3725 AC_CHECKING([for $CC warning options]) 3726 cf_save_CXXFLAGS="$CXXFLAGS" 3727 EXTRA_CXXFLAGS="-Wall" 3728 for cf_opt in \ 3729 wd1419 \ 3730 wd1682 \ 3731 wd1683 \ 3732 wd1684 \ 3733 wd193 \ 3734 wd279 \ 3735 wd593 \ 3736 wd810 \ 3737 wd869 \ 3738 wd981 3739 do 3740 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt" 3741 if AC_TRY_EVAL(ac_compile); then 3742 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3743 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt" 3744 fi 3745 done 3746 CXXFLAGS="$cf_save_CXXFLAGS" 3747 3748elif test "$GXX" = yes 3749then 3750 AC_CHECKING([for $CXX warning options]) 3751 cf_save_CXXFLAGS="$CXXFLAGS" 3752 EXTRA_CXXFLAGS="-W -Wall" 3753 cf_gxx_extra_warnings="" 3754 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings" 3755 case "$GXX_VERSION" in 3756 ([[1-2]].*) 3757 ;; 3758 (*) 3759 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++" 3760 ;; 3761 esac 3762 for cf_opt in \ 3763 Wabi \ 3764 fabi-version=0 \ 3765 Wextra \ 3766 Wignored-qualifiers \ 3767 Wlogical-op \ 3768 Woverloaded-virtual \ 3769 Wsign-promo \ 3770 Wsynth \ 3771 Wold-style-cast \ 3772 Wcast-align \ 3773 Wcast-qual \ 3774 Wpointer-arith \ 3775 Wshadow \ 3776 Wundef $cf_gxx_extra_warnings $1 3777 do 3778 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt" 3779 if AC_TRY_EVAL(ac_compile); then 3780 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3781 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt" 3782 else 3783 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt) 3784 fi 3785 done 3786 CXXFLAGS="$cf_save_CXXFLAGS" 3787fi 3788 3789rm -rf ./conftest* 3790AC_LANG_RESTORE 3791AC_SUBST(EXTRA_CXXFLAGS) 3792])dnl 3793dnl --------------------------------------------------------------------------- 3794dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57 3795dnl ------------ 3796dnl Look for an instance of the Berkeley hashed database. 3797dnl 3798dnl $1 = optional parameter, to specify install-prefix for the database. 3799AC_DEFUN([CF_HASHED_DB], 3800[ 3801ifelse([$1],,,[ 3802case $1 in 3803(yes|*able*) 3804 ;; 3805(*) 3806 if test -d "$1" ; then 3807 CF_ADD_INCDIR($1/include) 3808 CF_ADD_LIBDIR($1/lib) 3809 else 3810 case "$1" in 3811 (./*|../*|/*) 3812 AC_MSG_WARN(no such directory $1) 3813 ;; 3814 (*) 3815 CF_FIND_SUB_INCDIR($1) 3816 CF_FIND_SUB_LIBDIR($1) 3817 ;; 3818 esac 3819 fi 3820esac 3821]) 3822AC_CHECK_HEADER(db.h,[ 3823CF_HASHED_DB_VERSION 3824if test "$cf_cv_hashed_db_version" = unknown ; then 3825 AC_MSG_ERROR(Cannot determine version of db) 3826else 3827 CF_HASHED_DB_LIBS 3828 if test "$cf_cv_hashed_db_libs" = unknown ; then 3829 AC_MSG_ERROR(Cannot determine library for db) 3830 elif test "$cf_cv_hashed_db_libs" != default ; then 3831 CF_ADD_LIB($cf_cv_hashed_db_libs) 3832 fi 3833fi 3834],[ 3835 AC_MSG_ERROR(Cannot find db.h) 3836]) 3837])dnl 3838dnl --------------------------------------------------------------------------- 3839dnl CF_HASHED_DB_LIBS version: 10 updated: 2021/01/02 17:09:14 3840dnl ----------------- 3841dnl Given that we have the header and version for hashed database, find the 3842dnl library information. 3843AC_DEFUN([CF_HASHED_DB_LIBS], 3844[ 3845AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[ 3846cf_cv_hashed_db_libs=unknown 3847for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db '' 3848do 3849 cf_save_libs="$LIBS" 3850 if test -n "$cf_db_libs"; then 3851 CF_ADD_LIB($cf_db_libs) 3852 fi 3853 CF_MSG_LOG(checking for library $cf_db_libs) 3854 AC_TRY_LINK([ 3855$ac_includes_default 3856#include <db.h> 3857],[ 3858 char *path = "/tmp/foo"; 3859#ifdef DB_VERSION_MAJOR 3860#if DB_VERSION_MAJOR >= 4 3861 DB *result = 0; 3862 db_create(&result, NULL, 0); 3863 result->open(result, 3864 NULL, 3865 path, 3866 path, 3867 DB_HASH, 3868 DB_CREATE, 3869 0644); 3870#elif DB_VERSION_MAJOR >= 3 3871 DB *result = 0; 3872 db_create(&result, NULL, 0); 3873 result->open(result, 3874 path, 3875 path, 3876 DB_HASH, 3877 DB_CREATE, 3878 0644); 3879#elif DB_VERSION_MAJOR >= 2 3880 DB *result = 0; 3881 db_open(path, 3882 DB_HASH, 3883 DB_CREATE, 3884 0644, 3885 (DB_ENV *) 0, 3886 (DB_INFO *) 0, 3887 &result); 3888#endif /* DB_VERSION_MAJOR */ 3889#else 3890 DB *result = dbopen(path, 3891 2, 3892 0644, 3893 DB_HASH, 3894 0); 3895#endif 3896 ${cf_cv_main_return:-return}(result != 0) 3897],[ 3898 if test -n "$cf_db_libs" ; then 3899 cf_cv_hashed_db_libs=$cf_db_libs 3900 else 3901 cf_cv_hashed_db_libs=default 3902 fi 3903 LIBS="$cf_save_libs" 3904 break 3905]) 3906 LIBS="$cf_save_libs" 3907done 3908]) 3909])dnl 3910dnl --------------------------------------------------------------------------- 3911dnl CF_HASHED_DB_VERSION version: 5 updated: 2023/02/18 17:41:25 3912dnl -------------------- 3913dnl Given that we have the header file for hashed database, find the version 3914dnl information. 3915AC_DEFUN([CF_HASHED_DB_VERSION], 3916[ 3917AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[ 3918cf_cv_hashed_db_version=unknown 3919 3920for cf_db_version in 1 2 3 4 5 6 3921do 3922 CF_MSG_LOG(checking for db version $cf_db_version) 3923 AC_TRY_COMPILE([ 3924$ac_includes_default 3925#include <db.h> 3926 3927#ifdef DB_VERSION_MAJOR 3928 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */ 3929#if $cf_db_version == DB_VERSION_MAJOR 3930 /* ok */ 3931#else 3932 #error $cf_db_version is not DB_VERSION_MAJOR 3933#endif 3934#else 3935#if $cf_db_version == 1 3936 /* ok: assuming this is DB 1.8.5 */ 3937#else 3938 #error $cf_db_version is not 1 3939#endif 3940#endif 3941],[DBT *foo = 0],[ 3942 cf_cv_hashed_db_version=$cf_db_version 3943 break 3944 ]) 3945done 3946]) 3947])dnl 3948dnl --------------------------------------------------------------------------- 3949dnl CF_HEADER_PATH version: 15 updated: 2021/01/01 13:31:04 3950dnl -------------- 3951dnl Construct a search-list of directories for a nonstandard header-file 3952dnl 3953dnl Parameters 3954dnl $1 = the variable to return as result 3955dnl $2 = the package name 3956AC_DEFUN([CF_HEADER_PATH], 3957[ 3958$1= 3959 3960# collect the current set of include-directories from compiler flags 3961cf_header_path_list="" 3962if test -n "${CFLAGS}${CPPFLAGS}" ; then 3963 for cf_header_path in $CPPFLAGS $CFLAGS 3964 do 3965 case "$cf_header_path" in 3966 (-I*) 3967 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` 3968 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE) 3969 cf_header_path_list="$cf_header_path_list [$]$1" 3970 ;; 3971 esac 3972 done 3973fi 3974 3975# add the variations for the package we are looking for 3976CF_SUBDIR_PATH($1,$2,include) 3977 3978test "$includedir" != NONE && \ 3979test "$includedir" != "/usr/include" && \ 3980test -d "$includedir" && { 3981 test -d "$includedir" && $1="[$]$1 $includedir" 3982 test -d "$includedir/$2" && $1="[$]$1 $includedir/$2" 3983} 3984 3985test "$oldincludedir" != NONE && \ 3986test "$oldincludedir" != "/usr/include" && \ 3987test -d "$oldincludedir" && { 3988 test -d "$oldincludedir" && $1="[$]$1 $oldincludedir" 3989 test -d "$oldincludedir/$2" && $1="[$]$1 $oldincludedir/$2" 3990} 3991 3992$1="[$]$1 $cf_header_path_list" 3993])dnl 3994dnl --------------------------------------------------------------------------- 3995dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54 3996dnl --------------- 3997dnl Insert text into the help-message, for readability, from AC_ARG_WITH. 3998AC_DEFUN([CF_HELP_MESSAGE], 3999[CF_ACVERSION_CHECK(2.53,[],[ 4000AC_DIVERT_HELP($1)])dnl 4001])dnl 4002dnl --------------------------------------------------------------------------- 4003dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42 4004dnl --------------- 4005dnl Construct the list of include-options according to whether we're building 4006dnl in the source directory or using '--srcdir=DIR' option. 4007AC_DEFUN([CF_INCLUDE_DIRS], 4008[ 4009if test "$srcdir" != "."; then 4010 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS" 4011fi 4012CPPFLAGS="-I../include $CPPFLAGS" 4013if test "$srcdir" != "."; then 4014 CPPFLAGS="-I\${srcdir} $CPPFLAGS" 4015fi 4016CPPFLAGS="-I. $CPPFLAGS" 4017AC_SUBST(CPPFLAGS) 4018])dnl 4019dnl --------------------------------------------------------------------------- 4020dnl CF_INSTALL_OPTS version: 3 updated: 2023/06/03 15:17:30 4021dnl --------------- 4022dnl prompt for/fill-in useful install-program options 4023AC_DEFUN([CF_INSTALL_OPTS], 4024[ 4025CF_INSTALL_OPT_S 4026CF_INSTALL_OPT_P 4027CF_INSTALL_OPT_O 4028CF_INSTALL_OPT_STRIP_PROG 4029])dnl 4030dnl --------------------------------------------------------------------------- 4031dnl CF_INSTALL_OPT_O version: 3 updated: 2020/12/31 20:19:42 4032dnl ---------------- 4033dnl Almost all "install" programs default to the current user's ownership. 4034dnl Almost - MINIX is an exception. 4035AC_DEFUN([CF_INSTALL_OPT_O], 4036[ 4037AC_MSG_CHECKING(if install needs to be told about ownership) 4038case `$ac_config_guess` in 4039(*minix) 4040 with_install_o=yes 4041 ;; 4042(*) 4043 with_install_o=no 4044 ;; 4045esac 4046 4047AC_MSG_RESULT($with_install_o) 4048if test "x$with_install_o" = xyes 4049then 4050 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'`" 4051else 4052 INSTALL_OPT_O= 4053fi 4054 4055AC_SUBST(INSTALL_OPT_O) 4056])dnl 4057dnl --------------------------------------------------------------------------- 4058dnl CF_INSTALL_OPT_P version: 3 updated: 2021/01/01 13:31:04 4059dnl ---------------- 4060dnl Some install-programs accept a "-p" option to preserve file modification 4061dnl timestamps. That can be useful as an install option, as well as a way to 4062dnl avoid the need for ranlib after copying a static archive. 4063AC_DEFUN([CF_INSTALL_OPT_P], 4064[ 4065: "${INSTALL:=install}" 4066AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[ 4067 rm -rf ./conftest* 4068 date >conftest.in 4069 mkdir conftest.out 4070 sleep 3 4071 if $INSTALL -p conftest.in conftest.out 2>/dev/null 4072 then 4073 if test -f conftest.out/conftest.in 4074 then 4075 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \ 4076 test conftest.out/conftest.in -nt conftest.in 2>conftest.err 4077 if test -s conftest.err 4078 then 4079 cf_cv_install_p=no 4080 else 4081 cf_cv_install_p=yes 4082 fi 4083 else 4084 cf_cv_install_p=no 4085 fi 4086 else 4087 cf_cv_install_p=no 4088 fi 4089 rm -rf ./conftest* 4090]) 4091])dnl 4092dnl --------------------------------------------------------------------------- 4093dnl CF_INSTALL_OPT_S version: 3 updated: 2021/01/05 19:23:48 4094dnl ---------------- 4095dnl By default, we should strip executables which are installed, but leave the 4096dnl ability to suppress that for unit-testing. 4097AC_DEFUN([CF_INSTALL_OPT_S], 4098[ 4099AC_MSG_CHECKING(if you want to install stripped executables) 4100CF_ARG_DISABLE(stripping, 4101 [ --disable-stripping do not strip (debug info) installed executables], 4102 [enable_stripping=no], 4103 [enable_stripping=yes]) 4104AC_MSG_RESULT($enable_stripping) 4105 4106if test "$enable_stripping" = yes 4107then 4108 INSTALL_OPT_S="-s" 4109else 4110 INSTALL_OPT_S= 4111fi 4112AC_SUBST(INSTALL_OPT_S) 4113])dnl 4114dnl --------------------------------------------------------------------------- 4115dnl CF_INSTALL_OPT_STRIP_PROG version: 1 updated: 2023/06/03 15:17:30 4116dnl ------------------------- 4117dnl Provide an option for overriding the strip program used in install "-s" 4118dnl 4119dnl coreutils install provides a --strip-program option 4120dnl FreeBSD uses STRIPBIN environment variable, while NetBSD and OpenBSD use 4121dnl STRIP environment variable. Other versions of install do not support this. 4122AC_DEFUN([CF_INSTALL_OPT_STRIP_PROG], 4123[ 4124AC_REQUIRE([CF_INSTALL_OPT_S]) 4125if test -n "$INSTALL_OPT_S" 4126then 4127 AC_MSG_CHECKING(if you want to specify strip-program) 4128 AC_ARG_WITH(strip-program, 4129 [ --with-strip-program=XX specify program to use when stripping in install], 4130 [with_strip_program=$withval], 4131 [with_strip_program=no]) 4132 AC_MSG_RESULT($with_strip_program) 4133 if test "$with_strip_program" != no 4134 then 4135 AC_MSG_CHECKING(if strip-program is supported with this installer) 4136 cf_install_program=`echo "$INSTALL" | sed -e 's%[[ ]]*[[ ]]-.%%'` 4137 check_install_strip=no 4138 if test -f "$cf_install_program" 4139 then 4140 check_install_version=`"$cf_install_program" --version 2>/dev/null | head -n 1 | grep coreutils` 4141 if test -n "$check_install_version" 4142 then 4143 check_install_strip="option" 4144 else 4145 for check_strip_variable in STRIPBIN STRIP 4146 do 4147 if strings "$cf_install_program" | grep "^$check_strip_variable[$]" >/dev/null 4148 then 4149 check_install_strip="environ" 4150 break 4151 fi 4152 done 4153 fi 4154 fi 4155 AC_MSG_RESULT($check_install_strip) 4156 case "$check_install_strip" in 4157 (no) 4158 AC_MSG_WARN($cf_install_program does not support strip program option) 4159 with_strip_program=no 4160 ;; 4161 (environ) 4162 cat >install.tmp <<-CF_EOF 4163 #! $SHELL 4164 STRIPBIN="$with_strip_program" \\ 4165 STRIP="$with_strip_program" \\ 4166 $INSTALL "[$]@" 4167 CF_EOF 4168 INSTALL="`pwd`/install.tmp" 4169 chmod +x "$INSTALL" 4170 CF_VERBOSE(created $INSTALL) 4171 ;; 4172 (option) 4173 INSTALL_OPT_S="$INSTALL_OPT_S --strip-program=\"$with_strip_program\"" 4174 ;; 4175 esac 4176 fi 4177fi 4178AC_SUBST(INSTALL_OPT_S) 4179])dnl 4180dnl --------------------------------------------------------------------------- 4181dnl CF_INTEL_COMPILER version: 9 updated: 2023/02/18 17:41:25 4182dnl ----------------- 4183dnl Check if the given compiler is really the Intel compiler for Linux. It 4184dnl tries to imitate gcc, but does not return an error when it finds a mismatch 4185dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK. 4186dnl 4187dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to 4188dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from 4189dnl the wrappers for gcc and g++ warnings. 4190dnl 4191dnl $1 = GCC (default) or GXX 4192dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS 4193dnl $3 = CFLAGS (default) or CXXFLAGS 4194AC_DEFUN([CF_INTEL_COMPILER],[ 4195AC_REQUIRE([AC_CANONICAL_HOST]) 4196ifelse([$2],,INTEL_COMPILER,[$2])=no 4197 4198if test "$ifelse([$1],,[$1],GCC)" = yes ; then 4199 case "$host_os" in 4200 (linux*|gnu*) 4201 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler) 4202 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" 4203 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc" 4204 AC_TRY_COMPILE([],[ 4205#ifdef __INTEL_COMPILER 4206#else 4207#error __INTEL_COMPILER is not defined 4208#endif 4209],[ifelse([$2],,INTEL_COMPILER,[$2])=yes 4210cf_save_CFLAGS="$cf_save_CFLAGS -we147" 4211],[]) 4212 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" 4213 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2])) 4214 ;; 4215 esac 4216fi 4217])dnl 4218dnl --------------------------------------------------------------------------- 4219dnl CF_ISASCII version: 5 updated: 2023/12/03 09:21:34 4220dnl ---------- 4221dnl Check if we have either a function or macro for 'isascii()'. 4222AC_DEFUN([CF_ISASCII], 4223[ 4224AC_MSG_CHECKING(for isascii) 4225AC_CACHE_VAL(cf_cv_have_isascii,[ 4226 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' '); (void)x], 4227 [cf_cv_have_isascii=yes], 4228 [cf_cv_have_isascii=no]) 4229])dnl 4230AC_MSG_RESULT($cf_cv_have_isascii) 4231test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()]) 4232])dnl 4233dnl --------------------------------------------------------------------------- 4234dnl CF_LARGEFILE version: 13 updated: 2023/12/03 19:09:59 4235dnl ------------ 4236dnl Add checks for large file support. 4237AC_DEFUN([CF_LARGEFILE],[ 4238ifdef([AC_FUNC_FSEEKO],[ 4239 AC_SYS_LARGEFILE 4240 if test "$enable_largefile" != no ; then 4241 AC_FUNC_FSEEKO 4242 4243 # Normally we would collect these definitions in the config.h, 4244 # but (like _XOPEN_SOURCE), some environments rely on having these 4245 # defined before any of the system headers are included. Another 4246 # case comes up with C++, e.g., on AIX the compiler compiles the 4247 # header files by themselves before looking at the body files it is 4248 # told to compile. For ncurses, those header files do not include 4249 # the config.h 4250 if test "$ac_cv_sys_large_files" != no 4251 then 4252 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES) 4253 fi 4254 if test "$ac_cv_sys_largefile_source" != no 4255 then 4256 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE) 4257 fi 4258 if test "$ac_cv_sys_file_offset_bits" != no 4259 then 4260 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits) 4261 fi 4262 4263 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[ 4264 AC_TRY_COMPILE([ 4265#pragma GCC diagnostic error "-Wincompatible-pointer-types" 4266#include <sys/types.h> 4267#include <dirent.h> 4268 4269#ifndef __REDIRECT 4270/* if transitional largefile support is setup, this is true */ 4271extern struct dirent64 * readdir(DIR *); 4272#endif 4273 ],[ 4274 DIR *dp = opendir("."); 4275 struct dirent64 *x = readdir(dp); 4276 struct dirent *y = readdir(dp); 4277 int z = x - y; 4278 (void)z; 4279 ], 4280 [cf_cv_struct_dirent64=yes], 4281 [cf_cv_struct_dirent64=no]) 4282 ]) 4283 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64]) 4284 fi 4285]) 4286]) 4287dnl --------------------------------------------------------------------------- 4288dnl CF_LDFLAGS_STATIC version: 14 updated: 2021/01/02 17:09:14 4289dnl ----------------- 4290dnl Check for compiler/linker flags used to temporarily force usage of static 4291dnl libraries. This depends on the compiler and platform. Use this to help 4292dnl ensure that the linker picks up a given library based on its position in 4293dnl the list of linker options and libraries. 4294AC_DEFUN([CF_LDFLAGS_STATIC],[ 4295 4296if test "$GCC" = yes ; then 4297 case "$cf_cv_system_name" in 4298 (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*) 4299 LDFLAGS_STATIC= 4300 LDFLAGS_SHARED= 4301 ;; 4302 (*) # normally, except when broken 4303 LDFLAGS_STATIC=-static 4304 LDFLAGS_SHARED=-dynamic 4305 ;; 4306 esac 4307else 4308 case "$cf_cv_system_name" in 4309 (aix[[4-7]]*) # from ld manpage 4310 LDFLAGS_STATIC=-bstatic 4311 LDFLAGS_SHARED=-bdynamic 4312 ;; 4313 (hpux*) # from ld manpage for hpux10.20, hpux11.11 4314 # We could also use just "archive" and "shared". 4315 LDFLAGS_STATIC=-Wl,-a,archive_shared 4316 LDFLAGS_SHARED=-Wl,-a,shared_archive 4317 ;; 4318 (irix*) # from ld manpage IRIX64 4319 LDFLAGS_STATIC=-Bstatic 4320 LDFLAGS_SHARED=-Bdynamic 4321 ;; 4322 (osf[[45]]*) # from ld manpage osf4.0d, osf5.1 4323 # alternative "-oldstyle_liblookup" (not in cc manpage) 4324 LDFLAGS_STATIC=-noso 4325 LDFLAGS_SHARED=-so_archive 4326 ;; 4327 (solaris2*) 4328 LDFLAGS_STATIC=-Bstatic 4329 LDFLAGS_SHARED=-Bdynamic 4330 ;; 4331 esac 4332fi 4333 4334if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED" 4335then 4336 AC_MSG_CHECKING(if linker supports switching between static/dynamic) 4337 4338 rm -f libconftest.a 4339 cat >conftest.$ac_ext <<EOF 4340#line __oline__ "configure" 4341#include <stdio.h> 4342int cf_ldflags_static(FILE *fp) { return fflush(fp); } 4343EOF 4344 if AC_TRY_EVAL(ac_compile) ; then 4345 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null 4346 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null 4347 fi 4348 rm -f conftest.* 4349 4350 cf_save_LIBS="$LIBS" 4351 4352 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS" 4353 AC_TRY_LINK([ 4354#line __oline__ "configure" 4355#include <stdio.h> 4356int cf_ldflags_static(FILE *fp); 4357],[ 4358 return cf_ldflags_static(stdin); 4359],[ 4360 # some linkers simply ignore the -dynamic 4361 case x`file "conftest$ac_exeext" 2>/dev/null` in 4362 (*static*) 4363 cf_ldflags_static=no 4364 ;; 4365 (*) 4366 cf_ldflags_static=yes 4367 ;; 4368 esac 4369],[cf_ldflags_static=no]) 4370 4371 rm -f libconftest.* 4372 LIBS="$cf_save_LIBS" 4373 4374 AC_MSG_RESULT($cf_ldflags_static) 4375 4376 if test "$cf_ldflags_static" != yes 4377 then 4378 LDFLAGS_STATIC= 4379 LDFLAGS_SHARED= 4380 fi 4381else 4382 LDFLAGS_STATIC= 4383 LDFLAGS_SHARED= 4384fi 4385 4386AC_SUBST(LDFLAGS_STATIC) 4387AC_SUBST(LDFLAGS_SHARED) 4388]) 4389dnl --------------------------------------------------------------------------- 4390dnl CF_LD_RPATH_OPT version: 9 updated: 2021/01/01 13:31:04 4391dnl --------------- 4392dnl For the given system and compiler, find the compiler flags to pass to the 4393dnl loader to use the "rpath" feature. 4394AC_DEFUN([CF_LD_RPATH_OPT], 4395[ 4396AC_REQUIRE([CF_CHECK_CACHE]) 4397 4398LD_RPATH_OPT= 4399if test "x$cf_cv_enable_rpath" != xno 4400then 4401 AC_MSG_CHECKING(for an rpath option) 4402 case "$cf_cv_system_name" in 4403 (irix*) 4404 if test "$GCC" = yes; then 4405 LD_RPATH_OPT="-Wl,-rpath," 4406 else 4407 LD_RPATH_OPT="-rpath " 4408 fi 4409 ;; 4410 (linux*|gnu*|k*bsd*-gnu|freebsd*) 4411 LD_RPATH_OPT="-Wl,-rpath," 4412 ;; 4413 (openbsd[[2-9]].*|mirbsd*) 4414 LD_RPATH_OPT="-Wl,-rpath," 4415 ;; 4416 (dragonfly*) 4417 LD_RPATH_OPT="-rpath " 4418 ;; 4419 (netbsd*) 4420 LD_RPATH_OPT="-Wl,-rpath," 4421 ;; 4422 (osf*|mls+*) 4423 LD_RPATH_OPT="-rpath " 4424 ;; 4425 (solaris2*) 4426 LD_RPATH_OPT="-R" 4427 ;; 4428 (*) 4429 ;; 4430 esac 4431 AC_MSG_RESULT($LD_RPATH_OPT) 4432 4433 case "x$LD_RPATH_OPT" in 4434 (x-R*) 4435 AC_MSG_CHECKING(if we need a space after rpath option) 4436 cf_save_LIBS="$LIBS" 4437 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir) 4438 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes) 4439 LIBS="$cf_save_LIBS" 4440 AC_MSG_RESULT($cf_rpath_space) 4441 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT " 4442 ;; 4443 esac 4444fi 4445])dnl 4446dnl --------------------------------------------------------------------------- 4447dnl CF_LD_SEARCHPATH version: 4 updated: 2022/08/27 15:43:08 4448dnl ---------------- 4449dnl Try to obtain the linker's search-path, for use in scripts. 4450dnl 4451dnl Ignore LD_LIBRARY_PATH, etc. 4452AC_DEFUN([CF_LD_SEARCHPATH],[ 4453AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[ 4454 4455if test "$cross_compiling" != yes ; then 4456 4457# GNU binutils' ld does not involve permissions which may stop ldconfig. 4458cf_pathlist=`${LD:-ld} --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u` 4459 4460# The -NX options tell newer versions of Linux ldconfig to not attempt to 4461# update the cache, which makes it run faster. 4462test -z "$cf_pathlist" && \ 4463 cf_pathlist=`(ldconfig -NX -v) 2>/dev/null | sed -e '/^[[ ]]/d' -e 's/:$//' | sort -u` 4464 4465test -z "$cf_pathlist" && 4466 cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e '/^[[ ]]/d' -e 's/:$//p' | sort -u` 4467 4468# This works with OpenBSD 6.5, which lists only filenames 4469test -z "$cf_pathlist" && 4470 cf_pathlist=`(ldconfig -v) 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u` 4471 4472if test -z "$cf_pathlist" 4473then 4474 # dyld default path with MacOS 4475 if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin 4476 then 4477 # do this to bypass check 4478 cf_cv_ld_searchpath='$HOME/lib' 4479 cf_pathlist="/usr/local/lib /lib /usr/lib" 4480 fi 4481fi 4482 4483if test -z "$cf_pathlist" 4484then 4485 # Solaris is "SunOS" 4486 if test -f /usr/bin/isainfo && test "x`uname -s`" = xSunOS 4487 then 4488 case x`(isainfo -b)` in 4489 (x64) 4490 cf_pathlist="$cf_pathlist /lib/64 /usr/lib/64" 4491 ;; 4492 (x32) 4493 test -d /usr/ccs/lib && cf_pathlist="$cf_pathlist /usr/ccs/lib" 4494 cf_pathlist="$cf_pathlist /lib /usr/lib" 4495 ;; 4496 (*) 4497 AC_MSG_WARN(problem with Solaris architecture) 4498 ;; 4499 esac 4500 fi 4501fi 4502 4503if test -z "$cf_pathlist" 4504then 4505 # HP-UX 4506 if test x"`uname -s`" = xHP-UX 4507 then 4508 case x`getconf LONG_BIT` in 4509 (x64) 4510 cf_pathlist="/usr/lib/hpux64" 4511 ;; 4512 (x*) 4513 cf_pathlist="/usr/lib/hpux32" 4514 ;; 4515 esac 4516 fi 4517fi 4518 4519fi 4520 4521# If nothing else, assume it is conventional 4522test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib" 4523 4524# Finally, check that this is only directories 4525for cf_path in [$]0 $cf_pathlist 4526do 4527 if test -d "$cf_path"; then 4528 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} " 4529 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}" 4530 fi 4531done 4532 4533# Ensure that it is nonempty 4534test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib 4535]) 4536 4537LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'` 4538AC_SUBST(LD_SEARCHPATH) 4539])dnl 4540dnl --------------------------------------------------------------------------- 4541dnl CF_LIBRARY_PATH version: 11 updated: 2021/01/01 13:31:04 4542dnl --------------- 4543dnl Construct a search-list of directories for a nonstandard library-file 4544dnl 4545dnl Parameters 4546dnl $1 = the variable to return as result 4547dnl $2 = the package name 4548AC_DEFUN([CF_LIBRARY_PATH], 4549[ 4550$1= 4551cf_library_path_list="" 4552if test -n "${LDFLAGS}${LIBS}" ; then 4553 for cf_library_path in $LDFLAGS $LIBS 4554 do 4555 case "$cf_library_path" in 4556 (-L*) 4557 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` 4558 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE) 4559 cf_library_path_list="$cf_library_path_list [$]$1" 4560 ;; 4561 esac 4562 done 4563fi 4564 4565CF_SUBDIR_PATH($1,$2,lib) 4566 4567$1="$cf_library_path_list [$]$1" 4568])dnl 4569dnl --------------------------------------------------------------------------- 4570dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09 4571dnl ------------------ 4572AC_DEFUN([CF_LIBTOOL_VERSION],[ 4573if test -n "$LIBTOOL" && test "$LIBTOOL" != none 4574then 4575 cf_cv_libtool_version=`$LIBTOOL --version 2>&1 | sed -e '/^$/d' |sed -e '2,$d' -e 's/([[^)]]*)//g' -e 's/^[[^1-9]]*//' -e 's/[[^0-9.]].*//'` 4576else 4577 cf_cv_libtool_version= 4578fi 4579test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version 4580])dnl 4581dnl --------------------------------------------------------------------------- 4582dnl CF_LIB_PREFIX version: 14 updated: 2021/01/01 13:31:04 4583dnl ------------- 4584dnl Compute the library-prefix for the given host system 4585dnl $1 = variable to set 4586define([CF_LIB_PREFIX], 4587[ 4588 case "$cf_cv_system_name" in 4589 (OS/2*|os2*) 4590 if test "$DFT_LWR_MODEL" = libtool; then 4591 LIB_PREFIX='lib' 4592 else 4593 LIB_PREFIX='' 4594 fi 4595 ;; 4596 (*-msvc*) 4597 LIB_PREFIX='' 4598 ;; 4599 (*) LIB_PREFIX='lib' 4600 ;; 4601 esac 4602ifelse($1,,,[$1=$LIB_PREFIX]) 4603 AC_SUBST(LIB_PREFIX) 4604])dnl 4605dnl --------------------------------------------------------------------------- 4606dnl CF_LIB_RULES version: 100 updated: 2023/06/03 15:17:30 4607dnl ------------ 4608dnl Append definitions and rules for the given models to the subdirectory 4609dnl Makefiles, and the recursion rule for the top-level Makefile. If the 4610dnl subdirectory is a library-source directory, modify the Libs_To_Make list in 4611dnl the corresponding makefile to list the models that we'll generate. 4612dnl 4613dnl For shared libraries, make a list of symbolic links to construct when 4614dnl generating each library. The convention used for Linux is the simplest 4615dnl one: 4616dnl lib<name>.so -> 4617dnl lib<name>.so.<major> -> 4618dnl lib<name>.so.<maj>.<minor> 4619dnl 4620dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable. 4621AC_DEFUN([CF_LIB_RULES], 4622[AC_REQUIRE([AC_PROG_FGREP])dnl 4623AC_REQUIRE([CF_MAKE_PHONY])dnl 4624 4625cf_prefix=$LIB_PREFIX 4626AC_REQUIRE([CF_SUBST_NCURSES_VERSION]) 4627 4628case "$cf_cv_shlib_version" in 4629(cygdll|msysdll|mingw|msvcdll) 4630 TINFO_NAME=$TINFO_ARG_SUFFIX 4631 TINFO_SUFFIX=.dll 4632 ;; 4633esac 4634 4635if test -n "$TINFO_SUFFIX" ; then 4636 case "$TINFO_SUFFIX" in 4637 (tw*) 4638 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}" 4639 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^tw'$EXTRA_SUFFIX'//'` 4640 ;; 4641 (t*) 4642 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}" 4643 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^t'$EXTRA_SUFFIX'//'` 4644 ;; 4645 (w*) 4646 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}" 4647 TINFO_SUFFIX=`echo "$TINFO_SUFFIX" | sed 's/^w'$EXTRA_SUFFIX'//'` 4648 ;; 4649 esac 4650fi 4651 4652for cf_dir in $SRC_SUBDIRS 4653do 4654 if test ! -d "$srcdir/$cf_dir" ; then 4655 continue 4656 elif test -f "$srcdir/$cf_dir/modules" ; then 4657 4658 SHARED_LIB= 4659 Libs_To_Make= 4660 cf_awk_program= 4661 if test -n "${cf_cv_abi_default}" && test "x${cf_cv_abi_default}" != "x5" 4662 then 4663 cf_awk_program="$cf_awk_program\ 4664/deprecated in ABI${cf_cv_abi_default}/ { next; }\ 4665{ sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_default}\"); }\ 4666" 4667 fi 4668 4669 if test "x$WILDCARD_SYMS" = xno 4670 then 4671 cf_awk_program="$cf_awk_program\ 4672/[[ ]]_\\*;/ { skip=1; next; }\ 4673" 4674 fi 4675 4676 if test "x$cf_awk_program" != "x" 4677 then 4678 cat >>$cf_dir/Makefile <<CF_EOF 4679 4680# Generated by CF_LIB_RULES 4681resulting.map: $UNALTERED_SYMS 4682 $AWK 'BEGIN { skip = 1; last=""; } \ 4683$cf_awk_program \ 4684{ if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\ 4685 skip = 0; last = \[$]\[$]0; } \ 4686END { print last; }' < "$UNALTERED_SYMS" >\[$]@ 4687 4688distclean:: 4689 rm -f resulting.map 4690CF_EOF 4691 fi 4692 4693 for cf_item in $cf_LIST_MODELS 4694 do 4695 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf) 4696 if test "$cf_dir" = "c++" 4697 then 4698 CF_MAP_LIB_BASENAME(cf_libname,cxx) 4699 else 4700 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir) 4701 fi 4702 test -z "$cf_libname" && cf_libname="$cf_dir" 4703 if test "$cf_item" = shared ; then 4704 if test -n "${LIB_SUFFIX}" 4705 then 4706 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'` 4707 else 4708 cf_shared_suffix="$cf_suffix" 4709 fi 4710 if test "$cf_cv_do_symlinks" = yes ; then 4711 cf_version_name= 4712 4713 case "$cf_cv_shlib_version" in 4714 (rel) 4715 cf_version_name=REL_VERSION 4716 ;; 4717 (abi) 4718 cf_version_name=ABI_VERSION 4719 ;; 4720 esac 4721 4722 if test -n "$cf_version_name" 4723 then 4724 case "$cf_cv_system_name" in 4725 (darwin*) 4726 # "w", etc? 4727 cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix" 4728 ;; 4729 (*) 4730 cf_suffix="$cf_suffix"'.${'$cf_version_name'}' 4731 ;; 4732 esac 4733 fi 4734 if test -n "${USE_LIB_SUFFIX}" 4735 then 4736 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'` 4737 else 4738 cf_shared_suffix="$cf_suffix" 4739 fi 4740 fi 4741 # cygwin needs import library, and has unique naming convention 4742 # use autodetected ${cf_prefix} for import lib and static lib, but 4743 # use 'cyg' prefix for shared lib. 4744 case "$cf_cv_shlib_version" in 4745 (cygdll) 4746 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4747 cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}" 4748 ;; 4749 (msysdll) 4750 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4751 cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}" 4752 ;; 4753 (mingw) 4754 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4755 cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}" 4756 ;; 4757 (msvcdll) 4758 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4759 cf_add_lib="../lib/${cf_libname}${cf_cygsuf}" 4760 ;; 4761 (*) 4762 cf_add_lib= 4763 ;; 4764 esac 4765 if test -n "$cf_add_lib" 4766 then 4767 Libs_To_Make="$Libs_To_Make $cf_add_lib" 4768 continue 4769 fi 4770 fi 4771 cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}" 4772 Libs_To_Make="$Libs_To_Make $cf_add_lib" 4773 done 4774 4775 if test "$cf_dir" = ncurses ; then 4776 cf_subsets="$LIB_SUBSETS" 4777 cf_r_parts="$cf_subsets" 4778 cf_liblist="$Libs_To_Make" 4779 4780 while test -n "$cf_r_parts" 4781 do 4782 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'` 4783 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'` 4784 if test "$cf_l_parts" != "$cf_r_parts" ; then 4785 cf_add_lib= 4786 case "$cf_l_parts" in 4787 (*termlib*) 4788 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g` 4789 ;; 4790 (*ticlib*) 4791 cf_add_lib=`echo "$cf_liblist" |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g` 4792 ;; 4793 (*) 4794 break 4795 ;; 4796 esac 4797 if test -n "$cf_add_lib"; then 4798 Libs_To_Make="$cf_add_lib $Libs_To_Make" 4799 fi 4800 else 4801 break 4802 fi 4803 done 4804 else 4805 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'` 4806 fi 4807 4808 if test "$cf_dir" = c++; then 4809 if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then 4810 cf_list= 4811 for cf_item in $Libs_To_Make 4812 do 4813 case "$cf_item" in 4814 (*.a) 4815 ;; 4816 (*) 4817 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"` 4818 ;; 4819 esac 4820 for cf_test in $cf_list 4821 do 4822 if test "$cf_test" = "$cf_item" 4823 then 4824 cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'` 4825 cf_item= 4826 break 4827 fi 4828 done 4829 test -n "$cf_item" && cf_list="$cf_list $cf_item" 4830 done 4831 Libs_To_Make="$cf_list" 4832 fi 4833 fi 4834 4835 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \ 4836 -e "s%@SHARED_LIB@%$SHARED_LIB%" \ 4837 "$cf_dir/Makefile" >$cf_dir/Makefile.out 4838 mv "$cf_dir/Makefile.out" "$cf_dir/Makefile" 4839 4840 $AWK -f "$srcdir/mk-0th.awk" \ 4841 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \ 4842 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile 4843 4844 for cf_subset in $cf_subsets 4845 do 4846 cf_subdirs= 4847 for cf_item in $cf_LIST_MODELS 4848 do 4849 4850 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})" 4851 CF_UPPER(cf_ITEM,$cf_item) 4852 4853 CXX_MODEL=$cf_ITEM 4854 if test "$CXX_MODEL" = SHARED; then 4855 case "$cf_cv_shlib_version" in 4856 (cygdll|msysdll|mingw|msvcdll) 4857 test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED) 4858 with_shared_cxx=yes 4859 ;; 4860 (*) 4861 test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL 4862 ;; 4863 esac 4864 fi 4865 4866 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf) 4867 CF_OBJ_SUBDIR($cf_item,cf_subdir) 4868 4869 # Test for case where we build libtinfo with a different name. 4870 cf_libname=$cf_dir 4871 if test "$cf_dir" = ncurses ; then 4872 case "$cf_subset" in 4873 (*base*) 4874 cf_libname=${cf_libname}$USE_LIB_SUFFIX 4875 ;; 4876 (*termlib*) 4877 cf_libname=$TINFO_LIB_SUFFIX 4878 ;; 4879 (ticlib*) 4880 cf_libname=$TICS_LIB_SUFFIX 4881 ;; 4882 esac 4883 elif test "$cf_dir" = c++ ; then 4884 CF_MAP_LIB_BASENAME(cf_libname,cxx) 4885 cf_libname=${cf_libname}$USE_LIB_SUFFIX 4886 else 4887 CF_MAP_LIB_BASENAME(cf_libname,$cf_dir) 4888 cf_libname=${cf_libname}$USE_LIB_SUFFIX 4889 fi 4890 if test -n "${USE_ARG_SUFFIX}" ; then 4891 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX 4892 cf_suffix=`echo "$cf_suffix" |sed -e "s%^${USE_LIB_SUFFIX}%%"` 4893 fi 4894 4895 # These dependencies really are for development, not 4896 # builds, but they are useful in porting, too. 4897 cf_depend="../include/ncurses_cfg.h" 4898 if test "$srcdir" = "."; then 4899 cf_reldir="." 4900 else 4901 cf_reldir="\${srcdir}" 4902 fi 4903 4904 if test -f "$srcdir/$cf_dir/$cf_dir.priv.h" ; then 4905 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h" 4906 elif test -f "$srcdir/$cf_dir/curses.priv.h" ; then 4907 cf_depend="$cf_depend $cf_reldir/curses.priv.h" 4908 fi 4909 4910 cf_dir_suffix= 4911 old_cf_suffix="$cf_suffix" 4912 if test "$cf_cv_shlib_version_infix" = yes ; then 4913 if test -n "$USE_LIB_SUFFIX" ; then 4914 case "$USE_LIB_SUFFIX" in 4915 (tw*) 4916 cf_libname=`echo "$cf_libname" | sed 's/tw'$EXTRA_SUFFIX'$//'` 4917 cf_suffix=`echo "$cf_suffix" | sed 's/^tw'$EXTRA_SUFFIX'//'` 4918 cf_dir_suffix=tw$EXTRA_SUFFIX 4919 ;; 4920 (t*) 4921 cf_libname=`echo "$cf_libname" | sed 's/t'$EXTRA_SUFFIX'$//'` 4922 cf_suffix=`echo "$cf_suffix" | sed 's/^t'$EXTRA_SUFFIX'//'` 4923 cf_dir_suffix=t$EXTRA_SUFFIX 4924 ;; 4925 (w*) 4926 cf_libname=`echo "$cf_libname" | sed 's/w'$EXTRA_SUFFIX'$//'` 4927 cf_suffix=`echo "$cf_suffix" | sed 's/^w'$EXTRA_SUFFIX'//'` 4928 cf_dir_suffix=w$EXTRA_SUFFIX 4929 ;; 4930 (*) 4931 cf_libname=`echo "$cf_libname" | sed 's/'$EXTRA_SUFFIX'$//'` 4932 cf_suffix=`echo "$cf_suffix" | sed 's/^'$EXTRA_SUFFIX'//'` 4933 cf_dir_suffix=$EXTRA_SUFFIX 4934 ;; 4935 esac 4936 fi 4937 fi 4938 4939 $AWK -f "$srcdir/mk-1st.awk" \ 4940 name=${cf_libname}${cf_dir_suffix} \ 4941 traces=$LIB_TRACING \ 4942 MODEL=$cf_ITEM \ 4943 CXX_MODEL=$CXX_MODEL \ 4944 LIB_SUFFIX=$LIB_SUFFIX \ 4945 USE_LIB_SUFFIX=$USE_LIB_SUFFIX \ 4946 make_phony="${cf_cv_make_PHONY:-no}" \ 4947 model=$cf_subdir \ 4948 prefix=$cf_prefix \ 4949 suffix=$cf_suffix \ 4950 subset=$cf_subset \ 4951 driver=$cf_cv_term_driver \ 4952 SymLink="$LN_S" \ 4953 TermlibRoot=$TINFO_NAME \ 4954 TermlibSuffix=$TINFO_SUFFIX \ 4955 ShlibVer=$cf_cv_shlib_version \ 4956 ShlibVerInfix=$cf_cv_shlib_version_infix \ 4957 ReLink=${cf_cv_do_relink:-no} \ 4958 ReRanlib=${cf_cv_do_reranlib:-yes} \ 4959 DoLinks=$cf_cv_do_symlinks \ 4960 rmSoLocs=$cf_cv_rm_so_locs \ 4961 ldconfig="$LDCONFIG" \ 4962 overwrite=$WITH_OVERWRITE \ 4963 depend="$cf_depend" \ 4964 host="$host" \ 4965 libtool_version="$LIBTOOL_VERSION" \ 4966 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile 4967 4968 cf_suffix="$old_cf_suffix" 4969 4970 for cf_subdir2 in $cf_subdirs lib 4971 do 4972 test "$cf_subdir" = "$cf_subdir2" && break 4973 done 4974 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \ 4975 $AWK -f "$srcdir/mk-2nd.awk" \ 4976 name=$cf_dir \ 4977 traces=$LIB_TRACING \ 4978 MODEL=$cf_ITEM \ 4979 model=$cf_subdir \ 4980 subset=$cf_subset \ 4981 srcdir=$srcdir \ 4982 echo=$WITH_ECHO \ 4983 crenames=$cf_cv_prog_CC_c_o \ 4984 cxxrenames=$cf_cv_prog_CXX_c_o \ 4985 "$srcdir/$cf_dir/modules" >>$cf_dir/Makefile 4986 cf_subdirs="$cf_subdirs $cf_subdir" 4987 done 4988 done 4989 fi 4990 4991 echo ' ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >>Makefile 4992done 4993 4994echo >> Makefile 4995echo '# generated by CF_LIB_RULES' >> Makefile 4996 4997if test "x$cf_cv_make_PHONY" = xyes ; then 4998 cat >> Makefile <<-CF_EOF 4999 5000 .PHONY : libs 5001 .PHONY : lintlib 5002 .PHONY : install.includes 5003 .PHONY : uninstall.includes 5004 .PHONY : install.libs 5005 .PHONY : uninstall.libs 5006CF_EOF 5007fi 5008 5009for cf_dir in $SRC_SUBDIRS 5010do 5011 if test ! -d "$srcdir/$cf_dir" ; then 5012 continue 5013 fi 5014 5015 if test -f "$cf_dir/Makefile" ; then 5016 case "$cf_dir" in 5017 (Ada95) 5018 echo 'libs \' >> Makefile 5019 echo 'install.libs \' >> Makefile 5020 echo 'uninstall.libs ::' >> Makefile 5021 echo ' ( cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@ )' >> Makefile 5022 ;; 5023 esac 5024 fi 5025 5026 if test -f "$srcdir/$cf_dir/modules" ; then 5027 5028 if test "x$cf_cv_make_PHONY" = xyes ; then 5029 cat >> Makefile <<-CF_EOF 5030 5031 .PHONY : install.$cf_dir 5032 .PHONY : uninstall.$cf_dir 5033CF_EOF 5034 fi 5035 5036 echo >> Makefile 5037 if test -f "$srcdir/$cf_dir/headers" ; then 5038cat >> Makefile <<CF_EOF 5039install.includes \\ 5040uninstall.includes \\ 5041CF_EOF 5042 fi 5043 5044cat >> Makefile <<CF_EOF 5045lint \\ 5046libs \\ 5047lintlib \\ 5048install.libs \\ 5049uninstall.libs \\ 5050install.$cf_dir \\ 5051uninstall.$cf_dir :: 5052 ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ ) 5053CF_EOF 5054 elif test -f "$srcdir/$cf_dir/headers" ; then 5055cat >> Makefile <<CF_EOF 5056 5057libs \\ 5058install.libs \\ 5059uninstall.libs \\ 5060install.includes \\ 5061uninstall.includes :: 5062 ( cd "$cf_dir" && \${MAKE} \${TOP_MFLAGS} \[$]@ ) 5063CF_EOF 5064fi 5065done 5066 5067if test "x$cf_cv_make_PHONY" = xyes ; then 5068 cat >> Makefile <<-CF_EOF 5069 5070 .PHONY : install.data 5071 .PHONY : uninstall.data 5072CF_EOF 5073fi 5074 5075if test "x$cf_with_db_install" = xyes; then 5076cat >> Makefile <<CF_EOF 5077 5078install.libs uninstall.libs \\ 5079install.data uninstall.data :: 5080$MAKE_TERMINFO ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ ) 5081CF_EOF 5082else 5083cat >> Makefile <<CF_EOF 5084 5085install.libs uninstall.libs :: 5086 ( cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ ) 5087CF_EOF 5088fi 5089 5090if test "x$cf_with_manpages" = xyes; then 5091 5092if test "x$cf_cv_make_PHONY" = xyes ; then 5093 cat >> Makefile <<-CF_EOF 5094 5095 .PHONY : install.man 5096 .PHONY : uninstall.man 5097CF_EOF 5098fi 5099 5100cat >> Makefile <<CF_EOF 5101 5102install.man \\ 5103uninstall.man :: 5104 ( cd man && \${MAKE} \${TOP_MFLAGS} \[$]@ ) 5105CF_EOF 5106fi 5107 5108cat >> Makefile <<CF_EOF 5109 5110distclean :: 5111 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h 5112 rm -f headers.sh headers.sed mk_shared_lib.sh 5113 rm -f edit_man.* man_alias.* *.tmp 5114 rm -rf \${DIRS_TO_MAKE} 5115CF_EOF 5116 5117dnl If we're installing into a subdirectory of /usr/include, etc., we should 5118dnl prepend the subdirectory's name to the "#include" paths. It won't hurt 5119dnl anything, and will make it more standardized. It's awkward to decide this 5120dnl at configuration because of quoting, so we'll simply make all headers 5121dnl installed via a script that can do the right thing. 5122 5123rm -f headers.sed headers.sh 5124 5125dnl ( generating this script makes the makefiles a little tidier :-) 5126echo creating headers.sh 5127cat >headers.sh <<CF_EOF 5128#! $SHELL 5129# This shell script is generated by the 'configure' script. It is invoked in a 5130# subdirectory of the build tree. It generates a sed-script in the parent 5131# directory that is used to adjust includes for header files that reside in a 5132# subdirectory of /usr/include, etc. 5133PRG="" 5134while test \[$]# != 3 5135do 5136PRG="\$PRG \[$]1"; shift 5137done 5138DST=\[$]1 5139REF=\[$]2 5140SRC=\[$]3 5141TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$ 5142TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$ 5143echo installing \$SRC in \$DST 5144CF_EOF 5145 5146if test "$WITH_CURSES_H" = yes; then 5147 cat >>headers.sh <<CF_EOF 5148case \$DST in 5149(/*/include/*) 5150 END=\`basename \$DST\` 5151 for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\` 5152 do 5153 NAME=\`basename \$i\` 5154 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED 5155 done 5156 ;; 5157(*) 5158 echo "" >> \$TMPSED 5159 ;; 5160esac 5161CF_EOF 5162 5163else 5164 cat >>headers.sh <<CF_EOF 5165case \$DST in 5166(/*/include/*) 5167 END=\`basename \$DST\` 5168 for i in \`cat \$REF/../*/headers |${FGREP-fgrep} -v "#"\` 5169 do 5170 NAME=\`basename \$i\` 5171 if test "\$NAME" = "curses.h" 5172 then 5173 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED 5174 NAME=ncurses.h 5175 fi 5176 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED 5177 done 5178 ;; 5179(*) 5180 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED 5181 ;; 5182esac 5183CF_EOF 5184fi 5185cat >>headers.sh <<CF_EOF 5186rm -f \$TMPSRC 5187sed -f \$TMPSED \$SRC > \$TMPSRC 5188NAME=\`basename \$SRC\` 5189CF_EOF 5190if test "$WITH_CURSES_H" != yes; then 5191 cat >>headers.sh <<CF_EOF 5192test "\$NAME" = "curses.h" && NAME=ncurses.h 5193CF_EOF 5194fi 5195cat >>headers.sh <<CF_EOF 5196# Just in case someone gzip'd manpages, remove the conflicting copy. 5197test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz 5198 5199eval \$PRG \$TMPSRC \$DST/\$NAME 5200rm -f \$TMPSRC \$TMPSED 5201CF_EOF 5202 5203chmod 0755 headers.sh 5204 5205for cf_dir in $SRC_SUBDIRS 5206do 5207 if test ! -d "$srcdir/$cf_dir" ; then 5208 continue 5209 fi 5210 5211 if test -f "$srcdir/$cf_dir/headers" ; then 5212 $AWK -f "$srcdir/mk-hdr.awk" \ 5213 subset="$LIB_SUBSETS" \ 5214 compat="$WITH_CURSES_H" \ 5215 "$srcdir/$cf_dir/headers" >>$cf_dir/Makefile 5216 fi 5217 5218 if test -f "$srcdir/$cf_dir/modules" ; then 5219 if test "$cf_dir" != "c++" ; then 5220 if test "x$cf_cv_make_PHONY" = xyes ; then 5221 cat >> $cf_dir/Makefile <<-CF_EOF 5222 5223 .PHONY : depend 5224CF_EOF 5225 fi 5226 5227 cat >>$cf_dir/Makefile <<"CF_EOF" 5228depend : ${AUTO_SRC} 5229 makedepend -- ${CPPFLAGS} -- ${C_SRC} 5230 5231# DO NOT DELETE THIS LINE -- make depend depends on it. 5232CF_EOF 5233 fi 5234 fi 5235done 5236AC_SUBST(Libs_To_Make) 5237])dnl 5238dnl --------------------------------------------------------------------------- 5239dnl CF_LIB_SONAME version: 9 updated: 2021/01/04 18:48:01 5240dnl ------------- 5241dnl Find the and soname for the given shared library. Set the cache variable 5242dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache 5243dnl variable to "unknown". 5244dnl 5245dnl $1 = headers 5246dnl $2 = code 5247dnl $3 = library name 5248AC_DEFUN([CF_LIB_SONAME], 5249[AC_REQUIRE([AC_PROG_FGREP])dnl 5250 5251AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[ 5252 5253cf_cv_$3_soname=unknown 5254if test "$cross_compiling" != yes ; then 5255cat >conftest.$ac_ext <<CF_EOF 5256$1 5257int main(void) 5258{ 5259$2 5260 ${cf_cv_main_return:-return}(0); 5261} 5262CF_EOF 5263cf_save_LIBS="$LIBS" 5264 CF_ADD_LIB($3) 5265 if AC_TRY_EVAL(ac_compile) ; then 5266 if AC_TRY_EVAL(ac_link) ; then 5267 cf_cv_$3_soname="`ldd \"conftest$ac_exeext\" 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | ${FGREP-fgrep} lib$3.`" 5268 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown 5269 fi 5270 fi 5271rm -rf ./conftest* 5272LIBS="$cf_save_LIBS" 5273fi 5274]) 5275]) 5276dnl --------------------------------------------------------------------------- 5277dnl CF_LIB_SUFFIX version: 28 updated: 2021/01/01 16:53:59 5278dnl ------------- 5279dnl Compute the library file-suffix from the given model name 5280dnl $1 = model name 5281dnl $2 = variable to set (the nominal library suffix) 5282dnl $3 = dependency variable to set (actual filename) 5283dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. 5284AC_DEFUN([CF_LIB_SUFFIX], 5285[ 5286 case X$1 in 5287 (Xlibtool) 5288 $2='.la' 5289 $3=[$]$2 5290 ;; 5291 (Xdebug) 5292 case "$cf_cv_system_name" in 5293 (*-msvc*) 5294 $2='_g.lib' 5295 ;; 5296 (*) 5297 $2='_g.a' 5298 ;; 5299 esac 5300 $3=[$]$2 5301 ;; 5302 (Xprofile) 5303 case "$cf_cv_system_name" in 5304 (*-msvc*) 5305 $2='_p.lib' 5306 ;; 5307 (*) 5308 $2='_p.a' 5309 ;; 5310 esac 5311 $3=[$]$2 5312 ;; 5313 (Xshared) 5314 case "$cf_cv_system_name" in 5315 (aix[[5-7]]*) 5316 $2='.so' 5317 $3=[$]$2 5318 ;; 5319 (*-msvc*) 5320 $2='.dll' 5321 $3='.dll.lib' 5322 ;; 5323 (cygwin*|msys*|mingw*) 5324 $2='.dll' 5325 $3='.dll.a' 5326 ;; 5327 (darwin*) 5328 $2='.dylib' 5329 $3=[$]$2 5330 ;; 5331 (hpux*) 5332 case "$target" in 5333 (ia64*) 5334 $2='.so' 5335 $3=[$]$2 5336 ;; 5337 (*) 5338 $2='.sl' 5339 $3=[$]$2 5340 ;; 5341 esac 5342 ;; 5343 (*) 5344 $2='.so' 5345 $3=[$]$2 5346 ;; 5347 esac 5348 ;; 5349 (*) 5350 case "$target" in 5351 (*-msvc*) 5352 $2='.lib' 5353 ;; 5354 (*) 5355 $2='.a' 5356 ;; 5357 esac 5358 $3=[$]$2 5359 ;; 5360 esac 5361 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}" 5362 then 5363 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}" 5364 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}" 5365 fi 5366])dnl 5367dnl --------------------------------------------------------------------------- 5368dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04 5369dnl ----------- 5370dnl Compute the string to append to -library from the given model name 5371dnl $1 = model name 5372dnl $2 = variable to set 5373dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. 5374AC_DEFUN([CF_LIB_TYPE], 5375[ 5376 case $1 in 5377 (libtool) $2='' ;; 5378 (normal) $2='' ;; 5379 (debug) $2='_g' ;; 5380 (profile) $2='_p' ;; 5381 (shared) $2='' ;; 5382 esac 5383 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}" 5384])dnl 5385dnl --------------------------------------------------------------------------- 5386dnl CF_LINK_DATAONLY version: 15 updated: 2023/12/03 10:03:10 5387dnl ---------------- 5388dnl Some systems have a non-ANSI linker that doesn't pull in modules that have 5389dnl only data (i.e., no functions), for example NeXT. On those systems we'll 5390dnl have to provide wrappers for global tables to ensure they're linked 5391dnl properly. 5392AC_DEFUN([CF_LINK_DATAONLY], 5393[ 5394AC_MSG_CHECKING([if data-only library module links]) 5395AC_CACHE_VAL(cf_cv_link_dataonly,[ 5396 rm -f conftest.a 5397 cat >conftest.$ac_ext <<EOF 5398#line __oline__ "configure" 5399int testdata[[3]] = { 123, 456, 789 }; 5400EOF 5401 if AC_TRY_EVAL(ac_compile) ; then 5402 mv conftest.o data.o && \ 5403 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null 5404 fi 5405 rm -f conftest.$ac_ext data.o 5406 cat >conftest.$ac_ext <<EOF 5407#line __oline__ "configure" 5408extern int testfunc(void); 5409#if defined(NeXT) 5410int testfunc(void) 5411{ 5412 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */ 5413} 5414#else 5415extern int testdata[[3]]; 5416int testfunc(void) 5417{ 5418 return testdata[[0]] == 123 5419 && testdata[[1]] == 456 5420 && testdata[[2]] == 789; 5421} 5422#endif 5423EOF 5424 if AC_TRY_EVAL(ac_compile); then 5425 mv conftest.o func.o && \ 5426 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null 5427 fi 5428 rm -f conftest.$ac_ext func.o 5429 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null 5430 cf_saveLIBS="$LIBS" 5431 LIBS="conftest.a $LIBS" 5432 AC_TRY_RUN([ 5433 extern int testfunc(void); 5434 int main(void) 5435 { 5436 ${cf_cv_main_return:-return} (!testfunc()); 5437 } 5438 ], 5439 [cf_cv_link_dataonly=yes], 5440 [cf_cv_link_dataonly=no], 5441 [cf_cv_link_dataonly=unknown]) 5442 LIBS="$cf_saveLIBS" 5443 ]) 5444AC_MSG_RESULT($cf_cv_link_dataonly) 5445 5446if test "$cf_cv_link_dataonly" = no ; then 5447 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link]) 5448 BROKEN_LINKER=1 5449fi 5450AC_SUBST(BROKEN_LINKER) 5451 5452])dnl 5453dnl --------------------------------------------------------------------------- 5454dnl CF_LINK_FUNCS version: 13 updated: 2023/12/03 09:24:04 5455dnl ------------- 5456dnl Most Unix systems have both link and symlink, a few don't have symlink. 5457dnl A few non-Unix systems implement symlink, but not link. 5458dnl A few non-systems implement neither (or have nonfunctional versions). 5459dnl 5460dnl This allows for a 2-second difference in modification times to allow for 5461dnl some marginal NFS implementations. 5462AC_DEFUN([CF_LINK_FUNCS], 5463[ 5464AC_CHECK_HEADERS( \ 5465unistd.h \ 5466) 5467AC_CHECK_FUNCS( \ 5468 remove \ 5469 unlink ) 5470 5471if test "$cross_compiling" = yes ; then 5472 AC_CHECK_FUNCS( \ 5473 link \ 5474 symlink ) 5475else 5476 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[ 5477 cf_cv_link_funcs= 5478 for cf_func in link symlink ; do 5479 AC_TRY_RUN([ 5480$ac_includes_default 5481 5482int main(void) 5483{ 5484 int fail = 0; 5485 char src[] = "conftest.tmp"; 5486 char dst[] = "conftest.chk"; 5487 struct stat src_sb, dst_sb; 5488 FILE *fp = fopen(src, "w"); 5489 if (fp == 0) { fail = 3; } else { 5490 fclose(fp); stat(src, &src_sb); 5491 if ($cf_func(src, dst) < 0) { 5492 fail = 1; 5493 } else if (stat(dst, &dst_sb) < 0) { 5494 fail = 2; 5495 } else { 5496 long diff = (dst_sb.st_mtime - src_sb.st_mtime); 5497 if (diff < 0) diff = -diff; 5498 if (diff > 2) fail = 3; 5499 } 5500 } 5501#ifdef HAVE_UNLINK 5502 unlink(dst); unlink(src); 5503#else 5504 remove(dst); remove(src); 5505#endif 5506 ${cf_cv_main_return:-return} (fail); 5507} 5508 ],[ 5509 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func" 5510 eval 'ac_cv_func_'$cf_func'=yes'],[ 5511 eval 'ac_cv_func_'$cf_func'=no'],[ 5512 eval 'ac_cv_func_'$cf_func'=error']) 5513 done 5514 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no 5515 ]) 5516 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function]) 5517 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function]) 5518fi 5519])dnl 5520dnl --------------------------------------------------------------------------- 5521dnl CF_MAKEFLAGS version: 21 updated: 2021/09/04 06:47:34 5522dnl ------------ 5523dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make' 5524dnl options to lower-levels. It is very useful for "make -n" -- if we have it. 5525dnl (GNU 'make' does both, something POSIX 'make', which happens to make the 5526dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-) 5527AC_DEFUN([CF_MAKEFLAGS], 5528[AC_REQUIRE([AC_PROG_FGREP])dnl 5529 5530AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[ 5531 cf_cv_makeflags='' 5532 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}' 5533 do 5534 cat >cf_makeflags.tmp <<CF_EOF 5535SHELL = $SHELL 5536all : 5537 @ echo '.$cf_option' 5538CF_EOF 5539 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | ${FGREP-fgrep} -v "ing directory" | sed -e 's,[[ ]]*$,,'` 5540 case "$cf_result" in 5541 (.*k|.*kw) 5542 cf_result="`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null`" 5543 case "$cf_result" in 5544 (.*CC=*) cf_cv_makeflags= 5545 ;; 5546 (*) cf_cv_makeflags=$cf_option 5547 ;; 5548 esac 5549 break 5550 ;; 5551 (.-) 5552 ;; 5553 (*) 5554 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\") 5555 ;; 5556 esac 5557 done 5558 rm -f cf_makeflags.tmp 5559]) 5560 5561AC_SUBST(cf_cv_makeflags) 5562])dnl 5563dnl --------------------------------------------------------------------------- 5564dnl CF_MAKE_PHONY version: 3 updated: 2021/01/08 16:08:21 5565dnl ------------- 5566dnl Check if the make-program handles a ".PHONY" target, e.g,. a target which 5567dnl acts as a placeholder. 5568dnl 5569dnl The ".PHONY" feature was proposed in 2011 here 5570dnl https://www.austingroupbugs.net/view.php?id=523 5571dnl and is scheduled for release in P1003.1 Issue 8 (late 2022). 5572dnl 5573dnl This is not supported by SVr4 make (or SunOS 4, 4.3SD, etc), but works with 5574dnl a few others (i.e., GNU make and the non-POSIX "BSD" make): 5575dnl 5576dnl + This is a GNU make feature (since April 1988, but in turn from binutils, 5577dnl date unspecified). 5578dnl 5579dnl + It was adopted in NetBSD make in June 1995. 5580dnl 5581dnl + The other BSD make programs are derived from the NetBSD make (and for 5582dnl that reason are not actually different "implementations"). 5583dnl 5584dnl + Some features of NetBSD make were actually adapted from pmake, which 5585dnl began as a modified GNU make starting in 1993. 5586dnl 5587dnl + Version 3.8 of the dmake program in January 1992 also implemented this 5588dnl GNU make extension, but is less well known than the BSD make. 5589AC_DEFUN([CF_MAKE_PHONY],[ 5590AC_CACHE_CHECK(for \".PHONY\" make-support, cf_cv_make_PHONY,[ 5591 rm -rf conftest* 5592 ( 5593 mkdir conftest || exit 1 5594 cd conftest 5595 cat >makefile <<'CF_EOF' 5596.PHONY: always 5597DATA=0 5598always: always.out 5599 @echo "** making [$]@ [$](DATA)" 5600once: once.out 5601 @echo "** making [$]@ [$](DATA)" 5602always.out: 5603 @echo "** making [$]@ [$](DATA)" 5604 echo [$](DATA) > [$]@ 5605once.out: 5606 @echo "** making [$]@ [$](DATA)" 5607 echo [$](DATA) > [$]@ 5608CF_EOF 5609 for cf_data in 1 2 3 5610 do 5611 ${MAKE:-make} always DATA=$cf_data 5612 ${MAKE:-make} once DATA=$cf_data 5613 ${MAKE:-make} -t always once 5614 if test -f always ; then 5615 echo "no (case 1)" > ../conftest.tmp 5616 elif test ! -f always.out ; then 5617 echo "no (case 2)" > ../conftest.tmp 5618 elif test ! -f once.out ; then 5619 echo "no (case 3)" > ../conftest.tmp 5620 elif ! cmp -s always.out once.out ; then 5621 echo "no (case 4)" > ../conftest.tmp 5622 diff always.out once.out 5623 else 5624 cf_check="`cat always.out`" 5625 if test "x$cf_check" != "x$cf_data" ; then 5626 echo "no (case 5)" > ../conftest.tmp 5627 else 5628 echo yes > ../conftest.tmp 5629 rm -f ./*.out 5630 continue 5631 fi 5632 fi 5633 break 5634 done 5635 ) >&AC_FD_CC 2>&1 5636 cf_cv_make_PHONY="`cat conftest.tmp`" 5637 rm -rf conftest* 5638]) 5639MAKE_NO_PHONY="#" 5640MAKE_PHONY="#" 5641test "x$cf_cv_make_PHONY" = xyes && MAKE_PHONY= 5642test "x$cf_cv_make_PHONY" != xyes && MAKE_NO_PHONY= 5643AC_SUBST(MAKE_NO_PHONY) 5644AC_SUBST(MAKE_PHONY) 5645])dnl 5646dnl --------------------------------------------------------------------------- 5647dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32 5648dnl ------------ 5649dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have 5650dnl a monocase filesystem. 5651AC_DEFUN([CF_MAKE_TAGS],[ 5652AC_REQUIRE([CF_MIXEDCASE_FILENAMES]) 5653 5654AC_CHECK_PROGS(CTAGS, exctags ctags) 5655AC_CHECK_PROGS(ETAGS, exetags etags) 5656 5657AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no) 5658 5659if test "$cf_cv_mixedcase" = yes ; then 5660 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no) 5661else 5662 MAKE_UPPER_TAGS=no 5663fi 5664 5665if test "$MAKE_UPPER_TAGS" = yes ; then 5666 MAKE_UPPER_TAGS= 5667else 5668 MAKE_UPPER_TAGS="#" 5669fi 5670 5671if test "$MAKE_LOWER_TAGS" = yes ; then 5672 MAKE_LOWER_TAGS= 5673else 5674 MAKE_LOWER_TAGS="#" 5675fi 5676 5677AC_SUBST(CTAGS) 5678AC_SUBST(ETAGS) 5679 5680AC_SUBST(MAKE_UPPER_TAGS) 5681AC_SUBST(MAKE_LOWER_TAGS) 5682])dnl 5683dnl --------------------------------------------------------------------------- 5684dnl CF_MANPAGE_FORMAT version: 19 updated: 2024/03/30 08:27:40 5685dnl ----------------- 5686dnl Option to allow user to override automatic configuration of manpage format. 5687dnl There are several special cases: 5688dnl 5689dnl compress - man checks for, can display compressed files 5690dnl bzip2 - man checks for, can display bzip2'd files 5691dnl gzip - man checks for, can display gzip'd files 5692dnl xz - man checks for, can display xz'd files 5693dnl 5694dnl BSDI - files in the cat-directories are suffixed ".0" 5695dnl formatted - installer should format (put files in cat-directory) 5696dnl catonly - installer should only format, e.g., for a turnkey system. 5697dnl 5698dnl There are other configurations which this macro does not test, e.g., HPUX's 5699dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming 5700dnl convention would not match our use). 5701AC_DEFUN([CF_MANPAGE_FORMAT], 5702[ 5703AC_REQUIRE([CF_PATHSEP]) 5704AC_MSG_CHECKING(format of man-pages) 5705 5706AC_ARG_WITH(manpage-format, 5707 [ --with-manpage-format specify manpage-format: gzip/compress/bzip2/xz, 5708 BSDI/normal and optionally formatted/catonly, 5709 e.g., gzip,formatted], 5710 [MANPAGE_FORMAT=$withval], 5711 [MANPAGE_FORMAT=unknown]) 5712 5713test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown 5714MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'` 5715 5716cf_unknown= 5717 5718case "$MANPAGE_FORMAT" in 5719(unknown) 5720 if test -z "$MANPATH" ; then 5721 MANPATH="/usr/man:/usr/share/man" 5722 fi 5723 5724 # look for the 'date' man-page (it is most likely to be installed!) 5725 MANPAGE_FORMAT= 5726 cf_preform="no" 5727 cf_catonly="yes" 5728 cf_example="date" 5729 5730 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}" 5731 for cf_dir in $MANPATH; do 5732 test -z "$cf_dir" && cf_dir=/usr/man 5733 for cf_name in $cf_dir/man*/$cf_example.[[01]]* $cf_dir/cat*/$cf_example.[[01]]* $cf_dir/man*/$cf_example $cf_dir/cat*/$cf_example 5734 do 5735 cf_test=`echo "$cf_name" | sed -e 's/*//'` 5736 if test "x$cf_test" = "x$cf_name" ; then 5737 5738 case "$cf_name" in 5739 (*.bz2) MANPAGE_FORMAT="$MANPAGE_FORMAT bzip2";; 5740 (*.xz) MANPAGE_FORMAT="$MANPAGE_FORMAT xz";; 5741 (*.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";; 5742 (*.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";; 5743 (*.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";; 5744 (*) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";; 5745 esac 5746 5747 case "$cf_name" in 5748 ($cf_dir/man*) 5749 cf_catonly=no 5750 ;; 5751 ($cf_dir/cat*) 5752 cf_preform=yes 5753 ;; 5754 esac 5755 break 5756 fi 5757 5758 # if we found a match in either man* or cat*, stop looking 5759 if test -n "$MANPAGE_FORMAT" ; then 5760 cf_found=no 5761 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted" 5762 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly" 5763 case "$cf_name" in 5764 ($cf_dir/cat*) 5765 cf_found=yes 5766 ;; 5767 esac 5768 test "$cf_found" = yes && break 5769 fi 5770 done 5771 # only check the first directory in $MANPATH where we find manpages 5772 if test -n "$MANPAGE_FORMAT" ; then 5773 break 5774 fi 5775 done 5776 # if we did not find the example, just assume it is normal 5777 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal 5778 IFS="$ac_save_ifs" 5779 ;; 5780(*) 5781 for cf_option in $MANPAGE_FORMAT; do 5782 case "$cf_option" in 5783 (xz|bzip2|gzip|compress|BSDI|normal|formatted|catonly) 5784 ;; 5785 (*) 5786 cf_unknown="$cf_unknown $cf_option" 5787 ;; 5788 esac 5789 done 5790 ;; 5791esac 5792 5793AC_MSG_RESULT($MANPAGE_FORMAT) 5794if test -n "$cf_unknown" ; then 5795 AC_MSG_WARN(Unexpected manpage-format $cf_unknown) 5796fi 5797 5798cf_manpage_format=no 5799cf_manpage_inboth=no 5800cf_manpage_so_strip= 5801cf_manpage_compress= 5802cf_manpage_coptions= 5803 5804for cf_item in $MANPAGE_FORMAT 5805do 5806case "$cf_item" in 5807(catonly) 5808 cf_manpage_format=yes 5809 cf_manpage_inboth=no 5810 ;; 5811(formatted) 5812 cf_manpage_format=yes 5813 cf_manpage_inboth=yes 5814 ;; 5815(compress) 5816 cf_manpage_so_strip="Z" 5817 cf_manpage_compress=compress 5818 ;; 5819(gzip) 5820 cf_manpage_so_strip="gz" 5821 cf_manpage_compress=gzip 5822 cf_manpage_coptions=-n 5823 ;; 5824(bzip2) 5825 cf_manpage_so_strip="bz2" 5826 cf_manpage_compress=bzip2 5827 ;; 5828(xz) 5829 cf_manpage_so_strip="xz" 5830 cf_manpage_compress=xz 5831 ;; 5832esac 5833done 5834 5835AC_SUBST(cf_manpage_format) 5836AC_SUBST(cf_manpage_inboth) 5837AC_SUBST(cf_manpage_so_strip) 5838AC_SUBST(cf_manpage_compress) 5839AC_SUBST(cf_manpage_coptions) 5840 5841])dnl 5842dnl --------------------------------------------------------------------------- 5843dnl CF_MANPAGE_RENAMES version: 17 updated: 2022/10/23 07:46:29 5844dnl ------------------ 5845dnl The Debian people have their own naming convention for manpages. This 5846dnl option lets us override the name of the file containing renaming, or 5847dnl disable it altogether. 5848AC_DEFUN([CF_MANPAGE_RENAMES], 5849[ 5850AC_MSG_CHECKING(for manpage renaming) 5851 5852AC_ARG_WITH(manpage-renames, 5853 [ --with-manpage-renames specify manpage-renaming], 5854 [MANPAGE_RENAMES=$withval], 5855 [MANPAGE_RENAMES=yes]) 5856 5857case ".$MANPAGE_RENAMES" in 5858(.no) 5859 ;; 5860(.|.yes) 5861 # Debian 'man' program? 5862 if test -f /etc/debian_version ; then 5863 MANPAGE_RENAMES=man/man_db.renames 5864 else 5865 MANPAGE_RENAMES=no 5866 fi 5867 ;; 5868esac 5869 5870if test "$MANPAGE_RENAMES" = man/man_db.renames ; then 5871 MANPAGE_RENAMES=`pwd`/$MANPAGE_RENAMES 5872elif test "$MANPAGE_RENAMES" = no ; then 5873 : 5874elif test ! -f "$MANPAGE_RENAMES" ; then 5875 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES) 5876fi 5877 5878AC_MSG_RESULT($MANPAGE_RENAMES) 5879AC_SUBST(MANPAGE_RENAMES) 5880])dnl 5881dnl --------------------------------------------------------------------------- 5882dnl CF_MANPAGE_SYMLINKS version: 7 updated: 2023/01/21 16:37:17 5883dnl ------------------- 5884dnl Some people expect each tool to make all aliases for manpages in the 5885dnl man-directory. This accommodates the older, less-capable implementations 5886dnl of 'man', and is optional. 5887AC_DEFUN([CF_MANPAGE_SYMLINKS], 5888[ 5889AC_MSG_CHECKING(if manpage aliases will be installed) 5890 5891AC_ARG_WITH(manpage-aliases, 5892 [ --with-manpage-aliases specify manpage-aliases using .so], 5893 [MANPAGE_ALIASES=$withval], 5894 [MANPAGE_ALIASES=yes]) 5895 5896AC_MSG_RESULT($MANPAGE_ALIASES) 5897 5898case "x$LN_S" in 5899(xln*) 5900 cf_use_symlinks=yes 5901 ;; 5902(*) 5903 cf_use_symlinks=no 5904 ;; 5905esac 5906 5907MANPAGE_SYMLINKS=no 5908if test "$MANPAGE_ALIASES" = yes ; then 5909AC_MSG_CHECKING(if manpage symlinks should be used) 5910 5911AC_ARG_WITH(manpage-symlinks, 5912 [ --with-manpage-symlinks specify manpage-aliases using symlinks], 5913 [MANPAGE_SYMLINKS=$withval], 5914 [MANPAGE_SYMLINKS=$cf_use_symlinks]) 5915 5916if test "$cf_use_symlinks" = no; then 5917if test "$MANPAGE_SYMLINKS" = yes ; then 5918 AC_MSG_WARN(cannot make symlinks, will use .so files) 5919 MANPAGE_SYMLINKS=no 5920fi 5921fi 5922 5923AC_MSG_RESULT($MANPAGE_SYMLINKS) 5924fi 5925 5926])dnl 5927dnl --------------------------------------------------------------------------- 5928dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32 5929dnl -------------- 5930dnl This option causes manpages to be run through tbl(1) to generate tables 5931dnl correctly. 5932AC_DEFUN([CF_MANPAGE_TBL], 5933[ 5934AC_MSG_CHECKING(for manpage tbl) 5935 5936AC_ARG_WITH(manpage-tbl, 5937 [ --with-manpage-tbl specify manpage processing with tbl], 5938 [MANPAGE_TBL=$withval], 5939 [MANPAGE_TBL=no]) 5940 5941AC_MSG_RESULT($MANPAGE_TBL) 5942])dnl 5943dnl --------------------------------------------------------------------------- 5944dnl CF_MB_LEN_MAX version: 1 updated: 2024/03/02 15:45:10 5945dnl ------------- 5946dnl Check if <limits.h> defines a usable MB_LEN_MAX. That may be because it is 5947dnl not defined, or it may be a bogus value. 5948AC_DEFUN([CF_MB_LEN_MAX],[ 5949AC_CACHE_CHECK(if MB_LEN_MAX is usable,cf_cv_mb_len_max,[ 5950AC_TRY_COMPILE([ 5951$ac_includes_default 5952#include <limits.h>], 5953[ 5954#if defined(MB_LEN_MAX) && MB_LEN_MAX >= 6 5955 ${cf_cv_main_return:-return}(0); 5956#else 5957#error MB_LEN_MAX is not usable 5958#endif 5959], [cf_cv_mb_len_max=yes], 5960 [cf_cv_mb_len_max=no])]) 5961if test "$cf_cv_mb_len_max" = yes 5962then 5963 AC_DEFINE(HAVE_CONSISTENT_MB_LEN_MAX,1,[Define to 1 if MB_LEN_MAX is usable]) 5964else 5965 AC_MSG_WARN(MB_LEN_MAX is missing/inconsistent in system headers) 5966fi 5967])dnl 5968dnl --------------------------------------------------------------------------- 5969dnl CF_MAN_PAGES version: 59 updated: 2024/03/30 08:27:40 5970dnl ------------ 5971dnl Try to determine if the man-pages on the system are compressed, and if 5972dnl so, what format is used. Use this information to construct a script that 5973dnl will install man-pages. 5974AC_DEFUN([CF_MAN_PAGES], 5975[ 5976CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:) 5977CF_MANPAGE_FORMAT 5978CF_MANPAGE_RENAMES 5979CF_MANPAGE_SYMLINKS 5980CF_MANPAGE_TBL 5981 5982if test "$prefix" = "NONE" ; then 5983 cf_prefix="$ac_default_prefix" 5984else 5985 cf_prefix="$prefix" 5986fi 5987 5988test ! -d man && mkdir man 5989 5990cf_edit_man=./edit_man.sh 5991cf_man_alias=`pwd`/man_alias.sed 5992 5993cat >$cf_edit_man <<CF_EOF 5994#! $SHELL 5995# this script is generated by the configure-script CF_MAN_PAGES macro. 5996 5997prefix="$cf_prefix" 5998datarootdir="$datarootdir" 5999datadir="$datadir" 6000 6001NCURSES_MAJOR="$NCURSES_MAJOR" 6002NCURSES_MINOR="$NCURSES_MINOR" 6003NCURSES_PATCH="$NCURSES_PATCH" 6004 6005NCURSES_OSPEED="$NCURSES_OSPEED" 6006TERMINFO="$TERMINFO" 6007TERMINFO_DIRS="$TERMINFO_DIRS" 6008 6009INSTALL="$INSTALL" 6010INSTALL_DATA="$INSTALL_DATA" 6011 6012transform="$program_transform_name" 6013 6014TMP=\${TMPDIR:=/tmp}/man\$\$ 6015trap "rm -f \$TMP; exit 1" 1 2 3 15 6016trap "rm -f \$TMP" 0 6017 6018form=\[$]1 6019shift || exit 1 6020 6021verb=\[$]1 6022shift || exit 1 6023 6024mandir=\[$]1 6025shift || exit 1 6026 6027srcdir=\[$]1 6028top_srcdir=\[$]srcdir/.. 6029shift || exit 1 6030 6031if test "\$form" = normal ; then 6032 if test "$cf_manpage_format" = yes ; then 6033 if test "$cf_manpage_inboth" = no ; then 6034 $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@" 6035 exit $? 6036 fi 6037 fi 6038 cf_subdir=\$mandir/man 6039 cf_tables=$MANPAGE_TBL 6040else 6041 cf_subdir=\$mandir/cat 6042 cf_tables=yes 6043fi 6044 6045# process the list of source-files 6046for i in "\[$]@" ; do 6047case \$i in 6048(*.orig|*.rej) ;; 6049(*.[[0-9]]*) 6050 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`; 6051 if test "\$verb" = installing ; then 6052 if test ! -d "\$cf_subdir\${section}" ; then 6053 mkdir -p "\$cf_subdir\$section" 6054 fi 6055 fi 6056 6057 # replace variables in man page 6058 if test ! -f "$cf_man_alias" ; then 6059cat >>$cf_man_alias <<-CF_EOF2 6060 s,@DATADIR@,\$datadir,g 6061 s,@TERMINFO@,\${TERMINFO:="no default value"},g 6062 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g 6063 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g 6064 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g 6065 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g 6066 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g 6067CF_EOF 6068 ifelse($1,,,[ 6069 for cf_name in $1 6070 do 6071 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` 6072 cf_name=`echo "$cf_name" | sed "$program_transform_name"` 6073cat >>$cf_edit_man <<-CF_EOF 6074 s,@$cf_NAME@,$cf_name,g 6075CF_EOF 6076 done 6077 ]) 6078cat >>$cf_edit_man <<CF_EOF 6079CF_EOF2 6080 echo "...made $cf_man_alias" 6081 fi 6082 6083 aliases= 6084 cf_source=\`basename "\$i"\` 6085 cf_full_alias=\$cf_source 6086 test ! -f "\$cf_full_alias" && cf_full_alias="\$srcdir/\$cf_full_alias" 6087 if test ! -f "\$cf_full_alias" ; then 6088 echo ".. skipped \$cf_source" 6089 continue 6090 fi 6091CF_EOF 6092 6093if test "$MANPAGE_ALIASES" != no ; then 6094cat >>$cf_edit_man <<CF_EOF 6095 nCurses=ignore.3x 6096 cf_part_alias=\`echo \$cf_full_alias| sed -e 's,^.*/,,'\` 6097 test "$with_curses_h" = yes && nCurses=ncurses.3x 6098 aliases=\`sed -f "\$top_srcdir/man/manlinks.sed" "\$cf_full_alias" |sed -f "$cf_man_alias" | sort -u; test "\$cf_part_alias" = "\$nCurses" && echo curses\` 6099CF_EOF 6100fi 6101 6102if test "$MANPAGE_RENAMES" = no ; then 6103cat >>$cf_edit_man <<CF_EOF 6104 # perform program transformations for section 1 man pages 6105 if test \$section = 1 ; then 6106 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\` 6107 else 6108 cf_target=\$cf_subdir\${section}/\$cf_source 6109 fi 6110CF_EOF 6111else 6112cat >>$cf_edit_man <<CF_EOF 6113 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\` 6114 if test -z "\$cf_target" ; then 6115 echo "? missing rename for \$cf_source" 6116 cf_target="\$cf_source" 6117 fi 6118 cf_target="\$cf_subdir\${section}/\${cf_target}" 6119 6120CF_EOF 6121fi 6122 6123cat >>$cf_edit_man <<CF_EOF 6124 sed -f "$cf_man_alias" \\ 6125CF_EOF 6126 6127if test "$MANPAGE_RENAMES" != no ; then 6128cat >>$cf_edit_man <<CF_EOF 6129 < "\$i" | sed -f `pwd`/edit_man.sed >\$TMP 6130CF_EOF 6131else 6132cat >>$cf_edit_man <<CF_EOF 6133 < "\$i" >\$TMP 6134CF_EOF 6135fi 6136 6137cat >>$cf_edit_man <<CF_EOF 6138if test \$cf_tables = yes ; then 6139 tbl \$TMP >\$TMP.out 6140 mv \$TMP.out \$TMP 6141fi 6142CF_EOF 6143 6144if test "$with_overwrite" != yes ; then 6145cat >>$cf_edit_man <<CF_EOF 6146 sed -e "/\\#[ ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out 6147 mv \$TMP.out \$TMP 6148CF_EOF 6149fi 6150 6151if test "$with_curses_h" != yes ; then 6152cat >>$cf_edit_man <<CF_EOF 6153 sed -e "/\\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out 6154 mv \$TMP.out \$TMP 6155CF_EOF 6156fi 6157 6158cat >>$cf_edit_man <<CF_EOF 6159 if test "\$form" = format ; then 6160 nroff -man \$TMP >\$TMP.out 6161 mv \$TMP.out \$TMP 6162 fi 6163CF_EOF 6164 6165if test -n "$cf_manpage_compress" ; then 6166cat >>$cf_edit_man <<CF_EOF 6167 if test "\$verb" = installing ; then 6168 if ( "$cf_manpage_compress" -f \$TMP ) 6169 then 6170 mv \$TMP.$cf_manpage_so_strip \$TMP 6171 fi 6172 fi 6173 cf_target="\$cf_target.$cf_manpage_so_strip" 6174CF_EOF 6175fi 6176 6177case "$MANPAGE_FORMAT" in 6178(*BSDI*) 6179cat >>$cf_edit_man <<CF_EOF 6180 if test "\$form" = format ; then 6181 # BSDI installs only .0 suffixes in the cat directories 6182 cf_target="\`echo \$cf_target|sed -e 's/\\.[[1-9]]\\+[[a-z]]*/.0/'\`" 6183 fi 6184CF_EOF 6185 ;; 6186esac 6187 6188cat >>$cf_edit_man <<CF_EOF 6189 suffix=\`basename "\$cf_target" | sed -e 's%^[[^.]]*%%'\` 6190 extra_suffix= 6191 if test -n "$EXTRA_SUFFIX" ; then 6192 case \$cf_target in 6193 (*${EXTRA_SUFFIX}\$suffix) 6194 extra_suffix="$EXTRA_SUFFIX" 6195 ;; 6196 esac 6197 fi 6198 if test "\$verb" = installing ; then 6199 echo "\$verb \$cf_target" 6200 \$INSTALL_DATA \$TMP "\$cf_target" 6201 test -d "\$cf_subdir\${section}" && 6202 test -n "\$aliases" && ( 6203 cd "\$cf_subdir\${section}" && ( 6204 cf_source=\`echo "\$cf_target" |sed -e 's%^.*/\\([[^/]][[^/]]*/[[^/]][[^/]]*$\\)%\\1%'\` 6205 test -n "$cf_manpage_so_strip" && cf_source=\`echo "\$cf_source" |sed -e 's%\\.$cf_manpage_so_strip\$%%'\` 6206 cf_target=\`basename "\$cf_target"\` 6207 for cf_alias in \$aliases 6208 do 6209 if test "\$section" = 1 ; then 6210 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\` 6211 fi 6212 cf_alias="\${cf_alias}\${extra_suffix}" 6213 6214 if test "$MANPAGE_SYMLINKS" = yes ; then 6215 if test -f "\$cf_alias\${suffix}" ; then 6216 if ( cmp -s "\$cf_target" "\$cf_alias\${suffix}" ) 6217 then 6218 continue 6219 fi 6220 fi 6221 echo ".. \$verb alias \$cf_alias\${suffix}" 6222CF_EOF 6223case "x$LN_S" in 6224(*-f) 6225cat >>$cf_edit_man <<CF_EOF 6226 $LN_S "\$cf_target" "\$cf_alias\${suffix}" 6227CF_EOF 6228 ;; 6229(*) 6230cat >>$cf_edit_man <<CF_EOF 6231 rm -f "\$cf_alias\${suffix}" 6232 $LN_S "\$cf_target" "\$cf_alias\${suffix}" 6233CF_EOF 6234 ;; 6235esac 6236cat >>$cf_edit_man <<CF_EOF 6237 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then 6238 echo ".so \$cf_source" >\$TMP 6239CF_EOF 6240if test -n "$cf_manpage_compress" ; then 6241cat >>$cf_edit_man <<CF_EOF 6242 if test -n "$cf_manpage_so_strip" ; then 6243 "$cf_manpage_compress" $cf_manpage_coptions -f \$TMP 6244 mv \$TMP.$cf_manpage_so_strip \$TMP 6245 fi 6246CF_EOF 6247fi 6248cat >>$cf_edit_man <<CF_EOF 6249 echo ".. \$verb alias \$cf_alias\${suffix}" 6250 rm -f "\$cf_alias\${suffix}" 6251 \$INSTALL_DATA \$TMP "\$cf_alias\${suffix}" 6252 fi 6253 done 6254 ) 6255 ) 6256 elif test "\$verb" = removing ; then 6257 test -f "\$cf_target" && ( 6258 echo "\$verb \$cf_target" 6259 rm -f "\$cf_target" 6260 ) 6261 test -d "\$cf_subdir\${section}" && 6262 test -n "\$aliases" && ( 6263 cd "\$cf_subdir\${section}" && ( 6264 for cf_alias in \$aliases 6265 do 6266 if test "\$section" = 1 ; then 6267 cf_alias=\`echo "\$cf_alias" |sed "\${transform}"\` 6268 fi 6269 cf_alias="\${cf_alias}\${extra_suffix}" 6270 6271 echo ".. \$verb alias \$cf_alias\${suffix}" 6272 rm -f "\$cf_alias\${suffix}" 6273 done 6274 ) 6275 ) 6276 else 6277# echo ".hy 0" 6278 cat \$TMP 6279 fi 6280 ;; 6281esac 6282done 6283 6284if test "$cf_manpage_inboth" = yes ; then 6285if test "\$form" != format ; then 6286 $SHELL "\[$]0" format "\$verb" "\$mandir" "\$srcdir" "\[$]@" 6287fi 6288fi 6289 6290exit 0 6291CF_EOF 6292chmod 755 "$cf_edit_man" 6293 6294])dnl 6295dnl --------------------------------------------------------------------------- 6296dnl CF_MAP_LIB_BASENAME version: 2 updated: 2021/01/02 17:09:14 6297dnl ------------------- 6298dnl Convert a default-libname to the actual one used via CF_WITH_LIB_BASENAME. 6299dnl 6300dnl $1 = variable to set 6301dnl $2 = default-libname 6302AC_DEFUN([CF_MAP_LIB_BASENAME],[ 6303CF_UPPER(cf_map_lib_basename,$2) 6304eval $1="\$${cf_map_lib_basename}_NAME" 6305])dnl 6306dnl --------------------------------------------------------------------------- 6307dnl CF_MATH_LIB version: 11 updated: 2022/07/27 19:01:48 6308dnl ----------- 6309dnl Checks for libraries. At least one UNIX system, Apple Macintosh 6310dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler 6311dnl AC_CHECK_LIB(m,sin), because that fails for C++. 6312AC_DEFUN([CF_MATH_LIB], 6313[ 6314AC_CACHE_CHECK(if -lm needed for math functions, 6315 cf_cv_need_libm,[ 6316 AC_TRY_LINK([ 6317 #include <stdio.h> 6318 #include <stdlib.h> 6319 #include <math.h> 6320 ], 6321 [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)], 6322 [cf_cv_need_libm=no], 6323 [cf_cv_need_libm=yes])]) 6324 6325if test "$cf_cv_need_libm" = yes 6326then 6327 6328 cf_save_LIBS="$LIBS" 6329 LIBS="$LIBS -lm" 6330 AC_CACHE_CHECK(if -lm is available for math functions, 6331 cf_cv_have_libm,[ 6332 AC_TRY_LINK([ 6333 #include <stdio.h> 6334 #include <stdlib.h> 6335 #include <math.h> 6336 ], 6337 [double x = rand(); printf("result = %g\\n", ]ifelse([$2],,sin(x),$2)[)], 6338 [cf_cv_have_libm=yes], 6339 [cf_cv_have_libm=no])]) 6340 LIBS="$cf_save_LIBS" 6341 6342 if test "$cf_cv_have_libm" = yes 6343 then 6344 ifelse($1,,[CF_ADD_LIB(m)],[$1=-lm]) 6345 fi 6346else 6347 cf_cv_have_libm=yes 6348fi 6349 6350if test "$cf_cv_have_libm" = yes 6351then 6352 AC_DEFINE(HAVE_MATH_FUNCS,1,[Define to 1 if math functions are available]) 6353fi 6354]) 6355dnl --------------------------------------------------------------------------- 6356dnl CF_MIXEDCASE_FILENAMES version: 9 updated: 2021/01/01 16:53:59 6357dnl ---------------------- 6358dnl Check if the file-system supports mixed-case filenames. If we're able to 6359dnl create a lowercase name and see it as uppercase, it doesn't support that. 6360AC_DEFUN([CF_MIXEDCASE_FILENAMES], 6361[ 6362AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[ 6363if test "$cross_compiling" = yes ; then 6364 case "$target_alias" in 6365 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*|darwin*) 6366 cf_cv_mixedcase=no 6367 ;; 6368 (*) 6369 cf_cv_mixedcase=yes 6370 ;; 6371 esac 6372else 6373 rm -f conftest CONFTEST 6374 echo test >conftest 6375 if test -f CONFTEST ; then 6376 cf_cv_mixedcase=no 6377 else 6378 cf_cv_mixedcase=yes 6379 fi 6380 rm -f conftest CONFTEST 6381fi 6382]) 6383test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.]) 6384])dnl 6385dnl --------------------------------------------------------------------------- 6386dnl CF_MKSTEMP version: 13 updated: 2023/12/01 17:22:50 6387dnl ---------- 6388dnl Check for a working mkstemp. This creates two files, checks that they are 6389dnl successfully created and distinct (AmigaOS apparently fails on the last). 6390AC_DEFUN([CF_MKSTEMP],[ 6391AC_CHECK_HEADERS( \ 6392unistd.h \ 6393) 6394AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[ 6395rm -rf ./conftest* 6396AC_TRY_RUN([ 6397$ac_includes_default 6398 6399int main(void) 6400{ 6401 static char tmpl[] = "conftestXXXXXX"; 6402 char name[2][80]; 6403 int n; 6404 int result = 0; 6405 int fd; 6406 struct stat sb; 6407 6408 umask(077); 6409 for (n = 0; n < 2; ++n) { 6410 strcpy(name[n], tmpl); 6411 if ((fd = mkstemp(name[n])) >= 0) { 6412 if (!strcmp(name[n], tmpl) 6413 || stat(name[n], &sb) != 0 6414 || (sb.st_mode & S_IFMT) != S_IFREG 6415 || (sb.st_mode & 077) != 0) { 6416 result = 1; 6417 } 6418 close(fd); 6419 } 6420 } 6421 if (result == 0 6422 && !strcmp(name[0], name[1])) 6423 result = 1; 6424 ${cf_cv_main_return:-return}(result); 6425} 6426],[cf_cv_func_mkstemp=yes 6427],[cf_cv_func_mkstemp=no 6428],[cf_cv_func_mkstemp=maybe]) 6429]) 6430if test "x$cf_cv_func_mkstemp" = xmaybe ; then 6431 AC_CHECK_FUNC(mkstemp) 6432fi 6433if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then 6434 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.]) 6435fi 6436])dnl 6437dnl --------------------------------------------------------------------------- 6438dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32 6439dnl ---------- 6440dnl Write a debug message to config.log, along with the line number in the 6441dnl configure script. 6442AC_DEFUN([CF_MSG_LOG],[ 6443echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC 6444])dnl 6445dnl --------------------------------------------------------------------------- 6446dnl CF_NCURSES_ABI_6 version: 5 updated: 2023/01/07 16:32:06 6447dnl ---------------- 6448dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and 6449dnl warn about this. 6450AC_DEFUN([CF_NCURSES_ABI_6],[ 6451if test "${with_abi_version+set}" != set; then 6452 case "$cf_cv_rel_version" in 6453 (5.*) 6454 cf_cv_rel_version=6.0 6455 cf_cv_abi_version=6 6456 cf_cv_abi_default=6 6457 AC_MSG_WARN(overriding ABI version to $cf_cv_abi_default) 6458 ;; 6459 esac 6460fi 6461])dnl 6462dnl --------------------------------------------------------------------------- 6463dnl CF_NCURSES_WITH_ABI_VERSION version: 3 updated: 2021/01/01 13:31:04 6464dnl --------------------------- 6465dnl Allow ncurses's ABI to be overridden. Generally this happens when a 6466dnl packager has incremented the ABI past that used in the original package, 6467dnl and wishes to keep doing this. 6468dnl 6469dnl $1 is the package name, if any, to derive a corresponding {package}_ABI 6470dnl symbol. 6471AC_DEFUN([CF_NCURSES_WITH_ABI_VERSION],[ 6472CF_WITH_ABI_VERSION($1) 6473if test "x$cf_cv_abi_version" != "x$with_abi_version" 6474then 6475 case "$cf_cv_rel_version" in 6476 (5.*) 6477 cf_cv_rel_version=$with_abi_version.0 6478 ;; 6479 esac 6480fi 6481])dnl 6482dnl --------------------------------------------------------------------------- 6483dnl CF_NO_LEAKS_OPTION version: 9 updated: 2021/06/13 19:45:41 6484dnl ------------------ 6485dnl see CF_WITH_NO_LEAKS 6486dnl 6487dnl $1 = option/name 6488dnl $2 = help-text 6489dnl $3 = symbol to define if the option is set 6490dnl $4 = additional actions to take if the option is set 6491AC_DEFUN([CF_NO_LEAKS_OPTION],[ 6492AC_MSG_CHECKING(if you want to use $1 for testing) 6493AC_ARG_WITH($1, 6494 [$2], 6495 [case "x$withval" in 6496 (x|xno) ;; 6497 (*) 6498 : "${with_cflags:=-g}" 6499 : "${enable_leaks:=no}" 6500 with_$1=yes 6501 AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[ 6502 $4 6503]) 6504 ;; 6505 esac], 6506 [with_$1=]) 6507AC_MSG_RESULT(${with_$1:-no}) 6508 6509case ".$with_cflags" in 6510(.*-g*) 6511 case .$CFLAGS in 6512 (.*-g*) 6513 ;; 6514 (*) 6515 CF_ADD_CFLAGS([-g]) 6516 ;; 6517 esac 6518 ;; 6519esac 6520])dnl 6521dnl --------------------------------------------------------------------------- 6522dnl CF_NUMBER_SYNTAX version: 3 updated: 2023/05/06 16:14:29 6523dnl ---------------- 6524dnl Check if the given variable is a positive integer. Report an error if not. 6525dnl $1 is the variable 6526dnl $2 is the message 6527AC_DEFUN([CF_NUMBER_SYNTAX],[ 6528if test -n "$1" ; then 6529 case `echo "$1" | sed -e 's/^[[0-9]]*$/0/g'` in 6530 (0) 6531 ;; 6532 (*) 6533 AC_MSG_ERROR($2 is not a number: $1) 6534 ;; 6535 esac 6536else 6537 AC_MSG_ERROR($2 value is empty) 6538fi 6539])dnl 6540dnl --------------------------------------------------------------------------- 6541dnl CF_OBJ_SUBDIR version: 8 updated: 2021/01/01 13:31:04 6542dnl ------------- 6543dnl Compute the object-directory name from the given model name 6544AC_DEFUN([CF_OBJ_SUBDIR], 6545[ 6546 case $1 in 6547 (libtool) $2='obj_lo' ;; 6548 (normal) $2='objects' ;; 6549 (debug) $2='obj_g' ;; 6550 (profile) $2='obj_p' ;; 6551 (shared) 6552 case "$cf_cv_system_name" in 6553 (cygwin|msys) 6554 $2='objects' ;; 6555 (*) 6556 $2='obj_s' ;; 6557 esac 6558 esac 6559])dnl 6560dnl --------------------------------------------------------------------------- 6561dnl CF_OUTPUT_MANPAGE_RENAMES version: 2 updated: 2022/10/22 19:12:31 6562dnl ------------------------- 6563dnl This runs in the output step to config.status, after man_db.renames has 6564dnl been generated. 6565AC_DEFUN([CF_OUTPUT_MANPAGE_RENAMES], 6566[ 6567AC_REQUIRE([CF_MANPAGE_RENAMES]) 6568if test "$MANPAGE_RENAMES" != no ; then 6569 # Construct a sed-script to perform renaming within man-pages 6570 test -n "$verbose" && echo "creating edit_man.sed" 6571 test ! -d man && mkdir man 6572 FGREP="${FGREP-grep -F}" $SHELL "$srcdir/man/make_sed.sh" "$MANPAGE_RENAMES" >./edit_man.sed 6573fi 6574])dnl 6575dnl --------------------------------------------------------------------------- 6576dnl CF_PATHSEP version: 8 updated: 2021/01/01 13:31:04 6577dnl ---------- 6578dnl Provide a value for the $PATH and similar separator (or amend the value 6579dnl as provided in autoconf 2.5x). 6580AC_DEFUN([CF_PATHSEP], 6581[ 6582 AC_MSG_CHECKING(for PATH separator) 6583 case "$cf_cv_system_name" in 6584 (os2*) PATH_SEPARATOR=';' ;; 6585 (*) ${PATH_SEPARATOR:=':'} ;; 6586 esac 6587ifelse([$1],,,[$1=$PATH_SEPARATOR]) 6588 AC_SUBST(PATH_SEPARATOR) 6589 AC_MSG_RESULT($PATH_SEPARATOR) 6590])dnl 6591dnl --------------------------------------------------------------------------- 6592dnl CF_PATH_PROG version: 12 updated: 2021/01/02 09:31:20 6593dnl ------------ 6594dnl Check for a given program, defining corresponding symbol. 6595dnl $1 = environment variable, which is suffixed by "_PATH" in the #define. 6596dnl $2 = program name to find. 6597dnl $3 = optional list of additional program names to test. 6598dnl $4 = $PATH 6599dnl 6600dnl If there is more than one token in the result, #define the remaining tokens 6601dnl to $1_ARGS. We need this for 'install' in particular. 6602dnl 6603dnl FIXME: we should allow this to be overridden by environment variables 6604dnl 6605AC_DEFUN([CF_PATH_PROG],[ 6606AC_REQUIRE([CF_PATHSEP]) 6607test -z "[$]$1" && $1="$2" 6608AC_PATH_PROGS($1,[$]$1 $2 ifelse($3,,,$3),[$]$1, ifelse($4,,,$4)) 6609 6610cf_path_prog="" 6611cf_path_args="" 6612IFS="${IFS:- }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR" 6613for cf_temp in $ac_cv_path_$1 6614do 6615 if test -z "$cf_path_prog" ; then 6616 if test "$with_full_paths" = yes ; then 6617 CF_PATH_SYNTAX(cf_temp,break) 6618 cf_path_prog="$cf_temp" 6619 else 6620 cf_path_prog="`basename "$cf_temp"`" 6621 fi 6622 elif test -z "$cf_path_args" ; then 6623 cf_path_args="$cf_temp" 6624 else 6625 cf_path_args="$cf_path_args $cf_temp" 6626 fi 6627done 6628IFS="$cf_save_ifs" 6629 6630if test -n "$cf_path_prog" ; then 6631 CF_MSG_LOG(defining path for ${cf_path_prog}) 6632 AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog",Define to pathname $1) 6633 test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args",Define to provide args for $1) 6634fi 6635])dnl 6636dnl --------------------------------------------------------------------------- 6637dnl CF_PATH_SYNTAX version: 18 updated: 2020/12/31 18:40:20 6638dnl -------------- 6639dnl Check the argument to see that it looks like a pathname. Rewrite it if it 6640dnl begins with one of the prefix/exec_prefix variables, and then again if the 6641dnl result begins with 'NONE'. This is necessary to work around autoconf's 6642dnl delayed evaluation of those symbols. 6643AC_DEFUN([CF_PATH_SYNTAX],[ 6644if test "x$prefix" != xNONE; then 6645 cf_path_syntax="$prefix" 6646else 6647 cf_path_syntax="$ac_default_prefix" 6648fi 6649 6650case ".[$]$1" in 6651(.\[$]\(*\)*|.\'*\'*) 6652 ;; 6653(..|./*|.\\*) 6654 ;; 6655(.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX 6656 ;; 6657(.\[$]\{*prefix\}*|.\[$]\{*dir\}*) 6658 eval $1="[$]$1" 6659 case ".[$]$1" in 6660 (.NONE/*) 6661 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%` 6662 ;; 6663 esac 6664 ;; 6665(.no|.NONE/*) 6666 $1=`echo "[$]$1" | sed -e s%NONE%$cf_path_syntax%` 6667 ;; 6668(*) 6669 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2) 6670 ;; 6671esac 6672])dnl 6673dnl --------------------------------------------------------------------------- 6674dnl CF_PKG_CONFIG version: 13 updated: 2023/10/28 11:59:01 6675dnl ------------- 6676dnl Check for the package-config program, unless disabled by command-line. 6677dnl 6678dnl Sets $PKG_CONFIG to the pathname of the pkg-config program. 6679AC_DEFUN([CF_PKG_CONFIG], 6680[ 6681AC_MSG_CHECKING(if you want to use pkg-config) 6682AC_ARG_WITH(pkg-config, 6683 [[ --with-pkg-config[=CMD] enable/disable use of pkg-config and its name CMD]], 6684 [cf_pkg_config=$withval], 6685 [cf_pkg_config=yes]) 6686AC_MSG_RESULT($cf_pkg_config) 6687 6688case "$cf_pkg_config" in 6689(no) 6690 PKG_CONFIG=none 6691 ;; 6692(yes) 6693 CF_ACVERSION_CHECK(2.52, 6694 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)], 6695 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)]) 6696 ;; 6697(*) 6698 PKG_CONFIG=$withval 6699 ;; 6700esac 6701 6702test -z "$PKG_CONFIG" && PKG_CONFIG=none 6703if test "$PKG_CONFIG" != none ; then 6704 CF_PATH_SYNTAX(PKG_CONFIG) 6705elif test "x$cf_pkg_config" != xno ; then 6706 AC_MSG_WARN(pkg-config is not installed) 6707fi 6708 6709AC_SUBST(PKG_CONFIG) 6710])dnl 6711dnl --------------------------------------------------------------------------- 6712dnl CF_POSIX_C_SOURCE version: 12 updated: 2023/02/18 17:41:25 6713dnl ----------------- 6714dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed. 6715dnl 6716dnl POSIX.1-1990 _POSIX_SOURCE 6717dnl POSIX.1-1990 and _POSIX_SOURCE and 6718dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2 6719dnl Bindings Option 6720dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L 6721dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L 6722dnl X/Open 2000 _POSIX_C_SOURCE=200112L 6723dnl 6724dnl Parameters: 6725dnl $1 is the nominal value for _POSIX_C_SOURCE 6726AC_DEFUN([CF_POSIX_C_SOURCE], 6727[AC_REQUIRE([CF_POSIX_VISIBLE])dnl 6728 6729if test "$cf_cv_posix_visible" = no; then 6730 6731cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1]) 6732 6733cf_save_CFLAGS="$CFLAGS" 6734cf_save_CPPFLAGS="$CPPFLAGS" 6735 6736CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE) 6737CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE) 6738 6739AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[ 6740 CF_MSG_LOG(if the symbol is already defined go no further) 6741 AC_TRY_COMPILE([#include <sys/types.h>],[ 6742#ifndef _POSIX_C_SOURCE 6743#error _POSIX_C_SOURCE is not defined 6744#endif], 6745 [cf_cv_posix_c_source=no], 6746 [cf_want_posix_source=no 6747 case .$cf_POSIX_C_SOURCE in 6748 (.[[12]]??*) 6749 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" 6750 ;; 6751 (.2) 6752 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" 6753 cf_want_posix_source=yes 6754 ;; 6755 (.*) 6756 cf_want_posix_source=yes 6757 ;; 6758 esac 6759 if test "$cf_want_posix_source" = yes ; then 6760 AC_TRY_COMPILE([#include <sys/types.h>],[ 6761#ifdef _POSIX_SOURCE 6762#error _POSIX_SOURCE is defined 6763#endif],[], 6764 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE") 6765 fi 6766 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE) 6767 CFLAGS="$cf_trim_CFLAGS" 6768 CPPFLAGS="$cf_trim_CPPFLAGS" 6769 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source) 6770 CF_MSG_LOG(if the second compile does not leave our definition intact error) 6771 AC_TRY_COMPILE([#include <sys/types.h>],[ 6772#ifndef _POSIX_C_SOURCE 6773#error _POSIX_C_SOURCE is not defined 6774#endif],, 6775 [cf_cv_posix_c_source=no]) 6776 CFLAGS="$cf_save_CFLAGS" 6777 CPPFLAGS="$cf_save_CPPFLAGS" 6778 ]) 6779]) 6780 6781if test "$cf_cv_posix_c_source" != no ; then 6782 CFLAGS="$cf_trim_CFLAGS" 6783 CPPFLAGS="$cf_trim_CPPFLAGS" 6784 CF_ADD_CFLAGS($cf_cv_posix_c_source) 6785fi 6786 6787fi # cf_cv_posix_visible 6788 6789])dnl 6790dnl --------------------------------------------------------------------------- 6791dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17 6792dnl ---------------- 6793dnl POSIX documents test-macros which an application may set before any system 6794dnl headers are included to make features available. 6795dnl 6796dnl Some BSD platforms (originally FreeBSD, but copied by a few others) 6797dnl diverged from POSIX in 2002 by setting symbols which make all of the most 6798dnl recent features visible in the system header files unless the application 6799dnl overrides the corresponding test-macros. Doing that introduces portability 6800dnl problems. 6801dnl 6802dnl This macro makes a special check for the symbols used for this, to avoid a 6803dnl conflicting definition. 6804AC_DEFUN([CF_POSIX_VISIBLE], 6805[ 6806AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[ 6807AC_TRY_COMPILE([#include <stdio.h>],[ 6808#if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \ 6809 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \ 6810 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \ 6811 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0) 6812#error conflicting symbols found 6813#endif 6814],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes]) 6815]) 6816])dnl 6817dnl --------------------------------------------------------------------------- 6818dnl CF_PREDEFINE version: 3 updated: 2023/02/18 17:41:25 6819dnl ------------ 6820dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles. 6821dnl 6822dnl $1 = symbol to test 6823dnl $2 = value (if any) to use for a predefinition 6824AC_DEFUN([CF_PREDEFINE], 6825[ 6826AC_MSG_CHECKING(if we must define $1) 6827AC_TRY_COMPILE([#include <sys/types.h> 6828],[ 6829#ifndef $1 6830#error $1 is not defined 6831#endif],[cf_result=no],[cf_result=yes]) 6832AC_MSG_RESULT($cf_result) 6833 6834if test "$cf_result" = yes ; then 6835 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])" 6836elif test "x$2" != "x" ; then 6837 AC_MSG_CHECKING(checking for compatible value versus $2) 6838 AC_TRY_COMPILE([#include <sys/types.h> 6839],[ 6840#if $1-$2 < 0 6841#error $1-$2 is negative 6842#endif],[cf_result=yes],[cf_result=no]) 6843 AC_MSG_RESULT($cf_result) 6844 if test "$cf_result" = no ; then 6845 # perhaps we can override it - try... 6846 CPPFLAGS="$CPPFLAGS -D$1=$2" 6847 fi 6848fi 6849])dnl 6850dnl --------------------------------------------------------------------------- 6851dnl CF_PRG_RULES version: 2 updated: 2021/01/01 13:31:04 6852dnl ------------ 6853dnl Append definitions and rules for the given programs to the subdirectory 6854dnl Makefiles, and the recursion rule for the top-level Makefile. 6855dnl 6856dnl parameters 6857dnl $1 = script to run 6858dnl $2 = list of subdirectories 6859dnl 6860dnl variables 6861dnl $AWK 6862AC_DEFUN([CF_PRG_RULES], 6863[ 6864for cf_dir in $2 6865do 6866 if test ! -d "$srcdir/$cf_dir" ; then 6867 continue 6868 elif test -f "$srcdir/$cf_dir/programs" ; then 6869 $AWK -f $1 "$srcdir/$cf_dir/programs" >>$cf_dir/Makefile 6870 fi 6871done 6872 6873])dnl 6874dnl --------------------------------------------------------------------------- 6875dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22 6876dnl ---------- 6877dnl Check for archiver "ar". 6878AC_DEFUN([CF_PROG_AR],[ 6879AC_CHECK_TOOL(AR, ar, ar) 6880]) 6881dnl --------------------------------------------------------------------------- 6882dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59 6883dnl ----------- 6884dnl Check for awk, ensure that the check found something. 6885AC_DEFUN([CF_PROG_AWK], 6886[ 6887AC_PROG_AWK 6888test -z "$AWK" && AC_MSG_ERROR(No awk program found) 6889])dnl 6890dnl --------------------------------------------------------------------------- 6891dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54 6892dnl ---------- 6893dnl standard check for CC, plus followup sanity checks 6894dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name 6895AC_DEFUN([CF_PROG_CC],[ 6896CF_ACVERSION_CHECK(2.53, 6897 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice) 6898 AC_REQUIRE([AC_PROG_CC])], 6899 []) 6900ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)]) 6901CF_GCC_VERSION 6902CF_ACVERSION_CHECK(2.52, 6903 [AC_PROG_CC_STDC], 6904 [CF_ANSI_CC_REQD]) 6905CF_CC_ENV_FLAGS 6906])dnl 6907dnl --------------------------------------------------------------------------- 6908dnl CF_PROG_CC_C_O version: 6 updated: 2021/01/01 13:31:04 6909dnl -------------- 6910dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that 6911dnl the output file can be renamed, and allows for a shell variable that can 6912dnl be used later. The parameter is either CC or CXX. The result is the 6913dnl cache variable: 6914dnl $cf_cv_prog_CC_c_o 6915dnl $cf_cv_prog_CXX_c_o 6916dnl 6917dnl $1 = compiler 6918dnl $2 = compiler options, if any 6919AC_DEFUN([CF_PROG_CC_C_O], 6920[AC_REQUIRE([AC_PROG_CC])dnl 6921AC_MSG_CHECKING([whether [$]$1 understands -c and -o together]) 6922AC_CACHE_VAL(cf_cv_prog_$1_c_o, 6923[ 6924cat > conftest.$ac_ext <<CF_EOF 6925int main(void) 6926{ 6927 ${cf_cv_main_return:-return}(0); 6928} 6929CF_EOF 6930# We do the test twice because some compilers refuse to overwrite an 6931# existing .o file with -o, though they will create one. 6932ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC' 6933if AC_TRY_EVAL(ac_try) && 6934 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try); 6935then 6936 eval cf_cv_prog_$1_c_o=yes 6937else 6938 eval cf_cv_prog_$1_c_o=no 6939fi 6940rm -rf ./conftest* 6941])dnl 6942if test "$cf_cv_prog_$1_c_o" = yes; then 6943 AC_MSG_RESULT([yes]) 6944else 6945 AC_MSG_RESULT([no]) 6946fi 6947])dnl 6948dnl --------------------------------------------------------------------------- 6949dnl CF_PROG_GNAT version: 12 updated: 2021/01/02 17:09:14 6950dnl ------------ 6951dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete. 6952AC_DEFUN([CF_PROG_GNAT],[ 6953for cf_prog_gnat in gnat gnatmake gprconfig gprbuild 6954do 6955 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat}) 6956 6957 unset ac_cv_path_cf_TEMP_gnat 6958 unset cf_TEMP_gnat 6959 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no) 6960 eval "cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat" 6961 6962 if test "x$cf_TEMP_gnat" != xno; then 6963 unset cf_cv_gnat_version 6964 unset cf_TEMP_gnat 6965 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat) 6966 fi 6967 eval "cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat" 6968 6969 unset cf_TEMP_gnat 6970 unset cf_cv_gnat_version 6971 unset ac_cv_path_cf_TEMP_gnat 6972done 6973 6974if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then 6975 cf_ada_make= 6976 cf_cv_prog_gnat_correct=no 6977else 6978 cf_ada_make=gnatmake 6979 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then 6980 # gprconfig is newer than gnatmake; we can continue... 6981 cf_ada_config="##" 6982 else 6983 rm -rf ./conftest* ./*~conftest* 6984 if mkdir conftest.src 6985 then 6986 cf_ada_config="" 6987 cd conftest.src 6988 for cf_gprconfig in Ada C 6989 do 6990 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig) 6991 if test "$cf_gprconfig" = C 6992 then 6993 for cf_gprconfig_param in \ 6994 "$cf_gprconfig,,,,GNATGCC" \ 6995 "$cf_gprconfig,,,,GCC" \ 6996 "$cf_gprconfig" 6997 do 6998 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1` 6999 test -n "$cf_gprconfig_value" && break 7000 done 7001 else 7002 cf_gprconfig_param=$cf_gprconfig 7003 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1` 7004 fi 7005 if test -n "$cf_gprconfig_value" 7006 then 7007 eval "cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value" 7008 AC_MSG_RESULT($cf_gprconfig_value) 7009 else 7010 AC_MSG_RESULT(missing) 7011 cf_ada_config="#" 7012 break 7013 fi 7014 done 7015 cd .. 7016 rm -rf ./conftest* ./*~conftest* 7017 fi 7018 fi 7019 if test "x$cf_ada_config" != "x#" 7020 then 7021 CF_GNAT_VERSION 7022 CF_CHECK_GNAT_VERSION 7023 AC_CHECK_PROG(M4_exists, m4, yes, no) 7024 if test "$ac_cv_prog_M4_exists" = no; then 7025 cf_cv_prog_gnat_correct=no 7026 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled) 7027 fi 7028 if test "$cf_cv_prog_gnat_correct" = yes; then 7029 AC_MSG_CHECKING(if GNAT works) 7030 CF_GNAT_TRY_RUN([procedure conftest;], 7031[with Text_IO; 7032with GNAT.OS_Lib; 7033procedure conftest is 7034begin 7035 Text_IO.Put ("Hello World"); 7036 Text_IO.New_Line; 7037 GNAT.OS_Lib.OS_Exit (0); 7038end conftest;], 7039[cf_cv_prog_gnat_correct=yes], 7040[cf_cv_prog_gnat_correct=no]) 7041 AC_MSG_RESULT($cf_cv_prog_gnat_correct) 7042 fi 7043 else 7044 cf_cv_prog_gnat_correct=no 7045 fi 7046fi 7047 7048AC_SUBST(cf_ada_make) 7049AC_SUBST(cf_ada_config) 7050AC_SUBST(cf_ada_config_Ada) 7051AC_SUBST(cf_ada_config_C) 7052])dnl 7053dnl --------------------------------------------------------------------------- 7054dnl CF_PROG_INSTALL version: 10 updated: 2021/01/04 19:33:05 7055dnl --------------- 7056dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the 7057dnl misc/tabset install won't work properly. Usually this happens only when 7058dnl using the fallback mkinstalldirs script 7059AC_DEFUN([CF_PROG_INSTALL], 7060[AC_PROG_INSTALL 7061case $INSTALL in 7062(/*) 7063 ;; 7064(*) 7065 CF_DIRNAME(cf_dir,$INSTALL) 7066 test -z "$cf_dir" && cf_dir=. 7067 INSTALL="`cd \"$cf_dir\" && pwd`"/"`echo "$INSTALL" | sed -e 's%^.*/%%'`" 7068 ;; 7069esac 7070])dnl 7071dnl --------------------------------------------------------------------------- 7072dnl CF_PROG_LDCONFIG version: 5 updated: 2015/04/18 08:56:57 7073dnl ---------------- 7074dnl Check for ldconfig, needed to fixup shared libraries that would be built 7075dnl and then used in the install. 7076AC_DEFUN([CF_PROG_LDCONFIG],[ 7077if test "$cross_compiling" = yes ; then 7078 LDCONFIG=: 7079else 7080 case "$cf_cv_system_name" in 7081 (dragonfly*|mirbsd*|freebsd*) 7082 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R" 7083 ;; 7084 (*) LDPATH=$PATH:/sbin:/usr/sbin 7085 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH) 7086 ;; 7087 esac 7088fi 7089AC_SUBST(LDCONFIG) 7090])dnl 7091dnl --------------------------------------------------------------------------- 7092dnl CF_PROG_LINT version: 5 updated: 2022/08/20 15:44:13 7093dnl ------------ 7094AC_DEFUN([CF_PROG_LINT], 7095[ 7096AC_CHECK_PROGS(LINT, lint cppcheck splint) 7097case "x$LINT" in 7098(xcppcheck|x*/cppcheck) 7099 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all" 7100 ;; 7101esac 7102AC_SUBST(LINT_OPTS) 7103AC_SUBST(LINT_LIBS) 7104])dnl 7105dnl --------------------------------------------------------------------------- 7106dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37 7107dnl ------------ 7108dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f" 7109dnl option if it is supported. 7110AC_DEFUN([CF_PROG_LN_S],[ 7111AC_PROG_LN_S 7112AC_MSG_CHECKING(if $LN_S -f options work) 7113 7114rm -f conf$$.src conf$$dst 7115echo >conf$$.dst 7116echo first >conf$$.src 7117if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then 7118 cf_prog_ln_sf=yes 7119else 7120 cf_prog_ln_sf=no 7121fi 7122rm -f conf$$.dst conf$$src 7123AC_MSG_RESULT($cf_prog_ln_sf) 7124 7125test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f" 7126])dnl 7127dnl --------------------------------------------------------------------------- 7128dnl CF_REGEX version: 18 updated: 2021/01/01 16:53:59 7129dnl -------- 7130dnl Attempt to determine if we've got one of the flavors of regular-expression 7131dnl code that we can support. 7132AC_DEFUN([CF_REGEX], 7133[ 7134 7135cf_regex_func=no 7136cf_regex_libs= 7137case "$host_os" in 7138(mingw*) 7139 # -lsystre -ltre -lintl -liconv 7140 AC_CHECK_LIB(systre,regcomp,[ 7141 AC_CHECK_LIB(iconv,libiconv_open,[CF_ADD_LIB(iconv)]) 7142 AC_CHECK_LIB(intl,libintl_gettext,[CF_ADD_LIB(intl)]) 7143 AC_CHECK_LIB(tre,tre_regcomp,[CF_ADD_LIB(tre)]) 7144 CF_ADD_LIB(systre) 7145 cf_regex_func=regcomp 7146 ],[ 7147 AC_CHECK_LIB(gnurx,regcomp,[ 7148 CF_ADD_LIB(gnurx) 7149 cf_regex_func=regcomp]) 7150 ]) 7151 ;; 7152(*) 7153 cf_regex_libs="regex re" 7154 AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[ 7155 for cf_regex_lib in $cf_regex_libs 7156 do 7157 AC_CHECK_LIB($cf_regex_lib,regcomp,[ 7158 CF_ADD_LIB($cf_regex_lib) 7159 cf_regex_func=regcomp 7160 break]) 7161 done 7162 ]) 7163 ;; 7164esac 7165 7166if test "$cf_regex_func" = no ; then 7167 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[ 7168 AC_CHECK_LIB(gen,compile,[ 7169 CF_ADD_LIB(gen) 7170 cf_regex_func=compile])]) 7171fi 7172 7173if test "$cf_regex_func" = no ; then 7174 AC_MSG_WARN(cannot find regular expression library) 7175fi 7176 7177AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[ 7178 7179cf_cv_regex_hdrs=no 7180case "$cf_regex_func" in 7181(compile) 7182 for cf_regex_hdr in regexp.h regexpr.h 7183 do 7184 AC_TRY_LINK([#include <$cf_regex_hdr>],[ 7185 char *p = compile("", "", "", 0); 7186 int x = step("", ""); 7187 (void)p; 7188 (void)x; 7189 ],[ 7190 cf_cv_regex_hdrs=$cf_regex_hdr 7191 break 7192 ]) 7193 done 7194 ;; 7195(*) 7196 for cf_regex_hdr in regex.h 7197 do 7198 AC_TRY_LINK([#include <sys/types.h> 7199#include <$cf_regex_hdr>],[ 7200 regex_t *p = 0; 7201 int x = regcomp(p, "", 0); 7202 int y = regexec(p, "", 0, 0, 0); 7203 (void)x; 7204 (void)y; 7205 regfree(p); 7206 ],[ 7207 cf_cv_regex_hdrs=$cf_regex_hdr 7208 break 7209 ]) 7210 done 7211 ;; 7212esac 7213 7214]) 7215 7216case "$cf_cv_regex_hdrs" in 7217 (no) AC_MSG_WARN(no regular expression header found) ;; 7218 (regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;; 7219 (regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;; 7220 (regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;; 7221esac 7222])dnl 7223dnl --------------------------------------------------------------------------- 7224dnl CF_REMOVE_CFLAGS version: 3 updated: 2021/09/05 17:25:40 7225dnl ---------------- 7226dnl Remove a given option from CFLAGS/CPPFLAGS 7227dnl $1 = option to remove 7228dnl $2 = variable to update 7229dnl $3 = nonempty to allow verbose message 7230define([CF_REMOVE_CFLAGS], 7231[ 7232cf_tmp_cflag=`echo "x$1" | sed -e 's/^.//' -e 's/=.*//'` 7233while true 7234do 7235 cf_old_cflag=`echo "x[$]$2" | sed -e 's/^.//' -e 's/[[ ]][[ ]]*-/ -/g' -e "s%$cf_tmp_cflag\\(=[[^ ]][[^ ]]*\\)\?%%" -e 's/^[[ ]]*//' -e 's%[[ ]][[ ]]*-D% -D%g' -e 's%[[ ]][[ ]]*-I% -I%g'` 7236 test "[$]$2" != "$cf_old_cflag" || break 7237 ifelse([$3],,,[CF_VERBOSE(removing old option $1 from $2)]) 7238 $2="$cf_old_cflag" 7239done 7240])dnl 7241dnl --------------------------------------------------------------------------- 7242dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50 7243dnl ---------------- 7244dnl Remove all -U and -D options that refer to the given symbol from a list 7245dnl of C compiler options. This works around the problem that not all 7246dnl compilers process -U and -D options from left-to-right, so a -U option 7247dnl cannot be used to cancel the effect of a preceding -D option. 7248dnl 7249dnl $1 = target (which could be the same as the source variable) 7250dnl $2 = source (including '$') 7251dnl $3 = symbol to remove 7252define([CF_REMOVE_DEFINE], 7253[ 7254$1=`echo "$2" | \ 7255 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \ 7256 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'` 7257])dnl 7258dnl --------------------------------------------------------------------------- 7259dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52 7260dnl ------------- 7261dnl Remove the given library from the symbol 7262dnl 7263dnl $1 = target (which could be the same as the source variable) 7264dnl $2 = source (including '$') 7265dnl $3 = library to remove 7266define([CF_REMOVE_LIB], 7267[ 7268# remove $3 library from $2 7269$1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'` 7270])dnl 7271dnl --------------------------------------------------------------------------- 7272dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45 7273dnl --------------------- 7274dnl Restore flags saved in CF_SAVE_XTRA_FLAGS 7275dnl $1 = name of current macro 7276define([CF_RESTORE_XTRA_FLAGS], 7277[ 7278LIBS="$cf_save_LIBS_$1" 7279CFLAGS="$cf_save_CFLAGS_$1" 7280CPPFLAGS="$cf_save_CPPFLAGS_$1" 7281])dnl 7282dnl --------------------------------------------------------------------------- 7283dnl CF_RPATH_HACK version: 13 updated: 2021/01/03 18:30:50 7284dnl ------------- 7285AC_DEFUN([CF_RPATH_HACK], 7286[AC_REQUIRE([AC_PROG_FGREP])dnl 7287AC_REQUIRE([CF_LD_RPATH_OPT])dnl 7288 7289AC_MSG_CHECKING(for updated LDFLAGS) 7290if test -n "$LD_RPATH_OPT" ; then 7291 AC_MSG_RESULT(maybe) 7292 7293 AC_CHECK_PROGS(cf_ldd_prog,ldd,no) 7294 cf_rpath_list="/usr/lib /lib" 7295 if test "$cf_ldd_prog" != no 7296 then 7297 cf_rpath_oops= 7298 7299AC_TRY_LINK([#include <stdio.h>], 7300 [printf("Hello");], 7301 [cf_rpath_oops=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} ' not found' | sed -e 's% =>.*$%%' |sort | uniq` 7302 cf_rpath_list=`"$cf_ldd_prog" "conftest$ac_exeext" | ${FGREP-fgrep} / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`]) 7303 7304 # If we passed the link-test, but get a "not found" on a given library, 7305 # this could be due to inept reconfiguration of gcc to make it only 7306 # partly honor /usr/local/lib (or whatever). Sometimes this behavior 7307 # is intentional, e.g., installing gcc in /usr/bin and suppressing the 7308 # /usr/local libraries. 7309 if test -n "$cf_rpath_oops" 7310 then 7311 for cf_rpath_src in $cf_rpath_oops 7312 do 7313 for cf_rpath_dir in \ 7314 /usr/local \ 7315 /usr/pkg \ 7316 /opt/sfw 7317 do 7318 if test -f "$cf_rpath_dir/lib/$cf_rpath_src" 7319 then 7320 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src) 7321 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib" 7322 break 7323 fi 7324 done 7325 done 7326 fi 7327 fi 7328 7329 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS) 7330 7331 CF_RPATH_HACK_2(LDFLAGS) 7332 CF_RPATH_HACK_2(LIBS) 7333 7334 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS) 7335else 7336 AC_MSG_RESULT(no) 7337fi 7338AC_SUBST(EXTRA_LDFLAGS) 7339])dnl 7340dnl --------------------------------------------------------------------------- 7341dnl CF_RPATH_HACK_2 version: 8 updated: 2021/01/01 13:31:04 7342dnl --------------- 7343dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to 7344dnl EXTRA_LDFLAGS for each -L option found. 7345dnl 7346dnl $cf_rpath_list contains a list of directories to ignore. 7347dnl 7348dnl $1 = variable name to update. The LDFLAGS variable should be the only one, 7349dnl but LIBS often has misplaced -L options. 7350AC_DEFUN([CF_RPATH_HACK_2], 7351[ 7352CF_VERBOSE(...checking $1 [$]$1) 7353 7354cf_rpath_dst= 7355for cf_rpath_src in [$]$1 7356do 7357 case "$cf_rpath_src" in 7358 (-L*) 7359 7360 # check if this refers to a directory which we will ignore 7361 cf_rpath_skip=no 7362 if test -n "$cf_rpath_list" 7363 then 7364 for cf_rpath_item in $cf_rpath_list 7365 do 7366 if test "x$cf_rpath_src" = "x-L$cf_rpath_item" 7367 then 7368 cf_rpath_skip=yes 7369 break 7370 fi 7371 done 7372 fi 7373 7374 if test "$cf_rpath_skip" = no 7375 then 7376 # transform the option 7377 if test "$LD_RPATH_OPT" = "-R " ; then 7378 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"` 7379 else 7380 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"` 7381 fi 7382 7383 # if we have not already added this, add it now 7384 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"` 7385 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS" 7386 then 7387 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp) 7388 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS" 7389 fi 7390 fi 7391 ;; 7392 esac 7393 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src" 7394done 7395$1=$cf_rpath_dst 7396 7397CF_VERBOSE(...checked $1 [$]$1) 7398AC_SUBST(EXTRA_LDFLAGS) 7399])dnl 7400dnl --------------------------------------------------------------------------- 7401dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44 7402dnl ------------------ 7403dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers 7404dnl and libraries which do not update those variables. 7405dnl 7406dnl $1 = name of current macro 7407define([CF_SAVE_XTRA_FLAGS], 7408[ 7409cf_save_LIBS_$1="$LIBS" 7410cf_save_CFLAGS_$1="$CFLAGS" 7411cf_save_CPPFLAGS_$1="$CPPFLAGS" 7412LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}" 7413for cf_X_CFLAGS in $X_CFLAGS 7414do 7415 case "x$cf_X_CFLAGS" in 7416 x-[[IUD]]*) 7417 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS" 7418 ;; 7419 *) 7420 CFLAGS="$CFLAGS $cf_X_CFLAGS" 7421 ;; 7422 esac 7423done 7424])dnl 7425dnl --------------------------------------------------------------------------- 7426dnl CF_SHARED_OPTS version: 111 updated: 2024/03/29 20:08:49 7427dnl -------------- 7428dnl -------------- 7429dnl Attempt to determine the appropriate CC/LD options for creating a shared 7430dnl library. 7431dnl 7432dnl Notes: 7433dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within 7434dnl the build-tree, i.e., by making use of the libraries that are compiled in 7435dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the 7436dnl shared library since that can lead to unexpected results at runtime. 7437dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared 7438dnl libraries are compiled in ../../lib 7439dnl 7440dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure 7441dnl to install symbolic links to the rel/abi versions of shared libraries. 7442dnl 7443dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi 7444dnl version when making symbolic links. 7445dnl 7446dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library 7447dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix 7448dnl (ex: libncurses.so.<ver>). 7449dnl 7450dnl Some loaders leave 'so_locations' lying around. It is nice to clean up. 7451AC_DEFUN([CF_SHARED_OPTS], 7452[ 7453 AC_REQUIRE([CF_LD_RPATH_OPT]) 7454 7455 RM_SHARED_OPTS= 7456 LOCAL_LDFLAGS= 7457 LOCAL_LDFLAGS2= 7458 LD_SHARED_OPTS= 7459 INSTALL_LIB="-m 644" 7460 : ${rel_builddir:=.} 7461 7462 shlibdir=$libdir 7463 AC_SUBST(shlibdir) 7464 7465 MAKE_DLLS="#" 7466 AC_SUBST(MAKE_DLLS) 7467 7468 cf_cv_do_symlinks=no 7469 cf_ld_rpath_opt= 7470 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT" 7471 7472 AC_MSG_CHECKING(whether to use release or ABI version in shared library file names) 7473 AC_ARG_WITH(shlib-version, 7474 [[ --with-shlib-version[={rel|abi}] use release or ABI version in shared library file names]], 7475 [test -z "$withval" && withval=auto 7476 case "$withval" in 7477 (yes) 7478 cf_cv_shlib_version=auto 7479 ;; 7480 (rel|abi|auto) 7481 cf_cv_shlib_version=$withval 7482 ;; 7483 (*) 7484 AC_MSG_RESULT($withval) 7485 AC_MSG_ERROR([option value must be one of: rel, abi, or auto]) 7486 ;; 7487 esac 7488 ],[cf_cv_shlib_version=auto]) 7489 AC_MSG_RESULT($cf_cv_shlib_version) 7490 7491 cf_cv_rm_so_locs=no 7492 cf_try_cflags= 7493 7494 # Some less-capable ports of gcc support only -fpic 7495 CC_SHARED_OPTS= 7496 7497 cf_try_fPIC=no 7498 if test "$GCC" = yes 7499 then 7500 cf_try_fPIC=yes 7501 else 7502 case "$cf_cv_system_name" in 7503 (*linux*) # e.g., PGI compiler 7504 cf_try_fPIC=yes 7505 ;; 7506 esac 7507 fi 7508 7509 if test "$cf_try_fPIC" = yes 7510 then 7511 AC_MSG_CHECKING(which $CC option to use) 7512 cf_save_CFLAGS="$CFLAGS" 7513 for CC_SHARED_OPTS in -fPIC -fpic '' 7514 do 7515 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS" 7516 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1; (void)x],[break],[]) 7517 done 7518 AC_MSG_RESULT($CC_SHARED_OPTS) 7519 CFLAGS="$cf_save_CFLAGS" 7520 fi 7521 7522 cf_cv_shlib_version_infix=no 7523 7524 case "$cf_cv_system_name" in 7525 (aix4.[3-9]*|aix[[5-7]]*) 7526 if test "$GCC" = yes; then 7527 CC_SHARED_OPTS='-Wl,-brtl' 7528 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@' 7529 else 7530 CC_SHARED_OPTS='-brtl' 7531 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall" 7532 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@' 7533 fi 7534 ;; 7535 (beos*) 7536 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0' 7537 ;; 7538 (cygwin*) 7539 CC_SHARED_OPTS= 7540 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 7541 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 7542 cf_cv_shlib_version=cygdll 7543 cf_cv_shlib_version_infix=cygdll 7544 shlibdir=$bindir 7545 MAKE_DLLS= 7546 cat >mk_shared_lib.sh <<-CF_EOF 7547 #!$SHELL 7548 SHARED_LIB=\[$]1 7549 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 7550 shift 7551 cat <<-EOF 7552 Linking shared library 7553 ** SHARED_LIB \[$]SHARED_LIB 7554 ** IMPORT_LIB \[$]IMPORT_LIB 7555EOF 7556 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 7557CF_EOF 7558 chmod +x mk_shared_lib.sh 7559 ;; 7560 (msys*) 7561 CC_SHARED_OPTS= 7562 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 7563 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 7564 cf_cv_shlib_version=msysdll 7565 cf_cv_shlib_version_infix=msysdll 7566 shlibdir=$bindir 7567 MAKE_DLLS= 7568 cat >mk_shared_lib.sh <<-CF_EOF 7569 #!$SHELL 7570 SHARED_LIB=\[$]1 7571 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 7572 shift 7573 cat <<-EOF 7574 Linking shared library 7575 ** SHARED_LIB \[$]SHARED_LIB 7576 ** IMPORT_LIB \[$]IMPORT_LIB 7577EOF 7578 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 7579CF_EOF 7580 chmod +x mk_shared_lib.sh 7581 ;; 7582 (darwin*) 7583 cf_try_cflags="no-cpp-precomp" 7584 CC_SHARED_OPTS="-dynamic" 7585 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]' 7586 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi 7587 cf_cv_shlib_version_infix=yes 7588 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [ 7589 cf_save_LDFLAGS=$LDFLAGS 7590 LDFLAGS="$LDFLAGS -Wl,-search_paths_first" 7591 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no) 7592 LDFLAGS=$cf_save_LDFLAGS]) 7593 if test "$cf_cv_ldflags_search_paths_first" = yes; then 7594 LDFLAGS="$LDFLAGS -Wl,-search_paths_first" 7595 fi 7596 ;; 7597 (haiku*) 7598 CF_SHARED_SONAME 7599 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 7600 ;; 7601 (hpux[[7-8]]*) 7602 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list 7603 if test "$GCC" != yes; then 7604 CC_SHARED_OPTS='+Z' 7605 fi 7606 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]' 7607 INSTALL_LIB="-m 555" 7608 ;; 7609 (hpux*) 7610 # (tested with gcc 2.7.2 -- I don't have c89) 7611 if test "$GCC" = yes; then 7612 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}' 7613 else 7614 CC_SHARED_OPTS='+Z' 7615 LD_SHARED_OPTS='-Wl,+b,${libdir}' 7616 fi 7617 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]' 7618 # HP-UX shared libraries must be executable, and should be 7619 # readonly to exploit a quirk in the memory manager. 7620 INSTALL_LIB="-m 555" 7621 ;; 7622 (interix*) 7623 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 7624 if test "$cf_cv_shlib_version" = rel; then 7625 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}' 7626 else 7627 cf_shared_soname='`basename $[@]`' 7628 fi 7629 CC_SHARED_OPTS= 7630 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]' 7631 ;; 7632 (irix*) 7633 if test "$cf_cv_enable_rpath" = yes ; then 7634 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 7635 fi 7636 # tested with IRIX 5.2 and 'cc'. 7637 if test "$GCC" != yes; then 7638 CC_SHARED_OPTS='-KPIC' 7639 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]' 7640 else 7641 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]' 7642 fi 7643 cf_cv_rm_so_locs=yes 7644 ;; 7645 (linux*|gnu*|k*bsd*-gnu) 7646 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 7647 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 7648 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7649 fi 7650 if test "$cf_cv_enable_rpath" = yes ; then 7651 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 7652 fi 7653 CF_SHARED_SONAME 7654 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 7655 ;; 7656 (mingw*msvc*) 7657 cf_cv_shlib_version=msvcdll 7658 cf_cv_shlib_version_infix=msvcdll 7659 shlibdir=$bindir 7660 MAKE_DLLS= 7661 if test "$DFT_LWR_MODEL" = "shared" ; then 7662 LOCAL_LDFLAGS="-link -dll" 7663 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7664 EXTRA_LDFLAGS="-link -dll $EXTRA_LDFLAGS" 7665 fi 7666 CC_SHARED_OPTS= 7667 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ ${LD} [$]{CFLAGS}' 7668 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.lib" 7669 cat >mk_shared_lib.sh <<-CF_EOF 7670 #!$SHELL 7671 SHARED_LIB=\[$]1 7672 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.lib/'\` 7673 shift 7674 my_ld=\[$]1 7675 shift 7676 cat <<-EOF 7677 Linking shared library 7678 ** SHARED LIB \$SHARED_LIB 7679 ** IMPORT_LIB \$IMPORT_LIB 7680EOF 7681 args=\$(echo \[$]* | sed -E "s#-l(\w*)#\1.dll.lib#g" | sed -E "s#-L(\w*)#-LIBPATH:\1#g") 7682 exec \$my_ld -DLL -IMPLIB:"\${IMPORT_LIB}" -OUT:"\${SHARED_LIB}" ${LDFLAGS} \$args 7683 mv "\${IMPORT_LIB}" "\${IMPORT_LIB}" 7684CF_EOF 7685 chmod +x mk_shared_lib.sh 7686 cat >mk_prog.sh <<-CF_EOF 7687 #!$SHELL 7688 shift 7689 # Ignore first argument (compiler) and use LD (link.exe) unconditionally 7690 LD="[$]LD" 7691 clopts=() 7692 ldopts=("/subsystem:console") 7693 libs=() 7694 isdll=0 7695 while test \[$]# -gt 0; do 7696 case "\[$]1" in 7697 -link) 7698 # ignore -link argument 7699 ;; 7700 -M[[TD]] | -M[[TD]]d) 7701 # ignore runtime-library option 7702 ;; 7703 -dll) 7704 isdll=1 7705 ;; 7706 -W* | -w*) 7707 # ignore warnings 7708 ;; 7709 -D*) 7710 clopts+=("\[$]1") 7711 ;; 7712 -I*) 7713 clopts+=("\[$]1") 7714 ;; 7715 -l*) 7716 libs+=("\`echo \"\[$]1\" | sed \"s/^-l//\"\`") 7717 ;; 7718 -L*) 7719 ldopts+=("\`echo \"\[$]1\" | sed \"s/^-L/-LIBPATH:/\"\`") 7720 ;; 7721 *.obj | *.o) 7722 ldopts+=("\[$]1") 7723 ;; 7724 -Wl,*) 7725 for linkarg in \`echo '\[$]1' | sed -e 's/-Wl,//' -e 's/,/ /'\`; do 7726 ldopts+=("\[$]{linkarg}") 7727 done 7728 ;; 7729 *.lib) 7730 ldopts+=("\[$]1") 7731 ;; 7732 -o) 7733 shift 7734 ldopts+=("-out:\[$]1") 7735 ;; 7736 *) 7737 clopts+=("\[$]1") 7738 ldopts+=("\[$]1") 7739 ;; 7740 esac 7741 shift 7742 done 7743 if [[ "\$isdll" -ne 0 ]]; then 7744 for lib in \[$]{libs[[*]]}; do 7745 ldopts+=("\[$]lib.dll.lib") 7746 done 7747 else 7748 for lib in \[$]{libs[[*]]}; do 7749 ldopts+=("\[$]lib.lib") 7750 done 7751 fi 7752 cat <<-EOF 7753 Creating program 7754 ** ld options: "\[$]{ldopts[[@]]}" 7755EOF 7756 exec \[$]LD \[$]{ldopts[[@]]} 7757CF_EOF 7758 chmod +x mk_prog.sh 7759 LINK_PROGS="$SHELL ${rel_builddir}/mk_prog.sh" 7760 LINK_TESTS="$SHELL ${rel_builddir}/mk_prog.sh" 7761 ;; 7762 (mingw*) 7763 cf_cv_shlib_version=mingw 7764 cf_cv_shlib_version_infix=mingw 7765 shlibdir=$bindir 7766 MAKE_DLLS= 7767 if test "$DFT_LWR_MODEL" = "shared" ; then 7768 LOCAL_LDFLAGS="-Wl,--enable-auto-import" 7769 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7770 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS" 7771 fi 7772 CC_SHARED_OPTS= 7773 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 7774 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 7775 cat >mk_shared_lib.sh <<-CF_EOF 7776 #!$SHELL 7777 SHARED_LIB=\[$]1 7778 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 7779 shift 7780 cat <<-EOF 7781 Linking shared library 7782 ** SHARED_LIB \[$]SHARED_LIB 7783 ** IMPORT_LIB \[$]IMPORT_LIB 7784EOF 7785 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 7786CF_EOF 7787 chmod +x mk_shared_lib.sh 7788 ;; 7789 (openbsd[[2-9]].*|mirbsd*) 7790 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 7791 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 7792 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7793 fi 7794 if test "$cf_cv_enable_rpath" = yes ; then 7795 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 7796 fi 7797 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 7798 CF_SHARED_SONAME 7799 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 7800 ;; 7801 (nskJ*) 7802 CC_SHARED_OPTS= 7803 MK_SHARED_LIB='${LD} -Wshared -Weld=-export_all -o $[@]' 7804 ;; 7805 (nskL*) 7806 CC_SHARED_OPTS= 7807 MK_SHARED_LIB='${LD} -Wshared -Wxld=-export_all -o $[@]' 7808 ;; 7809 (nto-qnx*|openbsd*|freebsd[[12]].*) 7810 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 7811 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]' 7812 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 7813 ;; 7814 (dragonfly*|freebsd*) 7815 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 7816 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then 7817 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)" 7818 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS" 7819 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 7820 fi 7821 CF_SHARED_SONAME 7822 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 7823 ;; 7824 (netbsd*) 7825 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 7826 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then 7827 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)" 7828 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7829 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 7830 if test "$cf_cv_shlib_version" = auto; then 7831 if test -f /usr/libexec/ld.elf_so; then 7832 cf_cv_shlib_version=abi 7833 else 7834 cf_cv_shlib_version=rel 7835 fi 7836 fi 7837 CF_SHARED_SONAME 7838 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]' 7839 else 7840 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -o $[@]' 7841 fi 7842 ;; 7843 (osf*|mls+*) 7844 # tested with OSF/1 V3.2 and 'cc' 7845 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't 7846 # link with shared libs). 7847 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`' 7848 case "$host_os" in 7849 (osf4*) 7850 MK_SHARED_LIB="${MK_SHARED_LIB} -msym" 7851 ;; 7852 esac 7853 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]' 7854 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 7855 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 7856 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7857 fi 7858 cf_cv_rm_so_locs=yes 7859 ;; 7860 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98 7861 # tested with osr5.0.5 7862 if test "$GCC" != yes; then 7863 CC_SHARED_OPTS='-belf -KPIC' 7864 fi 7865 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@' 7866 if test "$cf_cv_enable_rpath" = yes ; then 7867 # only way is to set LD_RUN_PATH but no switch for it 7868 RUN_PATH=$libdir 7869 fi 7870 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 7871 LINK_PROGS='LD_RUN_PATH=${libdir}' 7872 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib' 7873 ;; 7874 (sunos4*) 7875 # tested with SunOS 4.1.1 and gcc 2.7.0 7876 if test "$GCC" != yes; then 7877 CC_SHARED_OPTS='-KPIC' 7878 fi 7879 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]' 7880 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 7881 ;; 7882 (solaris2*) 7883 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2 7884 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3 7885 if test "$DFT_LWR_MODEL" = "shared" ; then 7886 LOCAL_LDFLAGS="-R\$(LOCAL_LIBDIR):\${libdir}" 7887 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 7888 fi 7889 if test "$cf_cv_enable_rpath" = yes ; then 7890 EXTRA_LDFLAGS="-R\${libdir} $EXTRA_LDFLAGS" 7891 fi 7892 CF_SHARED_SONAME 7893 if test "$GCC" != yes; then 7894 cf_save_CFLAGS="$CFLAGS" 7895 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O 7896 do 7897 CFLAGS="$cf_shared_opts $cf_save_CFLAGS" 7898 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\\n");],[break]) 7899 done 7900 CFLAGS="$cf_save_CFLAGS" 7901 CC_SHARED_OPTS=$cf_shared_opts 7902 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -Wl,-h,'$cf_cv_shared_soname' -o $[@]' 7903 else 7904 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -Wl,-h,'$cf_cv_shared_soname' -o $[@]' 7905 fi 7906 ;; 7907 (sysv5uw7*|unix_sv*) 7908 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc) 7909 if test "$GCC" != yes; then 7910 CC_SHARED_OPTS='-KPIC' 7911 fi 7912 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@' 7913 ;; 7914 (*) 7915 CC_SHARED_OPTS='unknown' 7916 MK_SHARED_LIB='echo unknown' 7917 ;; 7918 esac 7919 7920 # This works if the last tokens in $MK_SHARED_LIB are the -o target. 7921 case "$cf_cv_shlib_version" in 7922 (rel|abi) 7923 case "$MK_SHARED_LIB" in 7924 (*'-o $[@]') 7925 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes 7926 ;; 7927 (*) 7928 AC_MSG_WARN(ignored --with-shlib-version) 7929 ;; 7930 esac 7931 ;; 7932 esac 7933 7934 if test -n "$cf_try_cflags" 7935 then 7936cat > conftest.$ac_ext <<EOF 7937#line __oline__ "${as_me:-configure}" 7938#include <stdio.h> 7939int main(int argc, char *argv[[]]) 7940{ 7941 printf("hello\\n"); 7942 return (argv[[argc-1]] == 0) ; 7943} 7944EOF 7945 cf_save_CFLAGS="$CFLAGS" 7946 for cf_opt in $cf_try_cflags 7947 do 7948 CFLAGS="$cf_save_CFLAGS -$cf_opt" 7949 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works) 7950 if AC_TRY_EVAL(ac_compile); then 7951 AC_MSG_RESULT(yes) 7952 cf_save_CFLAGS="$CFLAGS" 7953 else 7954 AC_MSG_RESULT(no) 7955 fi 7956 done 7957 CFLAGS="$cf_save_CFLAGS" 7958 fi 7959 7960 7961 # RPATH_LIST is a colon-separated list of directories 7962 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}" 7963 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}" 7964 7965 test "$cf_cv_rm_so_locs" = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations" 7966 7967 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS) 7968 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 7969 7970 AC_SUBST(CC_SHARED_OPTS) 7971 AC_SUBST(LD_RPATH_OPT) 7972 AC_SUBST(LD_SHARED_OPTS) 7973 AC_SUBST(MK_SHARED_LIB) 7974 AC_SUBST(RM_SHARED_OPTS) 7975 7976 AC_SUBST(LINK_PROGS) 7977 AC_SUBST(LINK_TESTS) 7978 7979 AC_SUBST(EXTRA_LDFLAGS) 7980 AC_SUBST(LOCAL_LDFLAGS) 7981 AC_SUBST(LOCAL_LDFLAGS2) 7982 7983 AC_SUBST(INSTALL_LIB) 7984 AC_SUBST(RPATH_LIST) 7985])dnl 7986dnl --------------------------------------------------------------------------- 7987dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43 7988dnl ---------------- 7989dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for 7990dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar) 7991dnl option. 7992dnl 7993dnl $1 is the default that should be used for "$cf_cv_shlib_version". 7994dnl If missing, use "rel". 7995define([CF_SHARED_SONAME], 7996[ 7997 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1) 7998 if test "$cf_cv_shlib_version" = rel; then 7999 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}' 8000 else 8001 cf_cv_shared_soname='`basename $[@]`' 8002 fi 8003]) 8004dnl --------------------------------------------------------------------------- 8005dnl CF_SIGWINCH version: 7 updated: 2023/02/18 17:41:25 8006dnl ----------- 8007dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all 8008dnl programs need this test). 8009dnl 8010dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE 8011dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct 8012dnl winsize declaration is left alone - we may revisit this if Apple choose to 8013dnl break that part of the interface as well. 8014AC_DEFUN([CF_SIGWINCH], 8015[ 8016AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[ 8017 AC_TRY_COMPILE([ 8018#include <sys/types.h> 8019#include <sys/signal.h> 8020],[int x = SIGWINCH; (void)x], 8021 [cf_cv_define_sigwinch=yes], 8022 [AC_TRY_COMPILE([ 8023#undef _XOPEN_SOURCE 8024#undef _POSIX_SOURCE 8025#undef _POSIX_C_SOURCE 8026#include <sys/types.h> 8027#include <sys/signal.h> 8028],[int x = SIGWINCH; (void)x], 8029 [cf_cv_define_sigwinch=maybe], 8030 [cf_cv_define_sigwinch=no]) 8031]) 8032]) 8033 8034if test "$cf_cv_define_sigwinch" = maybe ; then 8035AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[ 8036cf_cv_fixup_sigwinch=unknown 8037cf_sigwinch=32 8038while test "$cf_sigwinch" != 1 8039do 8040 AC_TRY_COMPILE([ 8041#undef _XOPEN_SOURCE 8042#undef _POSIX_SOURCE 8043#undef _POSIX_C_SOURCE 8044#include <sys/types.h> 8045#include <sys/signal.h> 8046],[ 8047#if SIGWINCH != $cf_sigwinch 8048#error SIGWINCH is not $cf_sigwinch 8049#endif 8050int x = SIGWINCH; (void)x], 8051 [cf_cv_fixup_sigwinch=$cf_sigwinch 8052 break]) 8053 8054cf_sigwinch="`expr "$cf_sigwinch" - 1`" 8055done 8056]) 8057 8058 if test "$cf_cv_fixup_sigwinch" != unknown ; then 8059 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch" 8060 fi 8061fi 8062])dnl 8063dnl --------------------------------------------------------------------------- 8064dnl CF_SIG_ATOMIC_T version: 5 updated: 2020/03/10 18:53:47 8065dnl --------------- 8066dnl signal handler, but there are some gcc dependencies in that recommendation. 8067dnl Try anyway. 8068AC_DEFUN([CF_SIG_ATOMIC_T], 8069[ 8070AC_MSG_CHECKING(for signal global datatype) 8071AC_CACHE_VAL(cf_cv_sig_atomic_t,[ 8072 for cf_type in \ 8073 "volatile sig_atomic_t" \ 8074 "sig_atomic_t" \ 8075 "int" 8076 do 8077 AC_TRY_COMPILE([ 8078#include <sys/types.h> 8079#include <signal.h> 8080#include <stdio.h> 8081 8082extern $cf_type x; 8083$cf_type x; 8084static void handler(int sig) 8085{ 8086 (void)sig; 8087 x = 5; 8088}], 8089 [signal(SIGINT, handler); 8090 x = 1], 8091 [cf_cv_sig_atomic_t=$cf_type], 8092 [cf_cv_sig_atomic_t=no]) 8093 test "$cf_cv_sig_atomic_t" != no && break 8094 done 8095 ]) 8096AC_MSG_RESULT($cf_cv_sig_atomic_t) 8097test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype]) 8098])dnl 8099dnl --------------------------------------------------------------------------- 8100dnl CF_SIZECHANGE version: 18 updated: 2021/09/04 06:35:04 8101dnl ------------- 8102dnl Check for definitions & structures needed for window size-changing 8103dnl 8104dnl https://stackoverflow.com/questions/18878141/difference-between-structures-ttysize-and-winsize/50769952#50769952 8105AC_DEFUN([CF_SIZECHANGE], 8106[ 8107AC_REQUIRE([CF_STRUCT_TERMIOS]) 8108AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[ 8109 cf_cv_sizechange=unknown 8110 cf_save_CPPFLAGS="$CPPFLAGS" 8111 8112for cf_opts in "" "NEED_PTEM_H" 8113do 8114 8115 CPPFLAGS="$cf_save_CPPFLAGS" 8116 if test -n "$cf_opts" 8117 then 8118 CF_APPEND_TEXT(CPPFLAGS,-D$cf_opts) 8119 fi 8120 AC_TRY_COMPILE([#include <sys/types.h> 8121#ifdef HAVE_TERMIOS_H 8122#include <termios.h> 8123#else 8124#ifdef HAVE_TERMIO_H 8125#include <termio.h> 8126#endif 8127#endif 8128 8129#ifdef NEED_PTEM_H 8130/* This is a workaround for SCO: they neglected to define struct winsize in 8131 * termios.h -- it is only in termio.h and ptem.h 8132 */ 8133#include <sys/stream.h> 8134#include <sys/ptem.h> 8135#endif 8136 8137#ifdef HAVE_SYS_IOCTL_H 8138#include <sys/ioctl.h> 8139#endif 8140],[ 8141#ifdef TIOCGSIZE 8142 struct ttysize win; /* SunOS 3.0... */ 8143 int y = win.ts_lines = 2; 8144 int x = win.ts_cols = 1; 8145 (void)y; 8146 (void)x; 8147#else 8148#ifdef TIOCGWINSZ 8149 struct winsize win; /* everything else */ 8150 int y = win.ws_row = 2; 8151 int x = win.ws_col = 1; 8152 (void)y; 8153 (void)x; 8154#else 8155 no TIOCGSIZE or TIOCGWINSZ 8156#endif /* TIOCGWINSZ */ 8157#endif /* TIOCGSIZE */ 8158 ], 8159 [cf_cv_sizechange=yes], 8160 [cf_cv_sizechange=no]) 8161 8162 CPPFLAGS="$cf_save_CPPFLAGS" 8163 if test "$cf_cv_sizechange" = yes ; then 8164 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC 8165 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts" 8166 break 8167 fi 8168done 8169]) 8170if test "$cf_cv_sizechange" != no ; then 8171 AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechange declarations are provided]) 8172 case "$cf_cv_sizechange" in 8173 (NEED*) 8174 AC_DEFINE_UNQUOTED($cf_cv_sizechange ) 8175 ;; 8176 esac 8177fi 8178])dnl 8179dnl --------------------------------------------------------------------------- 8180dnl CF_SRC_MODULES version: 34 updated: 2023/04/22 11:51:06 8181dnl -------------- 8182dnl For each parameter, test if the source-directory exists, and if it contains 8183dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll 8184dnl use in CF_LIB_RULES. 8185dnl 8186dnl This uses the configured value to make the lists SRC_SUBDIRS and 8187dnl SUB_MAKEFILES which are used in the makefile-generation scheme. 8188AC_DEFUN([CF_SRC_MODULES], 8189[ 8190AC_REQUIRE([CF_CHECK_GNAT_VERSION]) 8191AC_MSG_CHECKING(for src modules) 8192 8193# dependencies and linker-arguments for test-programs 8194TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS" 8195TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2" 8196if test "$DFT_LWR_MODEL" = "libtool"; then 8197 TEST_ARGS="${TEST_DEPS}" 8198 TEST_ARG2="${TEST_DEP2}" 8199else 8200 TEST_ARGS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS" 8201 TEST_ARG2="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARG2" 8202fi 8203 8204PC_MODULES_TO_MAKE="ncurses${USE_ARG_SUFFIX}" 8205cf_cv_src_modules= 8206for cf_dir in $1 8207do 8208 if test -f "$srcdir/$cf_dir/modules" ; then 8209 8210 if test -z "$cf_cv_src_modules"; then 8211 cf_cv_src_modules=$cf_dir 8212 else 8213 cf_cv_src_modules="$cf_cv_src_modules $cf_dir" 8214 fi 8215 8216 # Make the ncurses_cfg.h file record the library interface files as 8217 # well. These are header files that are the same name as their 8218 # directory. Ncurses is the only library that does not follow 8219 # that pattern. 8220 if test -f "$srcdir/${cf_dir}/${cf_dir}.h" ; then 8221 CF_UPPER(cf_have_include,$cf_dir) 8222 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H) 8223 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include}) 8224 CF_MAP_LIB_BASENAME(TEST_ROOT,$cf_dir) 8225 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEPS" 8226 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${TEST_ROOT}${DFT_DEP_SUFFIX} $TEST_DEP2" 8227 if test "$DFT_LWR_MODEL" = "libtool"; then 8228 TEST_ARGS="${TEST_DEPS}" 8229 TEST_ARG2="${TEST_DEP2}" 8230 else 8231 TEST_ARGS="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARGS" 8232 TEST_ARG2="-l${TEST_ROOT}${USE_ARG_SUFFIX} $TEST_ARG2" 8233 fi 8234 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${USE_ARG_SUFFIX}" 8235 fi 8236 fi 8237done 8238AC_MSG_RESULT($cf_cv_src_modules) 8239 8240TEST_ARGS="-L${LIB_DIR} $TEST_ARGS" 8241TEST_ARG2="-L${LIB_2ND} $TEST_ARG2" 8242 8243AC_SUBST(TEST_ARGS) 8244AC_SUBST(TEST_DEPS) 8245 8246AC_SUBST(TEST_ARG2) 8247AC_SUBST(TEST_DEP2) 8248 8249SRC_SUBDIRS= 8250if test "x$cf_with_manpages" != xno ; then 8251 SRC_SUBDIRS="$SRC_SUBDIRS man" 8252fi 8253SRC_SUBDIRS="$SRC_SUBDIRS include" 8254for cf_dir in $cf_cv_src_modules 8255do 8256 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir" 8257done 8258if test "x$cf_with_tests" != "xno" ; then 8259 SRC_SUBDIRS="$SRC_SUBDIRS test" 8260fi 8261# always make this, to install the ncurses-config script 8262SRC_SUBDIRS="$SRC_SUBDIRS misc" 8263if test "$cf_with_cxx_binding" != no; then 8264 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${USE_ARG_SUFFIX}" 8265 SRC_SUBDIRS="$SRC_SUBDIRS c++" 8266fi 8267 8268test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX" 8269test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX" 8270 8271AC_SUBST(PC_MODULES_TO_MAKE) 8272 8273ADA_SUBDIRS= 8274if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f "$srcdir/Ada95/Makefile.in" ; then 8275 SRC_SUBDIRS="$SRC_SUBDIRS Ada95" 8276 ADA_SUBDIRS="gen src" 8277 if test "x$cf_with_tests" != "xno" ; then 8278 ADA_SUBDIRS="$ADA_SUBDIRS samples" 8279 fi 8280fi 8281 8282SUB_MAKEFILES= 8283for cf_dir in $SRC_SUBDIRS 8284do 8285 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile" 8286done 8287 8288if test -n "$ADA_SUBDIRS"; then 8289 for cf_dir in $ADA_SUBDIRS 8290 do 8291 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile" 8292 done 8293 AC_SUBST(ADA_SUBDIRS) 8294fi 8295])dnl 8296dnl --------------------------------------------------------------------------- 8297dnl CF_STDCPP_LIBRARY version: 12 updated: 2021/01/01 13:31:04 8298dnl ----------------- 8299dnl Check for -lstdc++, which is GNU's standard C++ library. 8300dnl If $CXXLIBS is set, add that to the libraries used for test-linking. 8301dnl If -lstdc++ was not already added to $LIBS or $CXXLIBS, and is needed, 8302dnl add it to $CXXLIBS. 8303AC_DEFUN([CF_STDCPP_LIBRARY], 8304[ 8305if test -n "$GXX" ; then 8306 8307 cf_save="$LIBS" 8308 LIBS="$LIBS $CXXLIBS" 8309 AC_MSG_CHECKING(if we already have C++ library) 8310 AC_TRY_LINK([ 8311 #include <iostream>],[ 8312 std::cout << "Hello World!" << std::endl;], 8313 [cf_have_libstdcpp=yes], 8314 [cf_have_libstdcpp=no]) 8315 AC_MSG_RESULT($cf_have_libstdcpp) 8316 LIBS="$cf_save" 8317 8318 if test "$cf_have_libstdcpp" != yes 8319 then 8320 case "$cf_cv_system_name" in 8321 (os2*) 8322 if test -z "`g++ -dM -E - < /dev/null | grep __KLIBC__`"; then 8323 cf_stdcpp_libname=stdcpp 8324 else 8325 cf_stdcpp_libname=stdc++ 8326 fi 8327 ;; 8328 (*) 8329 cf_stdcpp_libname=stdc++ 8330 ;; 8331 esac 8332 8333 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[ 8334 cf_save="$LIBS" 8335 LIBS="$LIBS $CXXLIBS" 8336 CF_ADD_LIB($cf_stdcpp_libname) 8337 AC_TRY_LINK([ 8338 #include <iostream>],[ 8339 std::cout << "Hello World!" << std::endl;], 8340 [cf_cv_libstdcpp=yes], 8341 [cf_cv_libstdcpp=no]) 8342 LIBS="$cf_save" 8343 ]) 8344 test "$cf_cv_libstdcpp" = yes && { CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS) } 8345 fi 8346fi 8347])dnl 8348dnl --------------------------------------------------------------------------- 8349dnl CF_STRIP_G_OPT version: 4 updated: 2021/01/02 09:31:20 8350dnl -------------- 8351dnl Remove "-g" option from the compiler options 8352AC_DEFUN([CF_STRIP_G_OPT], 8353[$1=`echo "${$1}" | CF__SED_TRIMBLANKS(-e 's%-g %%' -e 's%-g$%%')`])dnl 8354dnl --------------------------------------------------------------------------- 8355dnl CF_STRUCT_SIGACTION version: 6 updated: 2023/12/03 09:21:34 8356dnl ------------------- 8357dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only 8358dnl do this if we've found the sigaction function. 8359AC_DEFUN([CF_STRUCT_SIGACTION],[ 8360AC_REQUIRE([CF_XOPEN_SOURCE]) 8361 8362if test "$ac_cv_func_sigaction" = yes; then 8363AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE) 8364AC_TRY_COMPILE([ 8365#include <sys/types.h> 8366#include <signal.h>], 8367 [struct sigaction act; (void)act], 8368 [sigact_bad=no], 8369 [ 8370AC_TRY_COMPILE([ 8371#define _POSIX_SOURCE 8372#include <sys/types.h> 8373#include <signal.h>], 8374 [struct sigaction act; (void)act], 8375 [sigact_bad=yes 8376 AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])], 8377 [sigact_bad=unknown])]) 8378AC_MSG_RESULT($sigact_bad) 8379fi 8380])dnl 8381dnl --------------------------------------------------------------------------- 8382dnl CF_STRUCT_TERMIOS version: 13 updated: 2023/12/03 19:38:54 8383dnl ----------------- 8384dnl Some machines require _POSIX_SOURCE to completely define struct termios. 8385AC_DEFUN([CF_STRUCT_TERMIOS],[ 8386AC_REQUIRE([CF_XOPEN_SOURCE]) 8387 8388AC_CHECK_HEADERS( \ 8389termio.h \ 8390termios.h \ 8391unistd.h \ 8392sys/ioctl.h \ 8393sys/termio.h \ 8394) 8395 8396if test "$ac_cv_header_termios_h" = yes ; then 8397 case "$CFLAGS $CPPFLAGS" in 8398 (*-D_POSIX_SOURCE*) 8399 termios_bad=dunno ;; 8400 (*) termios_bad=maybe ;; 8401 esac 8402 if test "$termios_bad" = maybe ; then 8403 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE) 8404 AC_TRY_COMPILE([#include <termios.h>], 8405 [struct termios foo; int x = (int)(foo.c_iflag = 1); (void)x], 8406 termios_bad=no, [ 8407 AC_TRY_COMPILE([ 8408#define _POSIX_SOURCE 8409#include <termios.h>], 8410 [struct termios foo; int x = (int)(foo.c_iflag = 2); (void)x], 8411 termios_bad=unknown, 8412 termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])) 8413 ]) 8414 AC_MSG_RESULT($termios_bad) 8415 fi 8416fi 8417])dnl 8418dnl --------------------------------------------------------------------------- 8419dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06 8420dnl -------------- 8421dnl Construct a search-list for a nonstandard header/lib-file 8422dnl $1 = the variable to return as result 8423dnl $2 = the package name 8424dnl $3 = the subdirectory, e.g., bin, include or lib 8425AC_DEFUN([CF_SUBDIR_PATH], 8426[ 8427$1= 8428 8429CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE) 8430 8431for cf_subdir_prefix in \ 8432 /usr \ 8433 /usr/local \ 8434 /usr/pkg \ 8435 /opt \ 8436 /opt/local \ 8437 [$]HOME 8438do 8439 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix) 8440done 8441])dnl 8442dnl --------------------------------------------------------------------------- 8443dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03 8444dnl ----------- 8445dnl Shorthand macro for substituting things that the user may override 8446dnl with an environment variable. 8447dnl 8448dnl $1 = condition to pass to "test" 8449dnl $2 = environment variable 8450dnl $3 = value if the test succeeds 8451dnl $4 = value if the test fails 8452AC_DEFUN([CF_SUBST_IF], 8453[ 8454if test $1 ; then 8455 $2=$3 8456ifelse($4,,,[else 8457 $2=$4]) 8458fi 8459AC_SUBST($2) 8460])dnl 8461dnl --------------------------------------------------------------------------- 8462dnl CF_SUBST_NCURSES_VERSION version: 11 updated: 2023/01/07 16:32:06 8463dnl ------------------------ 8464dnl Get the version-number for use in shared-library naming, etc. 8465AC_DEFUN([CF_SUBST_NCURSES_VERSION], 8466[AC_REQUIRE([AC_PROG_EGREP])dnl 8467 8468NCURSES_MAJOR="`${EGREP-egrep} '^NCURSES_MAJOR[[ ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`" 8469NCURSES_MINOR="`${EGREP-egrep} '^NCURSES_MINOR[[ ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`" 8470NCURSES_PATCH="`${EGREP-egrep} '^NCURSES_PATCH[[ ]]*=' "$srcdir/dist.mk" | sed -e 's/^[[^0-9]]*//'`" 8471cf_cv_abi_version=${NCURSES_MAJOR} 8472cf_cv_abi_default=${NCURSES_MAJOR} 8473cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR} 8474dnl Show the computed version, for logging 8475cf_cv_timestamp=`date` 8476AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_default ($cf_cv_timestamp)) 8477dnl We need these values in the generated headers 8478AC_SUBST(NCURSES_MAJOR) 8479AC_SUBST(NCURSES_MINOR) 8480AC_SUBST(NCURSES_PATCH) 8481dnl We need these values in the generated makefiles 8482AC_SUBST(cf_cv_rel_version) 8483AC_SUBST(cf_cv_abi_version) 8484AC_SUBST(cf_cv_abi_default) 8485AC_SUBST(cf_cv_builtin_bool) 8486AC_SUBST(cf_cv_header_stdbool_h) 8487AC_SUBST(cf_cv_type_of_bool)dnl 8488])dnl 8489dnl --------------------------------------------------------------------------- 8490dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57 8491dnl ------------------ 8492dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on 8493dnl older SCO configurations. 8494AC_DEFUN([CF_SYS_TIME_SELECT], 8495[ 8496AC_MSG_CHECKING(if sys/time.h works with sys/select.h) 8497AC_CACHE_VAL(cf_cv_sys_time_select,[ 8498AC_TRY_COMPILE([ 8499#include <sys/types.h> 8500#ifdef HAVE_SYS_TIME_H 8501#include <sys/time.h> 8502#endif 8503#ifdef HAVE_SYS_SELECT_H 8504#include <sys/select.h> 8505#endif 8506],[],[cf_cv_sys_time_select=yes], 8507 [cf_cv_sys_time_select=no]) 8508 ]) 8509AC_MSG_RESULT($cf_cv_sys_time_select) 8510test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT,1,[Define to 1 if we can include <sys/time.h> with <sys/select.h>]) 8511])dnl 8512dnl --------------------------------------------------------------------------- 8513dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32 8514dnl --------------- 8515dnl Define a top_builddir symbol, for applications that need an absolute path. 8516AC_DEFUN([CF_TOP_BUILDDIR], 8517[ 8518top_builddir=ifelse($1,,`pwd`,$1) 8519AC_SUBST(top_builddir) 8520])dnl 8521dnl --------------------------------------------------------------------------- 8522dnl CF_TRY_PKG_CONFIG version: 6 updated: 2020/12/31 10:54:15 8523dnl ----------------- 8524dnl This is a simple wrapper to use for pkg-config, for libraries which may be 8525dnl available in that form. 8526dnl 8527dnl $1 = package name, which may be a shell variable 8528dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS 8529dnl $3 = logic to use if pkg-config does not have the package 8530AC_DEFUN([CF_TRY_PKG_CONFIG],[ 8531AC_REQUIRE([CF_PKG_CONFIG]) 8532 8533if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists "$1"; then 8534 CF_VERBOSE(found package $1) 8535 cf_pkgconfig_incs="`$PKG_CONFIG --cflags "$1" 2>/dev/null`" 8536 cf_pkgconfig_libs="`$PKG_CONFIG --libs "$1" 2>/dev/null`" 8537 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs) 8538 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs) 8539 CF_ADD_CFLAGS($cf_pkgconfig_incs) 8540 CF_ADD_LIBS($cf_pkgconfig_libs) 8541 ifelse([$2],,:,[$2]) 8542else 8543 cf_pkgconfig_incs= 8544 cf_pkgconfig_libs= 8545 ifelse([$3],,:,[$3]) 8546fi 8547]) 8548dnl --------------------------------------------------------------------------- 8549dnl CF_TRY_XOPEN_SOURCE version: 4 updated: 2022/09/10 15:16:16 8550dnl ------------------- 8551dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we 8552dnl can define it successfully. 8553AC_DEFUN([CF_TRY_XOPEN_SOURCE],[ 8554AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[ 8555 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY, 8556 [cf_cv_xopen_source=no], 8557 [cf_save="$CPPFLAGS" 8558 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE) 8559 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY, 8560 [cf_cv_xopen_source=no], 8561 [cf_cv_xopen_source=$cf_XOPEN_SOURCE]) 8562 CPPFLAGS="$cf_save" 8563 ]) 8564]) 8565 8566if test "$cf_cv_xopen_source" != no ; then 8567 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE) 8568 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE) 8569 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source" 8570 CF_APPEND_CFLAGS($cf_temp_xopen_source) 8571fi 8572]) 8573dnl --------------------------------------------------------------------------- 8574dnl CF_TYPEOF_CHTYPE version: 11 updated: 2023/01/05 17:57:59 8575dnl ---------------- 8576dnl Determine the type we should use for chtype (and attr_t, which is treated 8577dnl as the same thing). We want around 32 bits, so on most machines want a 8578dnl long, but on newer 64-bit machines, probably want an int. If we're using 8579dnl wide characters, we have to have a type compatible with that, as well. 8580AC_DEFUN([CF_TYPEOF_CHTYPE], 8581[ 8582AC_MSG_CHECKING([for type of chtype]) 8583AC_CACHE_VAL(cf_cv_typeof_chtype,[ 8584 AC_TRY_RUN([ 8585$ac_includes_default 8586#define WANT_BITS 31 8587int main(void) 8588{ 8589 FILE *fp = fopen("cf_test.out", "w"); 8590 if (fp != 0) { 8591 char *result = "long"; 8592 if (sizeof(unsigned long) > sizeof(unsigned int)) { 8593 int n; 8594 unsigned int x, y; 8595 for (n = 0; n < WANT_BITS; n++) { 8596 x = (1 << n); 8597 y = (x >> n); 8598 if (y != 1 || x == 0) { 8599 x = 0; 8600 break; 8601 } 8602 } 8603 /* 8604 * If x is nonzero, an int is big enough for the bits 8605 * that we want. 8606 */ 8607 result = (x != 0) ? "int" : "long"; 8608 } 8609 fputs(result, fp); 8610 fclose(fp); 8611 } 8612 ${cf_cv_main_return:-return}(0); 8613} 8614 ], 8615 [cf_cv_typeof_chtype=`cat cf_test.out`], 8616 [cf_cv_typeof_chtype=long], 8617 [cf_cv_typeof_chtype=long]) 8618 rm -f cf_test.out 8619 ]) 8620AC_MSG_RESULT($cf_cv_typeof_chtype) 8621 8622AC_SUBST(cf_cv_typeof_chtype) 8623AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype]) 8624])dnl 8625dnl --------------------------------------------------------------------------- 8626dnl CF_TYPE_SIGACTION version: 5 updated: 2023/12/03 09:21:34 8627dnl ----------------- 8628dnl 8629AC_DEFUN([CF_TYPE_SIGACTION], 8630[ 8631AC_MSG_CHECKING([for type sigaction_t]) 8632AC_CACHE_VAL(cf_cv_type_sigaction,[ 8633 AC_TRY_COMPILE([ 8634#include <signal.h>], 8635 [sigaction_t x; (void)x], 8636 [cf_cv_type_sigaction=yes], 8637 [cf_cv_type_sigaction=no])]) 8638AC_MSG_RESULT($cf_cv_type_sigaction) 8639test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type]) 8640])dnl 8641dnl --------------------------------------------------------------------------- 8642dnl CF_UNSIGNED_LITERALS version: 3 updated: 2023/12/03 10:02:17 8643dnl -------------------- 8644dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers 8645dnl won't, but they're still there. 8646AC_DEFUN([CF_UNSIGNED_LITERALS], 8647[ 8648AC_MSG_CHECKING([if unsigned literals are legal]) 8649AC_CACHE_VAL(cf_cv_unsigned_literals,[ 8650 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1; (void)x], 8651 [cf_cv_unsigned_literals=yes], 8652 [cf_cv_unsigned_literals=no]) 8653 ]) 8654AC_MSG_RESULT($cf_cv_unsigned_literals) 8655])dnl 8656dnl --------------------------------------------------------------------------- 8657dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 8658dnl -------- 8659dnl Make an uppercase version of a variable 8660dnl $1=uppercase($2) 8661AC_DEFUN([CF_UPPER], 8662[ 8663$1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` 8664])dnl 8665dnl --------------------------------------------------------------------------- 8666dnl CF_UTF8_LIB version: 10 updated: 2023/01/11 04:05:23 8667dnl ----------- 8668dnl Check for multibyte support, and if not found, utf8 compatibility library 8669AC_DEFUN([CF_UTF8_LIB], 8670[ 8671AC_HAVE_HEADERS(wchar.h) 8672AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[ 8673 cf_save_LIBS="$LIBS" 8674 AC_TRY_LINK([ 8675$ac_includes_default 8676#ifdef HAVE_WCHAR_H 8677#include <wchar.h> 8678#endif 8679],[putwc(0,0);], 8680 [cf_cv_utf8_lib=yes], 8681 [CF_FIND_LINKAGE([ 8682#include <libutf8.h>],[putwc(0,0);],utf8, 8683 [cf_cv_utf8_lib=add-on], 8684 [cf_cv_utf8_lib=no]) 8685])]) 8686 8687# HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between 8688# ncurses/ncursesw: 8689if test "$cf_cv_utf8_lib" = "add-on" ; then 8690 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h]) 8691 CF_ADD_INCDIR($cf_cv_header_path_utf8) 8692 CF_ADD_LIBDIR($cf_cv_library_path_utf8) 8693 CF_ADD_LIBS($cf_cv_library_file_utf8) 8694fi 8695])dnl 8696dnl --------------------------------------------------------------------------- 8697dnl CF_VA_COPY version: 6 updated: 2018/12/04 18:14:25 8698dnl ---------- 8699dnl check for va_copy, part of stdarg.h starting with ISO C 1999. 8700dnl Also, workaround for glibc's __va_copy, by checking for both. 8701dnl Finally, try to accommodate pre-ISO C 1999 headers. 8702AC_DEFUN([CF_VA_COPY],[ 8703AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[ 8704AC_TRY_LINK([ 8705#include <stdarg.h> 8706],[ 8707 static va_list dst; 8708 static va_list src; 8709 va_copy(dst, src)], 8710 cf_cv_have_va_copy=yes, 8711 cf_cv_have_va_copy=no)]) 8712 8713if test "$cf_cv_have_va_copy" = yes; 8714then 8715 AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy]) 8716else # !cf_cv_have_va_copy 8717 8718AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[ 8719AC_TRY_LINK([ 8720#include <stdarg.h> 8721],[ 8722 static va_list dst; 8723 static va_list src; 8724 __va_copy(dst, src)], 8725 cf_cv_have___va_copy=yes, 8726 cf_cv_have___va_copy=no)]) 8727 8728if test "$cf_cv_have___va_copy" = yes 8729then 8730 AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy]) 8731else # !cf_cv_have___va_copy 8732 8733AC_CACHE_CHECK(for __builtin_va_copy, cf_cv_have___builtin_va_copy,[ 8734AC_TRY_LINK([ 8735#include <stdarg.h> 8736],[ 8737 static va_list dst; 8738 static va_list src; 8739 __builtin_va_copy(dst, src)], 8740 cf_cv_have___builtin_va_copy=yes, 8741 cf_cv_have___builtin_va_copy=no)]) 8742 8743test "$cf_cv_have___builtin_va_copy" = yes && 8744 AC_DEFINE(HAVE___BUILTIN_VA_COPY,1,[Define to 1 if we have __builtin_va_copy]) 8745 8746fi # cf_cv_have___va_copy 8747 8748fi # cf_cv_have_va_copy 8749 8750case "${cf_cv_have_va_copy}${cf_cv_have___va_copy}${cf_cv_have___builtin_va_copy}" in 8751(*yes*) 8752 ;; 8753 8754(*) 8755 AC_CACHE_CHECK(if we can simply copy va_list, cf_cv_pointer_va_list,[ 8756AC_TRY_LINK([ 8757#include <stdarg.h> 8758],[ 8759 va_list dst; 8760 va_list src; 8761 dst = src], 8762 cf_cv_pointer_va_list=yes, 8763 cf_cv_pointer_va_list=no)]) 8764 8765 if test "$cf_cv_pointer_va_list" = no 8766 then 8767 AC_CACHE_CHECK(if we can copy va_list indirectly, cf_cv_array_va_list,[ 8768AC_TRY_LINK([ 8769#include <stdarg.h> 8770],[ 8771 va_list dst; 8772 va_list src; 8773 *dst = *src], 8774 cf_cv_array_va_list=yes, 8775 cf_cv_array_va_list=no)]) 8776 test "$cf_cv_array_va_list" = yes && AC_DEFINE(ARRAY_VA_LIST,1,[Define to 1 if we can copy va_list indirectly]) 8777 fi 8778 ;; 8779esac 8780]) 8781dnl --------------------------------------------------------------------------- 8782dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12 8783dnl ---------- 8784dnl Use AC_VERBOSE w/o the warnings 8785AC_DEFUN([CF_VERBOSE], 8786[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG 8787CF_MSG_LOG([$1]) 8788])dnl 8789dnl --------------------------------------------------------------------------- 8790dnl CF_VERSION_INFO version: 8 updated: 2021/01/01 13:31:04 8791dnl --------------- 8792dnl Define several useful symbols derived from the VERSION file. A separate 8793dnl file is preferred to embedding the version numbers in various scripts. 8794dnl (automake is a textbook-example of why the latter is a bad idea, but there 8795dnl are others). 8796dnl 8797dnl The file contents are: 8798dnl libtool-version release-version patch-version 8799dnl or 8800dnl release-version 8801dnl where 8802dnl libtool-version (see ?) consists of 3 integers separated by '.' 8803dnl release-version consists of a major version and minor version 8804dnl separated by '.', optionally followed by a patch-version 8805dnl separated by '-'. The minor version need not be an 8806dnl integer (but it is preferred). 8807dnl patch-version is an integer in the form yyyymmdd, so ifdef's and 8808dnl scripts can easily compare versions. 8809dnl 8810dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL 8811dnl simply extracts the first field using 'cut -f1'. 8812dnl 8813dnl Optional parameters: 8814dnl $1 = internal name for package 8815dnl $2 = external name for package 8816AC_DEFUN([CF_VERSION_INFO], 8817[ 8818if test -f "$srcdir/VERSION" ; then 8819 AC_MSG_CHECKING(for package version) 8820 8821 # if there are not enough fields, cut returns the last one... 8822 cf_field1=`sed -e '2,$d' "$srcdir/VERSION" |cut -f1` 8823 cf_field2=`sed -e '2,$d' "$srcdir/VERSION" |cut -f2` 8824 cf_field3=`sed -e '2,$d' "$srcdir/VERSION" |cut -f3` 8825 8826 # this is how CF_BUNDLED_INTL uses $VERSION: 8827 VERSION="$cf_field1" 8828 8829 VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'` 8830 test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version) 8831 8832 VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'` 8833 test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version) 8834 8835 AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR}) 8836 8837 AC_MSG_CHECKING(for package patch date) 8838 VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'` 8839 case .$VERSION_PATCH in 8840 (.) 8841 AC_MSG_ERROR(missing patch-date $VERSION_PATCH) 8842 ;; 8843 (.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]]) 8844 ;; 8845 (*) 8846 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH) 8847 ;; 8848 esac 8849 AC_MSG_RESULT($VERSION_PATCH) 8850else 8851 AC_MSG_ERROR(did not find $srcdir/VERSION) 8852fi 8853 8854# show the actual data that we have for versions: 8855CF_VERBOSE(ABI VERSION $VERSION) 8856CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR) 8857CF_VERBOSE(VERSION_MINOR $VERSION_MINOR) 8858CF_VERBOSE(VERSION_PATCH $VERSION_PATCH) 8859 8860AC_SUBST(VERSION) 8861AC_SUBST(VERSION_MAJOR) 8862AC_SUBST(VERSION_MINOR) 8863AC_SUBST(VERSION_PATCH) 8864 8865dnl if a package name is given, define its corresponding version info. We 8866dnl need the package name to ensure that the defined symbols are unique. 8867ifelse($1,,,[ 8868 cf_PACKAGE=$1 8869 PACKAGE=ifelse($2,,$1,$2) 8870 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name]) 8871 AC_SUBST(PACKAGE) 8872 CF_UPPER(cf_PACKAGE,$cf_PACKAGE) 8873 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}") 8874 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH}) 8875]) 8876])dnl 8877dnl --------------------------------------------------------------------------- 8878dnl CF_WCHAR_TYPE version: 5 updated: 2023/12/03 09:21:34 8879dnl ------------- 8880dnl Check if type wide-character type $1 is declared, and if so, which header 8881dnl file is needed. The second parameter is used to set a shell variable when 8882dnl the type is not found. The first parameter sets a shell variable for the 8883dnl opposite sense. 8884AC_DEFUN([CF_WCHAR_TYPE], 8885[ 8886# This is needed on Tru64 5.0 to declare $1 8887AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[ 8888AC_TRY_COMPILE([ 8889#include <stdlib.h> 8890#include <stdarg.h> 8891#include <stdio.h> 8892#ifdef HAVE_LIBUTF8_H 8893#include <libutf8.h> 8894#endif], 8895 [$1 state; (void)state], 8896 [cf_cv_$1=no], 8897 [AC_TRY_COMPILE([ 8898#include <stdlib.h> 8899#include <stdarg.h> 8900#include <stdio.h> 8901#include <wchar.h> 8902#ifdef HAVE_LIBUTF8_H 8903#include <libutf8.h> 8904#endif], 8905 [$1 value; (void) value], 8906 [cf_cv_$1=yes], 8907 [cf_cv_$1=unknown])])]) 8908 8909if test "$cf_cv_$1" = yes ; then 8910 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h]) 8911 NEED_WCHAR_H=1 8912fi 8913 8914ifelse([$2],,,[ 8915# if we do not find $1 in either place, use substitution to provide a fallback. 8916if test "$cf_cv_$1" = unknown ; then 8917 $2=1 8918fi 8919]) 8920ifelse($3,,,[ 8921# if we find $1 in either place, use substitution to provide a fallback. 8922if test "$cf_cv_$1" != unknown ; then 8923 $3=1 8924fi 8925]) 8926])dnl 8927dnl --------------------------------------------------------------------------- 8928dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06 8929dnl --------------- 8930dnl Check for compiler-support for weak symbols. 8931dnl This works with "recent" gcc. 8932AC_DEFUN([CF_WEAK_SYMBOLS],[ 8933AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[ 8934 8935AC_TRY_COMPILE([ 8936#include <stdio.h>], 8937[ 8938#if defined(__GNUC__) 8939# if defined __USE_ISOC99 8940# define _cat_pragma(exp) _Pragma(#exp) 8941# define _weak_pragma(exp) _cat_pragma(weak name) 8942# else 8943# define _weak_pragma(exp) 8944# endif 8945# define _declare(name) __extension__ extern __typeof__(name) name 8946# define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak)) 8947#endif 8948 8949weak_symbol(fopen); 8950],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no]) 8951]) 8952])dnl 8953dnl --------------------------------------------------------------------------- 8954dnl CF_WITH_ABI_ALTERED version: 1 updated: 2023/01/07 16:32:06 8955dnl ------------------- 8956dnl Provide a way to override the displayed ABI version, e.g., in filenames. 8957dnl Check this option after using the ABI version in configuration decisions. 8958AC_DEFUN([CF_WITH_ABI_ALTERED],[ 8959AC_REQUIRE([CF_WITH_ABI_VERSION]) 8960AC_REQUIRE([CF_ABI_DEFAULTS]) 8961AC_ARG_WITH(abi-altered, 8962[ --with-abi-altered=XXX override visible ABI version, for packaging],[ 8963 CF_NUMBER_SYNTAX($withval,ABI altered) 8964 if test "$cf_cv_abi_version" != "$withval" 8965 then 8966 AC_MSG_WARN(altering visible ABI from $cf_cv_abi_version to $withval) 8967 cf_cv_abi_version=$withval 8968 fi 8969])dnl 8970])dnl 8971dnl --------------------------------------------------------------------------- 8972dnl CF_WITH_ABI_VERSION version: 5 updated: 2023/01/07 16:32:06 8973dnl ------------------- 8974dnl Allow library's ABI to be overridden. Generally this happens when a 8975dnl packager has incremented the ABI past that used in the original package, 8976dnl and wishes to keep doing this. 8977dnl 8978dnl $1 is the package name, if any, to derive a corresponding {package}_ABI 8979dnl symbol. 8980AC_DEFUN([CF_WITH_ABI_VERSION],[ 8981test -z "$cf_cv_abi_version" && cf_cv_abi_version=0 8982AC_ARG_WITH(abi-version, 8983[ --with-abi-version=XXX override derived ABI version],[ 8984 if test "x$cf_cv_abi_version" != "x$withval" 8985 then 8986 AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval) 8987 case "$cf_cv_rel_version" in 8988 (5.*) 8989 cf_cv_rel_version=$withval.0 8990 ;; 8991 (6.*) 8992 cf_cv_rel_version=$withval.9 # FIXME: should be 10 as of 6.0 release 8993 ;; 8994 esac 8995 fi 8996 cf_cv_abi_version=$withval]) 8997 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version) 8998ifelse($1,,,[ 8999$1_ABI=$cf_cv_abi_version 9000]) 9001cf_cv_abi_default=$cf_cv_abi_version 9002])dnl 9003dnl --------------------------------------------------------------------------- 9004dnl CF_WITH_ADA_COMPILER version: 3 updated: 2023/10/28 11:59:01 9005dnl -------------------- 9006dnl Command-line option to specify the Ada95 compiler. 9007AC_DEFUN([CF_WITH_ADA_COMPILER],[ 9008AC_MSG_CHECKING(for Ada95 compiler) 9009AC_ARG_WITH(ada-compiler, 9010 [[ --with-ada-compiler[=CMD] use CMD as Ada95 compiler (default: gnatmake)]], 9011 [cf_ada_compiler=$withval], 9012 [cf_ada_compiler=gnatmake]) 9013AC_SUBST(cf_ada_compiler) 9014AC_MSG_RESULT($cf_ada_compiler) 9015])dnl 9016dnl --------------------------------------------------------------------------- 9017dnl CF_WITH_ADA_INCLUDE version: 3 updated: 2023/10/28 11:59:01 9018dnl ------------------- 9019dnl Command-line option to specify where Ada includes will install. 9020AC_DEFUN([CF_WITH_ADA_INCLUDE],[ 9021AC_MSG_CHECKING(for Ada95 include directory) 9022CF_WITH_PATH(ada-include, 9023 [ --with-ada-include=DIR find Ada95 includes in DIR], 9024 ADA_INCLUDE, 9025 PREFIX/share/ada/adainclude, 9026 [$]prefix/share/ada/adainclude) 9027AC_SUBST(ADA_INCLUDE) 9028AC_MSG_RESULT($ADA_INCLUDE) 9029])dnl 9030dnl --------------------------------------------------------------------------- 9031dnl CF_WITH_ADA_LIBNAME version: 3 updated: 2023/11/22 20:48:30 9032dnl ------------------- 9033dnl CF_WITH_ADA_LIBNAME 9034dnl ------------------- 9035dnl Command-line option to specify how to name the resulting Ada library. 9036dnl $1 = default value 9037AC_DEFUN([CF_WITH_ADA_LIBNAME],[ 9038AC_MSG_CHECKING(for Ada95 curses library name) 9039AC_ARG_WITH(ada-libname, 9040 [[ --with-ada-libname[=XXX] use XXX as Ada95 library name]], 9041 ADA_LIBNAME=[$]withval, 9042 ADA_LIBNAME=$1) 9043case "x$ADA_LIBNAME" in 9044(x|xyes|xno) 9045 ADA_LIBNAME=$1 9046 ;; 9047esac 9048AC_SUBST(ADA_LIBNAME) 9049AC_MSG_RESULT($ADA_LIBNAME) 9050])dnl 9051dnl --------------------------------------------------------------------------- 9052dnl CF_WITH_ADA_OBJECTS version: 3 updated: 2023/10/28 11:59:01 9053dnl ------------------- 9054dnl Command-line option to specify where Ada objects will install. 9055AC_DEFUN([CF_WITH_ADA_OBJECTS],[ 9056AC_MSG_CHECKING(for Ada95 object directory) 9057CF_WITH_PATH(ada-objects, 9058 [ --with-ada-objects=DIR find Ada95 objects in DIR], 9059 ADA_OBJECTS, 9060 PREFIX/lib/ada/adalib, 9061 [$]prefix/lib/ada/adalib) 9062AC_SUBST(ADA_OBJECTS) 9063AC_MSG_RESULT($ADA_OBJECTS) 9064])dnl 9065dnl --------------------------------------------------------------------------- 9066dnl CF_WITH_ADA_SHAREDLIB version: 6 updated: 2023/10/28 11:59:01 9067dnl --------------------- 9068dnl Command-line option to specify if an Ada95 shared library should be built, 9069dnl and optionally what its soname should be. 9070AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[ 9071AC_REQUIRE([CF_GNAT_PROJECTS]) 9072AC_MSG_CHECKING(whether to build an Ada95 shared library) 9073AC_ARG_WITH(ada-sharedlib, 9074 [ --with-ada-sharedlib build Ada95 shared library; requires GNAT project support], 9075 [with_ada_sharedlib=$withval], 9076 [with_ada_sharedlib=no]) 9077cf_ada_sharedlib_warn=no 9078 9079if test "x$with_ada_sharedlib" != xno 9080then 9081 if test "x$cf_gnat_projects" != xyes 9082 then 9083 with_ada_sharedlib=no 9084 cf_ada_sharedlib_warn=yes 9085 fi 9086fi 9087 9088AC_MSG_RESULT($with_ada_sharedlib) 9089if test "x$cf_ada_sharedlib_warn" != xno 9090then 9091 AC_MSG_WARN(disabling Ada95 shared library since GNAT projects are not supported) 9092fi 9093 9094ADA_SHAREDLIB='lib$(LIB_NAME).so.1' 9095MAKE_ADA_SHAREDLIB="#" 9096 9097if test "x$with_ada_sharedlib" != xno 9098then 9099 MAKE_ADA_SHAREDLIB= 9100 if test "x$with_ada_sharedlib" != xyes 9101 then 9102 ADA_SHAREDLIB="$with_ada_sharedlib" 9103 fi 9104fi 9105 9106AC_SUBST(ADA_SHAREDLIB) 9107AC_SUBST(MAKE_ADA_SHAREDLIB) 9108])dnl 9109dnl --------------------------------------------------------------------------- 9110dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47 9111dnl ---------------- 9112dnl Configure-option for dbmalloc. The optional parameter is used to override 9113dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. 9114AC_DEFUN([CF_WITH_DBMALLOC],[ 9115CF_NO_LEAKS_OPTION(dbmalloc, 9116 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library], 9117 [USE_DBMALLOC]) 9118 9119if test "$with_dbmalloc" = yes ; then 9120 AC_CHECK_HEADER(dbmalloc.h, 9121 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))]) 9122fi 9123])dnl 9124dnl --------------------------------------------------------------------------- 9125dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47 9126dnl --------------- 9127dnl Configure-option for dmalloc. The optional parameter is used to override 9128dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. 9129AC_DEFUN([CF_WITH_DMALLOC],[ 9130CF_NO_LEAKS_OPTION(dmalloc, 9131 [ --with-dmalloc test: use Gray Watson's dmalloc library], 9132 [USE_DMALLOC]) 9133 9134if test "$with_dmalloc" = yes ; then 9135 AC_CHECK_HEADER(dmalloc.h, 9136 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))]) 9137fi 9138])dnl 9139dnl --------------------------------------------------------------------------- 9140dnl CF_WITH_EXPORT_SYMS version: 5 updated: 2023/11/22 20:48:30 9141dnl ------------------- 9142dnl Use this with libtool to specify the list of symbols that may be exported. 9143dnl The input file contains one symbol per line; comments work with "#". 9144dnl 9145dnl $1 = basename of the ".sym" file (default $PACKAGE) 9146AC_DEFUN([CF_WITH_EXPORT_SYMS], 9147[ 9148AC_MSG_CHECKING(if exported-symbols file should be used) 9149AC_ARG_WITH(export-syms, 9150 [[ --with-export-syms[=SYM-FILE] limit symbols exported by libtool to those listed in SYM-FILE]], 9151 [with_export_syms=$withval], 9152 [with_export_syms=no]) 9153if test "x$with_export_syms" = xyes 9154then 9155 with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym' 9156 AC_SUBST(PACKAGE) 9157fi 9158AC_MSG_RESULT($with_export_syms) 9159if test "x$with_export_syms" != xno 9160then 9161 EXPORT_SYMS="-export-symbols $with_export_syms" 9162 AC_SUBST(EXPORT_SYMS) 9163fi 9164])dnl 9165dnl --------------------------------------------------------------------------- 9166dnl CF_WITH_GPM version: 10 updated: 2017/04/29 18:32:18 9167dnl ----------- 9168dnl 9169dnl The option parameter (if neither yes/no) is assumed to be the name of 9170dnl the gpm library, e.g., for dynamic loading. 9171AC_DEFUN([CF_WITH_GPM], 9172[ 9173AC_MSG_CHECKING(if you want to link with the GPM mouse library) 9174AC_ARG_WITH(gpm, 9175 [ --with-gpm use Alessandro Rubini's GPM library], 9176 [with_gpm=$withval], 9177 [with_gpm=maybe]) 9178AC_MSG_RESULT($with_gpm) 9179 9180if test "$with_gpm" != no ; then 9181 AC_CHECK_HEADER(gpm.h,[ 9182 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header]) 9183 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then 9184 CF_VERBOSE(assuming we really have GPM library) 9185 AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library]) 9186 with_gpm=yes 9187 else 9188 AC_CHECK_LIB(gpm,Gpm_Open,[with_gpm=yes],[ 9189 if test "$with_gpm" = maybe; then 9190 AC_MSG_WARN(Cannot link with GPM library) 9191 with_gpm=no 9192 else 9193 AC_MSG_ERROR(Cannot link with GPM library) 9194 fi 9195 ]) 9196 fi 9197 ],[ 9198 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header) 9199 with_gpm=no 9200 ]) 9201fi 9202]) 9203dnl --------------------------------------------------------------------------- 9204dnl CF_WITH_LIBTOOL version: 36 updated: 2021/01/01 13:31:04 9205dnl --------------- 9206dnl Provide a configure option to incorporate libtool. Define several useful 9207dnl symbols for the makefile rules. 9208dnl 9209dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses 9210dnl macros from libtool.m4 which is in the aclocal directory of automake. 9211dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro. 9212dnl But that still does not work properly since the macro is expanded outside 9213dnl the CF_WITH_LIBTOOL macro: 9214dnl 9215dnl #!/bin/sh 9216dnl ACLOCAL=`aclocal --print-ac-dir` 9217dnl if test -z "$ACLOCAL" ; then 9218dnl echo cannot find aclocal directory 9219dnl exit 1 9220dnl elif test ! -f $ACLOCAL/libtool.m4 ; then 9221dnl echo cannot find libtool.m4 file 9222dnl exit 1 9223dnl fi 9224dnl 9225dnl LOCAL=aclocal.m4 9226dnl ORIG=aclocal.m4.orig 9227dnl 9228dnl trap "mv $ORIG $LOCAL" 0 1 2 3 15 9229dnl rm -f $ORIG 9230dnl mv $LOCAL $ORIG 9231dnl 9232dnl # sed the LIBTOOL= assignment to omit the current directory? 9233dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL 9234dnl cat $ORIG >>$LOCAL 9235dnl 9236dnl autoconf-257 $* 9237dnl 9238AC_DEFUN([CF_WITH_LIBTOOL], 9239[ 9240AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION]) 9241ifdef([AC_PROG_LIBTOOL],,[ 9242LIBTOOL= 9243]) 9244# common library maintenance symbols that are convenient for libtool scripts: 9245LIB_CREATE='${AR} -cr' 9246LIB_OBJECT='${OBJECTS}' 9247LIB_SUFFIX=.a 9248LIB_PREP="$RANLIB" 9249 9250# symbols used to prop libtool up to enable it to determine what it should be 9251# doing: 9252LIB_CLEAN= 9253LIB_COMPILE= 9254LIB_LINK='${CC}' 9255LIB_INSTALL= 9256LIB_UNINSTALL= 9257 9258AC_MSG_CHECKING(if you want to build libraries with libtool) 9259AC_ARG_WITH(libtool, 9260 [ --with-libtool generate libraries with libtool], 9261 [with_libtool=$withval], 9262 [with_libtool=no]) 9263AC_MSG_RESULT($with_libtool) 9264if test "$with_libtool" != "no"; then 9265ifdef([AC_PROG_LIBTOOL],[ 9266 # missing_content_AC_PROG_LIBTOOL{{ 9267 AC_PROG_LIBTOOL 9268 # missing_content_AC_PROG_LIBTOOL}} 9269],[ 9270 if test "$with_libtool" != "yes" ; then 9271 CF_PATH_SYNTAX(with_libtool) 9272 LIBTOOL=$with_libtool 9273 else 9274 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none) 9275 CF_LIBTOOL_VERSION 9276 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool 9277 then 9278 CF_FORGET_TOOL(LIBTOOL) 9279 AC_CHECK_TOOLS(LIBTOOL,[glibtool],none) 9280 CF_LIBTOOL_VERSION 9281 fi 9282 fi 9283 if test -z "$LIBTOOL" ; then 9284 AC_MSG_ERROR(Cannot find libtool) 9285 fi 9286])dnl 9287 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o' 9288 LIB_OBJECT='${OBJECTS:.o=.lo}' 9289 LIB_SUFFIX=.la 9290 LIB_CLEAN='${LIBTOOL} --mode=clean' 9291 LIB_COMPILE='${LIBTOOL} --mode=compile' 9292 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}' 9293 LIB_INSTALL='${LIBTOOL} --mode=install' 9294 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall' 9295 LIB_PREP=: 9296 9297 CF_CHECK_LIBTOOL_VERSION 9298 9299 # special hack to add -no-undefined (which libtool should do for itself) 9300 LT_UNDEF= 9301 case "$cf_cv_system_name" in 9302 (cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]]) 9303 LT_UNDEF=-no-undefined 9304 ;; 9305 esac 9306 AC_SUBST([LT_UNDEF]) 9307 9308 # special hack to add --tag option for C++ compiler 9309 case "$cf_cv_libtool_version" in 9310 (1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) 9311 LIBTOOL_CXX="$LIBTOOL --tag=CXX" 9312 LIBTOOL="$LIBTOOL --tag=CC" 9313 ;; 9314 (*) 9315 LIBTOOL_CXX="$LIBTOOL" 9316 ;; 9317 esac 9318else 9319 LIBTOOL="" 9320 LIBTOOL_CXX="" 9321fi 9322 9323test -z "$LIBTOOL" && ECHO_LT= 9324 9325AC_SUBST(LIBTOOL) 9326AC_SUBST(LIBTOOL_CXX) 9327AC_SUBST(LIBTOOL_OPTS) 9328 9329AC_SUBST(LIB_CREATE) 9330AC_SUBST(LIB_OBJECT) 9331AC_SUBST(LIB_SUFFIX) 9332AC_SUBST(LIB_PREP) 9333 9334AC_SUBST(LIB_CLEAN) 9335AC_SUBST(LIB_COMPILE) 9336AC_SUBST(LIB_LINK) 9337AC_SUBST(LIB_INSTALL) 9338AC_SUBST(LIB_UNINSTALL) 9339 9340])dnl 9341dnl --------------------------------------------------------------------------- 9342dnl CF_WITH_LIBTOOL_OPTS version: 6 updated: 2023/11/22 20:48:30 9343dnl -------------------- 9344dnl Allow user to pass additional libtool options into the library creation 9345dnl and link steps. The main use for this is to do something like 9346dnl ./configure --with-libtool-opts=-static 9347dnl to get the same behavior as automake-flavored 9348dnl ./configure --enable-static 9349AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[ 9350AC_MSG_CHECKING(for additional libtool options) 9351AC_ARG_WITH(libtool-opts, 9352 [[ --with-libtool-opts[=XXX] give libtool additional options XXX]], 9353 [with_libtool_opts=$withval], 9354 [with_libtool_opts=no]) 9355AC_MSG_RESULT($with_libtool_opts) 9356 9357case .$with_libtool_opts in 9358(.yes|.no|.) 9359 ;; 9360(*) 9361 LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts" 9362 ;; 9363esac 9364 9365AC_SUBST(LIBTOOL_OPTS) 9366])dnl 9367dnl --------------------------------------------------------------------------- 9368dnl CF_WITH_LIB_BASENAME version: 2 updated: 2023/11/22 20:48:30 9369dnl -------------------- 9370dnl Allow for overriding the basename of a library, i.e., the part to which 9371dnl prefixes/suffixes are attached. 9372dnl 9373dnl $1 = variable to set 9374dnl $2 = option name 9375dnl $3 = default basename for library, if omitted use $2 9376AC_DEFUN([CF_WITH_LIB_BASENAME], 9377[ 9378AC_MSG_CHECKING(for desired basename for $2 library) 9379AC_ARG_WITH($2-libname, 9380 [[ --with-$2-libname[=XXX] override ifelse($3,,$2,$3) basename of library]], 9381 [with_lib_basename=$withval], 9382 [with_lib_basename=ifelse($3,,$2,$3)]) 9383$1="$with_lib_basename" 9384 9385case "x[$]$1" in 9386(x|xno|xnone|xyes) 9387 $1=ifelse($3,,$2,$3) 9388 ;; 9389(*) 9390 ;; 9391esac 9392 9393AC_MSG_RESULT([$]$1) 9394AC_SUBST($1) 9395])dnl 9396dnl --------------------------------------------------------------------------- 9397dnl CF_WITH_LIB_PREFIX version: 2 updated: 2021/01/01 16:53:59 9398dnl ------------------ 9399dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no 9400dnl "lib" prefix, e.g., because it used the dll naming convention. 9401dnl 9402dnl $1 = variable to set 9403AC_DEFUN([CF_WITH_LIB_PREFIX], 9404[ 9405AC_MSG_CHECKING(if you want to have a library-prefix) 9406AC_ARG_WITH(lib-prefix, 9407 [ --with-lib-prefix override library-prefix], 9408 [with_lib_prefix=$withval], 9409 [with_lib_prefix=auto]) 9410AC_MSG_RESULT($with_lib_prefix) 9411 9412if test "$with_lib_prefix" = auto 9413then 9414 CF_LIB_PREFIX($1) 9415elif test "$with_lib_prefix" = no 9416then 9417 LIB_PREFIX= 9418else 9419 LIB_PREFIX=$with_lib_prefix 9420fi 9421])dnl 9422dnl --------------------------------------------------------------------------- 9423dnl CF_WITH_PATH version: 12 updated: 2021/09/04 06:35:04 9424dnl ------------ 9425dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just 9426dnl defaulting to yes/no. 9427dnl 9428dnl $1 = option name 9429dnl $2 = help-text 9430dnl $3 = environment variable to set 9431dnl $4 = default value, shown in the help-message, must be a constant 9432dnl $5 = default value, if it is an expression & cannot be in the help-message 9433dnl 9434AC_DEFUN([CF_WITH_PATH], 9435[AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),, 9436ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl 9437if ifelse([$5],,true,[test -n "$5"]) ; then 9438CF_PATH_SYNTAX(withval) 9439fi 9440eval $3="$withval" 9441AC_SUBST($3)dnl 9442])dnl 9443dnl --------------------------------------------------------------------------- 9444dnl CF_WITH_PATHLIST version: 13 updated: 2021/09/04 06:35:04 9445dnl ---------------- 9446dnl Process an option specifying a list of colon-separated paths. 9447dnl 9448dnl $1 = option name 9449dnl $2 = help-text 9450dnl $3 = environment variable to set 9451dnl $4 = default value, shown in the help-message, must be a constant 9452dnl $5 = default value, if it is an expression & cannot be in the help-message 9453dnl $6 = flag to tell if we want to define or substitute 9454dnl 9455AC_DEFUN([CF_WITH_PATHLIST],[ 9456AC_REQUIRE([CF_PATHSEP]) 9457AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, 9458ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl 9459 9460IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}" 9461cf_dst_path= 9462for cf_src_path in $withval 9463do 9464 CF_PATH_SYNTAX(cf_src_path) 9465 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR" 9466 cf_dst_path="${cf_dst_path}${cf_src_path}" 9467done 9468IFS="$ac_save_ifs" 9469 9470ifelse($6,define,[ 9471# Strip single quotes from the value, e.g., when it was supplied as a literal 9472# for $4 or $5. 9473case "$cf_dst_path" in 9474(\'*) 9475 cf_dst_path="`echo "$cf_dst_path" |sed -e s/\'// -e s/\'\$//`" 9476 ;; 9477esac 9478cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'` 9479]) 9480 9481# This may use the prefix/exec_prefix symbols which will only yield "NONE" 9482# so we have to check/work around. We do prefer the result of "eval"... 9483eval cf_dst_eval="$cf_dst_path" 9484case "x$cf_dst_eval" in 9485(xNONE*) 9486 $3=$cf_dst_path 9487 ;; 9488(*) 9489 $3="$cf_dst_eval" 9490 ;; 9491esac 9492AC_SUBST($3)dnl 9493 9494])dnl 9495dnl --------------------------------------------------------------------------- 9496dnl CF_WITH_PATH_PROG version: 1 updated: 2019/06/30 19:44:43 9497dnl ----------------- 9498dnl Check for a given program, like CF_PATH_PROG, but allow override using a 9499dnl "--with-xxx" option. 9500dnl 9501dnl Parameters: 9502dnl $1 = environment variable to set/update 9503dnl $2 = program name 9504dnl $3 = help-text 9505dnl $4 = $PATH 9506AC_DEFUN([CF_WITH_PATH_PROG],[ 9507AC_ARG_WITH($2-path, 9508 [ --with-$2-path=XXX specify path of $2 ifelse($3,,,$3)], 9509 [AC_MSG_CHECKING(for $2 program ifelse($3,,,$3)) 9510 $1=$withval 9511 AC_MSG_RESULT([$]$1) 9512 CF_PATH_SYNTAX($1) 9513 ], 9514 [CF_PATH_PROG($1,$2,,ifelse($4,,,$4)) 9515 if test -z "[$]$1" 9516 then 9517 AC_MSG_WARN(no $2 program found ifelse($3,,,$3)) 9518 fi 9519 ]) 9520]) 9521dnl --------------------------------------------------------------------------- 9522dnl CF_WITH_PCRE2 version: 6 updated: 2021/08/11 20:35:34 9523dnl ------------- 9524dnl Add PCRE2 (Perl-compatible regular expressions v2) to the build if it is 9525dnl available and the user requests it. Assume the application will otherwise 9526dnl use the POSIX interface. 9527dnl 9528dnl TODO allow $withval to specify package location 9529AC_DEFUN([CF_WITH_PCRE2], 9530[ 9531AC_REQUIRE([CF_PKG_CONFIG]) 9532 9533AC_MSG_CHECKING(if you want to use PCRE2 for regular-expressions) 9534AC_ARG_WITH(pcre2, 9535 [ --with-pcre2 use PCRE2 for regular-expressions]) 9536test -z "$with_pcre2" && with_pcre2=no 9537AC_MSG_RESULT($with_pcre2) 9538 9539if test "x$with_pcre2" != xno ; then 9540 cf_with_pcre2_ok=no 9541 for cf_with_pcre2 in libpcre2 libpcre2-posix libpcre 9542 do 9543 CF_TRY_PKG_CONFIG($cf_with_pcre2,[cf_with_pcre2_ok=yes; break]) 9544 done 9545 cf_with_pcre2_ok=yes || AC_MSG_ERROR(Cannot find PCRE2 library) 9546 9547 AC_DEFINE(HAVE_LIB_PCRE2,1,[Define to 1 if we can/should compile with the PCRE2 library]) 9548 9549 # if pkgconfig gave no results, look for the libraries directly 9550 case "$LIBS" in 9551 (*pcre2-posix*|*pcreposix*) 9552 ;; 9553 (*) 9554 AC_CHECK_LIB(pcre2-posix,regcomp,[ 9555 CF_ADD_LIB(pcre2-posix)], 9556 [AC_CHECK_LIB(pcreposix,regcomp,[ 9557 CF_ADD_LIB(pcreposix) 9558 ],[AC_MSG_ERROR(Cannot find PCRE2 POSIX library)])]) 9559 ;; 9560 esac 9561 9562 # either way, check for the library header files 9563 AC_CHECK_HEADERS(pcre2posix.h pcreposix.h) 9564 AC_CHECK_FUNCS(PCRE2regcomp) 9565fi 9566])dnl 9567dnl --------------------------------------------------------------------------- 9568dnl CF_WITH_PKG_CONFIG_LIBDIR version: 23 updated: 2023/11/22 20:48:30 9569dnl ------------------------- 9570dnl Allow the choice of the pkg-config library directory to be overridden. 9571dnl 9572dnl pkg-config uses a search-list built from these colon-separated lists of 9573dnl directories: 9574dnl a) $PKG_CONFIG_PATH (tested first, added if set) 9575dnl b) $PKG_CONFIG_LIBDIR (tested second, added if set) 9576dnl c) builtin-list (added if $PKG_CONFIG_LIBDIR is not set) 9577dnl 9578dnl pkgconf (used with some systems such as FreeBSD in place of pkg-config) 9579dnl optionally ignores $PKG_CONFIG_LIBDIR. Very old versions of pkg-config, 9580dnl e.g., Solaris 10 also do not recognize $PKG_CONFIG_LIBDIR. 9581AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[ 9582 9583case "$PKG_CONFIG" in 9584(no|none|yes) 9585 AC_MSG_CHECKING(for pkg-config library directory) 9586 ;; 9587(*) 9588 AC_MSG_CHECKING(for $PKG_CONFIG library directory) 9589 ;; 9590esac 9591 9592# if $PKG_CONFIG_LIBDIR is set, try to use that 9593if test -n "$PKG_CONFIG_PATH"; then 9594 cf_search_path=`echo "$PKG_CONFIG_PATH" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'` 9595elif test -n "$PKG_CONFIG_LIBDIR"; then 9596 cf_search_path=`echo "$PKG_CONFIG_LIBDIR" | sed -e 's/:/ /g' -e 's,^[[ ]]*,,' -e 's,[[ ]]*$,,'` 9597else 9598 cf_search_path=auto 9599fi 9600 9601# if the option is used, let that override. otherwise default to "libdir" 9602AC_ARG_WITH(pkg-config-libdir, 9603 [[ --with-pkg-config-libdir[=XXX] use given directory for installing pc-files]], 9604 [cf_search_path=$withval], 9605 [test "x$PKG_CONFIG" != xnone && test -z "$cf_search_path" && cf_search_path=libdir]) 9606 9607case "x$cf_search_path" in 9608(xlibdir) 9609 PKG_CONFIG_LIBDIR='${libdir}/pkgconfig' 9610 AC_MSG_RESULT($PKG_CONFIG_LIBDIR) 9611 cf_search_path= 9612 ;; 9613(x) 9614 ;; 9615(x/*\ *) 9616 PKG_CONFIG_LIBDIR= 9617 ;; 9618(x/*) 9619 PKG_CONFIG_LIBDIR="$cf_search_path" 9620 AC_MSG_RESULT($PKG_CONFIG_LIBDIR) 9621 cf_search_path= 9622 ;; 9623(xyes|xauto) 9624 AC_MSG_RESULT(auto) 9625 cf_search_path= 9626 # Look for the library directory using the same prefix as the executable 9627 AC_MSG_CHECKING(for search-list) 9628 if test "x$PKG_CONFIG" != xnone 9629 then 9630 # works for pkg-config since version 0.24 (2009) 9631 # works for pkgconf since version 0.8.3 (2012) 9632 for cf_pkg_program in \ 9633 `echo "$PKG_CONFIG" | sed -e 's,^.*/,,'` \ 9634 pkg-config \ 9635 pkgconf 9636 do 9637 cf_search_path=`"$PKG_CONFIG" --variable=pc_path "$cf_pkg_program" 2>/dev/null | tr : ' '` 9638 test -n "$cf_search_path" && break 9639 done 9640 9641 # works for pkg-config since import in 2005 of original 2001 HP code. 9642 test -z "$cf_search_path" && \ 9643 cf_search_path=` 9644 "$PKG_CONFIG" --debug --exists no-such-package 2>&1 | $AWK "\ 9645/^Scanning directory (#[1-9][0-9]* )?'.*'$/{ \ 9646 sub(\"^[[^']]*'\",\"\"); \ 9647 sub(\"'.*\",\"\"); \ 9648 printf \" %s\", \\[$]0; } \ 9649{ next; } \ 9650"` 9651 fi 9652 9653 AC_MSG_RESULT($cf_search_path) 9654 ;; 9655(*) 9656 AC_MSG_ERROR(Unexpected option value: $cf_search_path) 9657 ;; 9658esac 9659 9660if test -n "$cf_search_path" 9661then 9662 AC_MSG_CHECKING(for first directory) 9663 cf_pkg_config_path=none 9664 for cf_config in $cf_search_path 9665 do 9666 if test -d "$cf_config" 9667 then 9668 cf_pkg_config_path=$cf_config 9669 break 9670 fi 9671 done 9672 AC_MSG_RESULT($cf_pkg_config_path) 9673 9674 if test "x$cf_pkg_config_path" != xnone ; then 9675 # limit this to the first directory found 9676 PKG_CONFIG_LIBDIR="$cf_pkg_config_path" 9677 fi 9678 9679 if test -z "$PKG_CONFIG_LIBDIR" && test -n "$cf_search_path" 9680 then 9681 AC_MSG_CHECKING(for workaround) 9682 if test "$prefix" = "NONE" ; then 9683 cf_prefix="$ac_default_prefix" 9684 else 9685 cf_prefix="$prefix" 9686 fi 9687 eval cf_libdir=$libdir 9688 cf_libdir=`echo "$cf_libdir" | sed -e "s,^NONE,$cf_prefix,"` 9689 cf_backup= 9690 for cf_config in $cf_search_path 9691 do 9692 case $cf_config in 9693 $cf_libdir/pkgconfig) 9694 PKG_CONFIG_LIBDIR=$cf_libdir/pkgconfig 9695 break 9696 ;; 9697 *) 9698 test -z "$cf_backup" && cf_backup=$cf_config 9699 ;; 9700 esac 9701 done 9702 test -z "$PKG_CONFIG_LIBDIR" && PKG_CONFIG_LIBDIR=$cf_backup 9703 AC_MSG_RESULT($PKG_CONFIG_LIBDIR) 9704 fi 9705fi 9706 9707AC_SUBST(PKG_CONFIG_LIBDIR) 9708])dnl 9709dnl --------------------------------------------------------------------------- 9710dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57 9711dnl --------------- 9712dnl Check for POSIX thread library. 9713AC_DEFUN([CF_WITH_PTHREAD], 9714[ 9715AC_MSG_CHECKING(if you want to link with the pthread library) 9716AC_ARG_WITH(pthread, 9717 [ --with-pthread use POSIX thread library], 9718 [with_pthread=$withval], 9719 [with_pthread=no]) 9720AC_MSG_RESULT($with_pthread) 9721 9722if test "$with_pthread" != no ; then 9723 AC_CHECK_HEADER(pthread.h,[ 9724 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header]) 9725 9726 for cf_lib_pthread in pthread c_r 9727 do 9728 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library) 9729 cf_save_LIBS="$LIBS" 9730 CF_ADD_LIB($cf_lib_pthread) 9731 AC_TRY_LINK([ 9732#include <pthread.h> 9733],[ 9734 int rc = pthread_create(0,0,0,0); 9735 int r2 = pthread_mutexattr_settype(0, 0); 9736],[with_pthread=yes],[with_pthread=no]) 9737 LIBS="$cf_save_LIBS" 9738 AC_MSG_RESULT($with_pthread) 9739 test "$with_pthread" = yes && break 9740 done 9741 9742 if test "$with_pthread" = yes ; then 9743 CF_ADD_LIB($cf_lib_pthread) 9744 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library]) 9745 else 9746 AC_MSG_ERROR(Cannot link with pthread library) 9747 fi 9748 ]) 9749fi 9750]) 9751dnl --------------------------------------------------------------------------- 9752dnl CF_WITH_REL_VERSION version: 2 updated: 2023/05/06 18:18:18 9753dnl ------------------- 9754dnl Allow library's release-version to be overridden. Generally this happens when a 9755dnl packager has incremented the release-version past that used in the original package, 9756dnl and wishes to keep doing this. 9757dnl 9758dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR 9759dnl and {package}_MINOR symbols 9760dnl symbol. 9761AC_DEFUN([CF_WITH_REL_VERSION],[ 9762test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0 9763AC_ARG_WITH(rel-version, 9764[ --with-rel-version=XXX override derived release version], 9765[AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval) 9766 cf_cv_rel_version=$withval]) 9767ifelse($1,,[ 9768 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version) 9769],[ 9770 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'` 9771 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'` 9772 test -n "$1_MINOR" || $1_MINOR=0 9773 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version) 9774 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version) 9775]) 9776])dnl 9777dnl --------------------------------------------------------------------------- 9778dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13 9779dnl ---------------- 9780dnl If we can compile with sysmouse, make it available unless it is not wanted. 9781AC_DEFUN([CF_WITH_SYSMOUSE],[ 9782# not everyone has "test -c" 9783if test -c /dev/sysmouse 2>/dev/null ; then 9784AC_MSG_CHECKING(if you want to use sysmouse) 9785AC_ARG_WITH(sysmouse, 9786 [ --with-sysmouse use sysmouse (FreeBSD console)], 9787 [cf_with_sysmouse=$withval], 9788 [cf_with_sysmouse=maybe]) 9789 if test "$cf_with_sysmouse" != no ; then 9790 AC_TRY_COMPILE([ 9791#include <osreldate.h> 9792#if (__FreeBSD_version >= 400017) 9793#include <sys/consio.h> 9794#include <sys/fbio.h> 9795#else 9796#include <machine/console.h> 9797#endif 9798],[ 9799 struct mouse_info the_mouse; 9800 ioctl(0, CONS_MOUSECTL, &the_mouse); 9801],[cf_with_sysmouse=yes],[cf_with_sysmouse=no]) 9802 fi 9803AC_MSG_RESULT($cf_with_sysmouse) 9804test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface]) 9805fi 9806])dnl 9807dnl --------------------------------------------------------------------------- 9808dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12 9809dnl --------------- 9810dnl For testing, override the derived host system-type which is used to decide 9811dnl things such as the linker commands used to build shared libraries. This is 9812dnl normally chosen automatically based on the type of system which you are 9813dnl building on. We use it for testing the configure script. 9814dnl 9815dnl This is different from the --host option: it is used only for testing parts 9816dnl of the configure script which would not be reachable with --host since that 9817dnl relies on the build environment being real, rather than mocked up. 9818AC_DEFUN([CF_WITH_SYSTYPE],[ 9819CF_CHECK_CACHE([AC_CANONICAL_SYSTEM]) 9820AC_ARG_WITH(system-type, 9821 [ --with-system-type=XXX test: override derived host system-type], 9822[AC_MSG_WARN(overriding system type to $withval) 9823 cf_cv_system_name=$withval 9824 host_os=$withval 9825]) 9826])dnl 9827dnl --------------------------------------------------------------------------- 9828dnl CF_WITH_TYPE version: 2 updated: 2023/11/25 16:11:47 9829dnl ------------ 9830dnl Accept a TYPE for substitution: 9831dnl $1 = name of type 9832dnl $2 = help/usage message 9833dnl $3 = symbol to set 9834dnl $4 = default value 9835AC_DEFUN([CF_WITH_TYPE],[ 9836AC_MSG_CHECKING(for type of $1) 9837AC_ARG_WITH([$1], [$2], 9838 [$3="$withval"], 9839 [$3=$4]) 9840AC_MSG_RESULT([$]$3) 9841case x[$]$3 in 9842(x|xyes|xno) 9843 AC_MSG_ERROR(expected a type name for $1) 9844 ;; 9845esac 9846AC_SUBST($3) 9847])dnl 9848dnl --------------------------------------------------------------------------- 9849dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21 9850dnl ---------------- 9851AC_DEFUN([CF_WITH_VALGRIND],[ 9852CF_NO_LEAKS_OPTION(valgrind, 9853 [ --with-valgrind test: use valgrind], 9854 [USE_VALGRIND]) 9855])dnl 9856dnl --------------------------------------------------------------------------- 9857dnl CF_WITH_VERSIONED_SYMS version: 13 updated: 2023/12/03 09:24:04 9858dnl ---------------------- 9859dnl Use this when building shared library with ELF, to markup symbols with the 9860dnl version identifier from the given input file. Generally that identifier is 9861dnl the same as the SONAME at which the symbol was first introduced. 9862dnl 9863dnl $1 = basename of the ".map" file (default $PACKAGE) 9864AC_DEFUN([CF_WITH_VERSIONED_SYMS], 9865[AC_REQUIRE([AC_PROG_FGREP])dnl 9866AC_REQUIRE([AC_PROG_EGREP])dnl 9867 9868AC_MSG_CHECKING(if versioned-symbols file should be used) 9869AC_ARG_WITH(versioned-syms, 9870 [[ --with-versioned-syms[=MAP-FILE] version ELF shared library symbols per MAP-FILE]], 9871 [with_versioned_syms=$withval], 9872 [with_versioned_syms=no]) 9873case "x$with_versioned_syms" in 9874(xyes) 9875 with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map' 9876 AC_SUBST(PACKAGE) 9877 ;; 9878(xno) 9879 ;; 9880(x/*) 9881 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms) 9882 ;; 9883(*) 9884 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms) 9885 with_versioned_syms=`pwd`/"$with_versioned_syms" 9886 ;; 9887esac 9888AC_MSG_RESULT($with_versioned_syms) 9889 9890RESULTING_SYMS= 9891VERSIONED_SYMS= 9892WILDCARD_SYMS= 9893 9894if test "x$with_versioned_syms" != xno 9895then 9896 RESULTING_SYMS=$with_versioned_syms 9897 case "x$MK_SHARED_LIB" in 9898 (*-Wl,*) 9899 VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}" 9900 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"` 9901 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 9902 ;; 9903 (*-dy\ *) 9904 VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}" 9905 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"` 9906 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 9907 ;; 9908 (*) 9909 AC_MSG_WARN(this system does not support versioned-symbols) 9910 ;; 9911 esac 9912 9913 # Linux ld can selectively override scope, e.g., of symbols beginning with 9914 # "_" by first declaring some as global, and then using a wildcard to 9915 # declare the others as local. Some other loaders cannot do this. Check 9916 # by constructing a (very) simple shared library and inspecting its 9917 # symbols. 9918 if test "x$VERSIONED_SYMS" != "x" 9919 then 9920 AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols) 9921 WILDCARD_SYMS=no 9922 9923 # make sources 9924 rm -f conftest.* 9925 9926 cat >conftest.ver <<EOF 9927module_1.0 { 9928global: 9929 globalf1; 9930local: 9931 localf1; 9932}; 9933module_2.0 { 9934global: 9935 globalf2; 9936local: 9937 localf2; 9938 _*; 9939} module_1.0; 9940submodule_1.0 { 9941global: 9942 subglobalf1; 9943 _ismissing; 9944local: 9945 sublocalf1; 9946}; 9947submodule_2.0 { 9948global: 9949 subglobalf2; 9950local: 9951 sublocalf2; 9952 _*; 9953} submodule_1.0; 9954EOF 9955 cat >conftest.$ac_ext <<EOF 9956#line __oline__ "configure" 9957extern int _ismissing(void); int _ismissing(void) { return 1; } 9958extern int _localf1(void); int _localf1(void) { return 1; } 9959extern int _localf2(void); int _localf2(void) { return 2; } 9960extern int globalf1(void); int globalf1(void) { return 1; } 9961extern int globalf2(void); int globalf2(void) { return 2; } 9962extern int _sublocalf1(void); int _sublocalf1(void) { return 1; } 9963extern int _sublocalf2(void); int _sublocalf2(void) { return 2; } 9964extern int subglobalf1(void); int subglobalf1(void) { return 1; } 9965extern int subglobalf2(void); int subglobalf2(void) { return 2; } 9966EOF 9967 cat >conftest.mk <<EOF 9968CC=${CC} 9969CFLAGS=${CFLAGS} 9970CPPFLAGS=${CPPFLAGS} 9971LDFLAGS=${LDFLAGS} 9972LIBS=${LIBS} 9973VERSIONED_SYMS=${VERSIONED_SYMS} 9974RESULTING_SYMS=conftest.ver 9975MK_SHARED_LIB=${MK_SHARED_LIB} 9976conftest.so: conftest.$ac_cv_objext 9977 \$(MK_SHARED_LIB) conftest.$ac_cv_objext 9978EOF 9979 9980 # compile source, make library 9981 if make -f conftest.mk 2>&AC_FD_CC >/dev/null 9982 then 9983 # test for missing symbol in either Data or Text section 9984 cf_missing="`nm -P conftest.so 2>&AC_FD_CC |${FGREP-fgrep} _ismissing | ${EGREP-egrep} '[[ ]][[DT]][[ ]]'`" 9985 test -n "$cf_missing" && WILDCARD_SYMS=yes 9986 fi 9987 AC_MSG_RESULT($WILDCARD_SYMS) 9988 rm -f conftest.* 9989 fi 9990fi 9991AC_SUBST(RESULTING_SYMS) 9992AC_SUBST(VERSIONED_SYMS) 9993AC_SUBST(WILDCARD_SYMS) 9994])dnl 9995dnl --------------------------------------------------------------------------- 9996dnl CF_WITH_X11_RGB version: 3 updated: 2023/10/28 11:59:01 9997dnl --------------- 9998dnl Handle configure option "--with-x11-rgb", setting these shell 9999dnl variables: 10000dnl 10001dnl $RGB_PATH is the option value, used for finding the X11 rgb file. 10002dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given. 10003dnl 10004dnl Most Linux's use this: 10005dnl /usr/share/X11/rgb.txt 10006dnl Debian uses this: 10007dnl /etc/X11/rgb.txt 10008dnl DragonFlyBSD ports uses this: 10009dnl /usr/pkg/lib/X11/rgb.txt 10010dnl FreeBSD ports use these: 10011dnl /usr/local/lib/X11/rgb.txt 10012dnl /usr/local/share/X11/rgb.txt 10013dnl Mandriva has these: 10014dnl /usr/lib/X11/rgb.txt 10015dnl /usr/lib64/X11/rgb.txt 10016dnl NetBSD has these 10017dnl /usr/X11R7/lib/X11/rgb.txt 10018dnl OpenSolaris uses 10019dnl 32-bit: 10020dnl /usr/X11/etc/X11/rgb.txt 10021dnl /usr/X11/share/X11/rgb.txt 10022dnl /usr/X11/lib/X11/rgb.txt 10023dnl OSX uses 10024dnl /opt/local/share/X11/rgb.txt (MacPorts) 10025dnl /opt/X11/share/X11/rgb.txt (non-ports) 10026dnl 64-bit: 10027dnl /usr/X11/etc/X11/rgb.txt 10028dnl /usr/X11/share/X11/rgb.txt (perhaps) 10029dnl /usr/X11/lib/amd64/X11/rgb.txt 10030dnl Solaris10 uses (in this order): 10031dnl /usr/openwin/lib/X11/rgb.txt 10032dnl /usr/X11/lib/X11/rgb.txt 10033AC_DEFUN([CF_WITH_X11_RGB],[ 10034AC_MSG_CHECKING(for X11 rgb file) 10035AC_ARG_WITH(x11-rgb, 10036 [ --with-x11-rgb=FILE obtain X11 color definitions from FILE (default: EPREFIX/lib/X11/rgb.txt)], 10037 [RGB_PATH=$withval], 10038 [RGB_PATH=auto]) 10039 10040if test "x[$]RGB_PATH" = xauto 10041then 10042 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt' 10043 for cf_path in \ 10044 /opt/local/share/X11/rgb.txt \ 10045 /opt/X11/share/X11/rgb.txt \ 10046 /usr/share/X11/rgb.txt \ 10047 /usr/X11/share/X11/rgb.txt \ 10048 /usr/X11/lib/X11/rgb.txt \ 10049 /usr/lib/X11/rgb.txt \ 10050 /etc/X11/rgb.txt \ 10051 /usr/pkg/lib/X11/rgb.txt \ 10052 /usr/X11R7/lib/X11/rgb.txt \ 10053 /usr/X11R6/lib/X11/rgb.txt \ 10054 /usr/X11R5/lib/X11/rgb.txt \ 10055 /usr/X11R4/lib/X11/rgb.txt \ 10056 /usr/local/lib/X11/rgb.txt \ 10057 /usr/local/share/X11/rgb.txt \ 10058 /usr/lib64/X11/rgb.txt 10059 do 10060 if test -f "$cf_path" ; then 10061 RGB_PATH="$cf_path" 10062 break 10063 fi 10064 done 10065else 10066 cf_path=$RGB_PATH 10067 CF_PATH_SYNTAX(cf_path) 10068fi 10069 10070AC_MSG_RESULT($RGB_PATH) 10071AC_SUBST(RGB_PATH) 10072AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt]) 10073 10074no_x11_rgb= 10075if test "$RGB_PATH" = no 10076then 10077 no_x11_rgb="#" 10078fi 10079AC_SUBST(no_x11_rgb) 10080])dnl 10081dnl --------------------------------------------------------------------------- 10082dnl CF_XOPEN_SOURCE version: 67 updated: 2023/09/06 18:55:27 10083dnl --------------- 10084dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, 10085dnl or adapt to the vendor's definitions to get equivalent functionality, 10086dnl without losing the common non-POSIX features. 10087dnl 10088dnl Parameters: 10089dnl $1 is the nominal value for _XOPEN_SOURCE 10090dnl $2 is the nominal value for _POSIX_C_SOURCE 10091dnl 10092dnl The default case prefers _XOPEN_SOURCE over _POSIX_C_SOURCE if the 10093dnl implementation predefines it, because X/Open and most implementations agree 10094dnl that the latter is a legacy or "aligned" value. 10095dnl 10096dnl Because _XOPEN_SOURCE is preferred, if defining _POSIX_C_SOURCE turns 10097dnl that off, then refrain from setting _POSIX_C_SOURCE explicitly. 10098dnl 10099dnl References: 10100dnl https://pubs.opengroup.org/onlinepubs/007904975/functions/xsh_chap02_02.html 10101dnl https://docs.oracle.com/cd/E19253-01/816-5175/standards-5/index.html 10102dnl https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html 10103AC_DEFUN([CF_XOPEN_SOURCE],[ 10104AC_REQUIRE([AC_CANONICAL_HOST]) 10105AC_REQUIRE([CF_POSIX_VISIBLE]) 10106 10107if test "$cf_cv_posix_visible" = no; then 10108 10109cf_XOPEN_SOURCE=ifelse([$1],,500,[$1]) 10110cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2]) 10111cf_xopen_source= 10112 10113case "$host_os" in 10114(aix[[4-7]]*) 10115 cf_xopen_source="-D_ALL_SOURCE" 10116 ;; 10117(darwin[[0-8]].*) 10118 cf_xopen_source="-D_APPLE_C_SOURCE" 10119 ;; 10120(darwin*) 10121 cf_xopen_source="-D_DARWIN_C_SOURCE" 10122 cf_XOPEN_SOURCE= 10123 ;; 10124(freebsd*|dragonfly*|midnightbsd*) 10125 # 5.x headers associate 10126 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L 10127 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L 10128 cf_POSIX_C_SOURCE=200112L 10129 cf_XOPEN_SOURCE=600 10130 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" 10131 ;; 10132(hpux11*) 10133 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500" 10134 ;; 10135(hpux*) 10136 cf_xopen_source="-D_HPUX_SOURCE" 10137 ;; 10138(irix[[56]].*) 10139 cf_xopen_source="-D_SGI_SOURCE" 10140 cf_XOPEN_SOURCE= 10141 ;; 10142(linux*gnu|linux*gnuabi64|linux*gnuabin32|linux*gnueabi|linux*gnueabihf|linux*gnux32|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin|msys|mingw*|linux*uclibc) 10143 CF_GNU_SOURCE($cf_XOPEN_SOURCE) 10144 ;; 10145(minix*) 10146 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this... 10147 ;; 10148(mirbsd*) 10149 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types 10150 cf_XOPEN_SOURCE= 10151 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) 10152 ;; 10153(netbsd*) 10154 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw 10155 ;; 10156(openbsd[[6-9]]*) 10157 # OpenBSD 6.x has broken locale support, both compile-time and runtime. 10158 # see https://www.mail-archive.com/bugs@openbsd.org/msg13200.html 10159 # Abusing the conformance level is a workaround. 10160 AC_MSG_WARN(this system does not provide usable locale support) 10161 cf_xopen_source="-D_BSD_SOURCE" 10162 cf_XOPEN_SOURCE=700 10163 ;; 10164(openbsd[[4-5]]*) 10165 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw 10166 cf_xopen_source="-D_BSD_SOURCE" 10167 cf_XOPEN_SOURCE=600 10168 ;; 10169(openbsd*) 10170 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw 10171 ;; 10172(osf[[45]]*) 10173 cf_xopen_source="-D_OSF_SOURCE" 10174 ;; 10175(nto-qnx*) 10176 cf_xopen_source="-D_QNX_SOURCE" 10177 ;; 10178(sco*) 10179 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer 10180 ;; 10181(solaris2.*) 10182 cf_xopen_source="-D__EXTENSIONS__" 10183 cf_cv_xopen_source=broken 10184 ;; 10185(sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2) 10186 cf_XOPEN_SOURCE= 10187 cf_POSIX_C_SOURCE= 10188 ;; 10189(*) 10190 CF_TRY_XOPEN_SOURCE 10191 cf_save_xopen_cppflags="$CPPFLAGS" 10192 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) 10193 # Some of these niche implementations use copy/paste, double-check... 10194 if test "$cf_cv_xopen_source" = no ; then 10195 CF_VERBOSE(checking if _POSIX_C_SOURCE interferes with _XOPEN_SOURCE) 10196 AC_TRY_COMPILE(CF__XOPEN_SOURCE_HEAD,CF__XOPEN_SOURCE_BODY,,[ 10197 AC_MSG_WARN(_POSIX_C_SOURCE definition is not usable) 10198 CPPFLAGS="$cf_save_xopen_cppflags"]) 10199 fi 10200 ;; 10201esac 10202 10203if test -n "$cf_xopen_source" ; then 10204 CF_APPEND_CFLAGS($cf_xopen_source,true) 10205fi 10206 10207dnl In anything but the default case, we may have system-specific setting 10208dnl which is still not guaranteed to provide all of the entrypoints that 10209dnl _XOPEN_SOURCE would yield. 10210if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then 10211 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set) 10212 AC_TRY_COMPILE([#include <stdlib.h>],[ 10213#ifndef _XOPEN_SOURCE 10214#error _XOPEN_SOURCE is not defined 10215#endif], 10216 [cf_XOPEN_SOURCE_set=yes], 10217 [cf_XOPEN_SOURCE_set=no]) 10218 AC_MSG_RESULT($cf_XOPEN_SOURCE_set) 10219 if test "$cf_XOPEN_SOURCE_set" = yes 10220 then 10221 AC_TRY_COMPILE([#include <stdlib.h>],[ 10222#if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE 10223#error (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE 10224#endif], 10225 [cf_XOPEN_SOURCE_set_ok=yes], 10226 [cf_XOPEN_SOURCE_set_ok=no]) 10227 if test "$cf_XOPEN_SOURCE_set_ok" = no 10228 then 10229 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested) 10230 fi 10231 else 10232 CF_TRY_XOPEN_SOURCE 10233 fi 10234fi 10235fi # cf_cv_posix_visible 10236]) 10237dnl --------------------------------------------------------------------------- 10238dnl CF__SED_TRIMBLANKS version: 1 updated: 2021/01/02 09:31:20 10239dnl ------------------ 10240dnl Trim something using sed, then trim extra whitespace 10241dnl $1 = extra parameters, e.g., in CF_STRIP_G_OPT 10242define([CF__SED_TRIMBLANKS],[sed ifelse($1,,,[$1] )-e 's%[[ ]]% %g' -e 's% [[ ]]*% %g' -e 's%^ %%' -e 's% [$]%%'])dnl 10243dnl --------------------------------------------------------------------------- 10244dnl CF__XOPEN_SOURCE_BODY version: 2 updated: 2023/02/18 17:41:25 10245dnl --------------------- 10246dnl body of test when test-compiling for _XOPEN_SOURCE check 10247define([CF__XOPEN_SOURCE_BODY], 10248[ 10249#ifndef _XOPEN_SOURCE 10250#error _XOPEN_SOURCE is not defined 10251#endif 10252]) 10253dnl --------------------------------------------------------------------------- 10254dnl CF__XOPEN_SOURCE_HEAD version: 2 updated: 2023/02/18 17:41:25 10255dnl --------------------- 10256dnl headers to include when test-compiling for _XOPEN_SOURCE check 10257define([CF__XOPEN_SOURCE_HEAD], 10258[ 10259$ac_includes_default 10260]) 10261