1dnl*************************************************************************** 2dnl Copyright 2018-2019,2020 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.896 2020/02/08 21:01:07 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: 4 updated: 2015/04/18 08:56:57 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([#include <langinfo.h>], 58 [char* cs = nl_langinfo(CODESET);], 59 am_cv_langinfo_codeset=yes, 60 am_cv_langinfo_codeset=no) 61 ]) 62 if test $am_cv_langinfo_codeset = yes; then 63 AC_DEFINE(HAVE_LANGINFO_CODESET, 1, 64 [Define if you have <langinfo.h> and nl_langinfo(CODESET).]) 65 fi 66])dnl 67dnl --------------------------------------------------------------------------- 68dnl CF_ABI_DEFAULTS version: 2 updated: 2015/06/06 13:49:58 69dnl --------------- 70dnl Provide configure-script defaults for different ncurses ABIs. 71AC_DEFUN([CF_ABI_DEFAULTS],[ 72AC_REQUIRE([CF_NCURSES_WITH_ABI_VERSION]) 73case x$cf_cv_abi_version in 74(x[[6789]]) 75 cf_dft_ext_colors=yes 76 cf_dft_ext_const=yes 77 cf_dft_ext_mouse=yes 78 cf_dft_ext_putwin=yes 79 cf_dft_ext_spfuncs=yes 80 cf_dft_filter_syms=yes 81 cf_dft_chtype=uint32_t 82 cf_dft_mmask_t=uint32_t 83 cf_dft_interop=yes 84 cf_dft_tparm_arg=intptr_t 85 cf_dft_with_lp64=yes 86 ;; 87(*) 88 cf_dft_ext_colors=no 89 cf_dft_ext_const=no 90 cf_dft_ext_mouse=no 91 cf_dft_ext_putwin=no 92 cf_dft_ext_spfuncs=no 93 cf_dft_filter_syms=no 94 cf_dft_chtype=auto 95 cf_dft_mmask_t=auto 96 cf_dft_interop=no 97 cf_dft_tparm_arg=long 98 cf_dft_with_lp64=no 99 ;; 100esac 101])dnl 102dnl --------------------------------------------------------------------------- 103dnl CF_ACVERSION_CHECK version: 5 updated: 2014/06/04 19:11:49 104dnl ------------------ 105dnl Conditionally generate script according to whether we're using a given autoconf. 106dnl 107dnl $1 = version to compare against 108dnl $2 = code to use if AC_ACVERSION is at least as high as $1. 109dnl $3 = code to use if AC_ACVERSION is older than $1. 110define([CF_ACVERSION_CHECK], 111[ 112ifdef([AC_ACVERSION], ,[ifdef([AC_AUTOCONF_VERSION],[m4_copy([AC_AUTOCONF_VERSION],[AC_ACVERSION])],[m4_copy([m4_PACKAGE_VERSION],[AC_ACVERSION])])])dnl 113ifdef([m4_version_compare], 114[m4_if(m4_version_compare(m4_defn([AC_ACVERSION]), [$1]), -1, [$3], [$2])], 115[CF_ACVERSION_COMPARE( 116AC_PREREQ_CANON(AC_PREREQ_SPLIT([$1])), 117AC_PREREQ_CANON(AC_PREREQ_SPLIT(AC_ACVERSION)), AC_ACVERSION, [$2], [$3])])])dnl 118dnl --------------------------------------------------------------------------- 119dnl CF_ACVERSION_COMPARE version: 3 updated: 2012/10/03 18:39:53 120dnl -------------------- 121dnl CF_ACVERSION_COMPARE(MAJOR1, MINOR1, TERNARY1, 122dnl MAJOR2, MINOR2, TERNARY2, 123dnl PRINTABLE2, not FOUND, FOUND) 124define([CF_ACVERSION_COMPARE], 125[ifelse(builtin([eval], [$2 < $5]), 1, 126[ifelse([$8], , ,[$8])], 127[ifelse([$9], , ,[$9])])])dnl 128dnl --------------------------------------------------------------------------- 129dnl CF_ADA_INCLUDE_DIRS version: 8 updated: 2013/10/14 04:24:07 130dnl ------------------- 131dnl Construct the list of include-options for the C programs in the Ada95 132dnl binding. 133AC_DEFUN([CF_ADA_INCLUDE_DIRS], 134[ 135ACPPFLAGS="-I. -I../include -I../../include $ACPPFLAGS" 136if test "$srcdir" != "."; then 137 ACPPFLAGS="-I\${srcdir}/../../include $ACPPFLAGS" 138fi 139if test "$GCC" != yes; then 140 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 141elif test "$includedir" != "/usr/include"; then 142 if test "$includedir" = '${prefix}/include' ; then 143 if test x$prefix != x/usr ; then 144 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 145 fi 146 else 147 ACPPFLAGS="$ACPPFLAGS -I\${includedir}" 148 fi 149fi 150AC_SUBST(ACPPFLAGS) 151])dnl 152dnl --------------------------------------------------------------------------- 153dnl CF_ADD_ADAFLAGS version: 1 updated: 2010/06/19 15:22:18 154dnl --------------- 155dnl Add to $ADAFLAGS, which is substituted into makefile and scripts. 156AC_DEFUN([CF_ADD_ADAFLAGS],[ 157 ADAFLAGS="$ADAFLAGS $1" 158 AC_SUBST(ADAFLAGS) 159])dnl 160dnl --------------------------------------------------------------------------- 161dnl CF_ADD_CFLAGS version: 13 updated: 2017/02/25 18:57:40 162dnl ------------- 163dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS 164dnl The second parameter if given makes this macro verbose. 165dnl 166dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, 167dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily 168dnl confused by the quotes (which require backslashes to keep them usable). 169AC_DEFUN([CF_ADD_CFLAGS], 170[ 171cf_fix_cppflags=no 172cf_new_cflags= 173cf_new_cppflags= 174cf_new_extra_cppflags= 175 176for cf_add_cflags in $1 177do 178case $cf_fix_cppflags in 179(no) 180 case $cf_add_cflags in 181 (-undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) 182 case $cf_add_cflags in 183 (-D*) 184 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'` 185 186 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \ 187 && test -z "${cf_tst_cflags}" \ 188 && cf_fix_cppflags=yes 189 190 if test $cf_fix_cppflags = yes ; then 191 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 192 continue 193 elif test "${cf_tst_cflags}" = "\"'" ; then 194 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 195 continue 196 fi 197 ;; 198 esac 199 case "$CPPFLAGS" in 200 (*$cf_add_cflags) 201 ;; 202 (*) 203 case $cf_add_cflags in 204 (-D*) 205 cf_tst_cppflags=`echo "x$cf_add_cflags" | sed -e 's/^...//' -e 's/=.*//'` 206 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,$cf_tst_cppflags) 207 ;; 208 esac 209 CF_APPEND_TEXT(cf_new_cppflags,$cf_add_cflags) 210 ;; 211 esac 212 ;; 213 (*) 214 CF_APPEND_TEXT(cf_new_cflags,$cf_add_cflags) 215 ;; 216 esac 217 ;; 218(yes) 219 CF_APPEND_TEXT(cf_new_extra_cppflags,$cf_add_cflags) 220 221 cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'` 222 223 test "x${cf_add_cflags}" != "x${cf_tst_cflags}" \ 224 && test -z "${cf_tst_cflags}" \ 225 && cf_fix_cppflags=no 226 ;; 227esac 228done 229 230if test -n "$cf_new_cflags" ; then 231 ifelse([$2],,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) 232 CF_APPEND_TEXT(CFLAGS,$cf_new_cflags) 233fi 234 235if test -n "$cf_new_cppflags" ; then 236 ifelse([$2],,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) 237 CF_APPEND_TEXT(CPPFLAGS,$cf_new_cppflags) 238fi 239 240if test -n "$cf_new_extra_cppflags" ; then 241 ifelse([$2],,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)]) 242 CF_APPEND_TEXT(EXTRA_CPPFLAGS,$cf_new_extra_cppflags) 243fi 244 245AC_SUBST(EXTRA_CPPFLAGS) 246 247])dnl 248dnl --------------------------------------------------------------------------- 249dnl CF_ADD_INCDIR version: 15 updated: 2018/06/20 20:23:13 250dnl ------------- 251dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's 252dnl redundant. We don't normally need to add -I/usr/local/include for gcc, 253dnl but old versions (and some misinstalled ones) need that. To make things 254dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to 255dnl the include-path). 256AC_DEFUN([CF_ADD_INCDIR], 257[ 258if test -n "$1" ; then 259 for cf_add_incdir in $1 260 do 261 while test $cf_add_incdir != /usr/include 262 do 263 if test -d $cf_add_incdir 264 then 265 cf_have_incdir=no 266 if test -n "$CFLAGS$CPPFLAGS" ; then 267 # a loop is needed to ensure we can add subdirs of existing dirs 268 for cf_test_incdir in $CFLAGS $CPPFLAGS ; do 269 if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then 270 cf_have_incdir=yes; break 271 fi 272 done 273 fi 274 275 if test "$cf_have_incdir" = no ; then 276 if test "$cf_add_incdir" = /usr/local/include ; then 277 if test "$GCC" = yes 278 then 279 cf_save_CPPFLAGS=$CPPFLAGS 280 CF_APPEND_TEXT(CPPFLAGS,-I$cf_add_incdir) 281 AC_TRY_COMPILE([#include <stdio.h>], 282 [printf("Hello")], 283 [], 284 [cf_have_incdir=yes]) 285 CPPFLAGS=$cf_save_CPPFLAGS 286 fi 287 fi 288 fi 289 290 if test "$cf_have_incdir" = no ; then 291 CF_VERBOSE(adding $cf_add_incdir to include-path) 292 ifelse([$2],,CPPFLAGS,[$2])="$ifelse([$2],,CPPFLAGS,[$2]) -I$cf_add_incdir" 293 294 cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` 295 test "$cf_top_incdir" = "$cf_add_incdir" && break 296 cf_add_incdir="$cf_top_incdir" 297 else 298 break 299 fi 300 else 301 break 302 fi 303 done 304 done 305fi 306])dnl 307dnl --------------------------------------------------------------------------- 308dnl CF_ADD_LIB version: 2 updated: 2010/06/02 05:03:05 309dnl ---------- 310dnl Add a library, used to enforce consistency. 311dnl 312dnl $1 = library to add, without the "-l" 313dnl $2 = variable to update (default $LIBS) 314AC_DEFUN([CF_ADD_LIB],[CF_ADD_LIBS(-l$1,ifelse($2,,LIBS,[$2]))])dnl 315dnl --------------------------------------------------------------------------- 316dnl CF_ADD_LIBDIR version: 10 updated: 2015/04/18 08:56:57 317dnl ------------- 318dnl Adds to the library-path 319dnl 320dnl Some machines have trouble with multiple -L options. 321dnl 322dnl $1 is the (list of) directory(s) to add 323dnl $2 is the optional name of the variable to update (default LDFLAGS) 324dnl 325AC_DEFUN([CF_ADD_LIBDIR], 326[ 327if test -n "$1" ; then 328 for cf_add_libdir in $1 329 do 330 if test $cf_add_libdir = /usr/lib ; then 331 : 332 elif test -d $cf_add_libdir 333 then 334 cf_have_libdir=no 335 if test -n "$LDFLAGS$LIBS" ; then 336 # a loop is needed to ensure we can add subdirs of existing dirs 337 for cf_test_libdir in $LDFLAGS $LIBS ; do 338 if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then 339 cf_have_libdir=yes; break 340 fi 341 done 342 fi 343 if test "$cf_have_libdir" = no ; then 344 CF_VERBOSE(adding $cf_add_libdir to library-path) 345 ifelse([$2],,LDFLAGS,[$2])="-L$cf_add_libdir $ifelse([$2],,LDFLAGS,[$2])" 346 fi 347 fi 348 done 349fi 350])dnl 351dnl --------------------------------------------------------------------------- 352dnl CF_ADD_LIBS version: 3 updated: 2019/11/02 16:47:33 353dnl ----------- 354dnl Add one or more libraries, used to enforce consistency. Libraries are 355dnl prepended to an existing list, since their dependencies are assumed to 356dnl already exist in the list. 357dnl 358dnl $1 = libraries to add, with the "-l", etc. 359dnl $2 = variable to update (default $LIBS) 360AC_DEFUN([CF_ADD_LIBS],[ 361cf_add_libs="[$]ifelse($2,,LIBS,[$2])" 362# reverse order 363cf_add_0lib= 364for cf_add_1lib in $1; do cf_add_0lib="$cf_add_1lib $cf_add_0lib"; done 365# filter duplicates 366for cf_add_1lib in $cf_add_0lib; do 367 for cf_add_2lib in $cf_add_libs; do 368 if test "x$cf_add_1lib" = "x$cf_add_2lib"; then 369 cf_add_1lib= 370 break 371 fi 372 done 373 test -n "$cf_add_1lib" && cf_add_libs="$cf_add_1lib $cf_add_libs" 374done 375ifelse($2,,LIBS,[$2])="$cf_add_libs" 376])dnl 377dnl --------------------------------------------------------------------------- 378dnl CF_ADD_SUBDIR_PATH version: 4 updated: 2013/10/08 17:47:05 379dnl ------------------ 380dnl Append to a search-list for a nonstandard header/lib-file 381dnl $1 = the variable to return as result 382dnl $2 = the package name 383dnl $3 = the subdirectory, e.g., bin, include or lib 384dnl $4 = the directory under which we will test for subdirectories 385dnl $5 = a directory that we do not want $4 to match 386AC_DEFUN([CF_ADD_SUBDIR_PATH], 387[ 388test "x$4" != "x$5" && \ 389test -d "$4" && \ 390ifelse([$5],NONE,,[(test -z "$5" || test x$5 = xNONE || test "x$4" != "x$5") &&]) { 391 test -n "$verbose" && echo " ... testing for $3-directories under $4" 392 test -d $4/$3 && $1="[$]$1 $4/$3" 393 test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2" 394 test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3" 395 test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3" 396 test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2" 397} 398])dnl 399dnl --------------------------------------------------------------------------- 400dnl CF_APPEND_TEXT version: 1 updated: 2017/02/25 18:58:55 401dnl -------------- 402dnl use this macro for appending text without introducing an extra blank at 403dnl the beginning 404define([CF_APPEND_TEXT], 405[ 406 test -n "[$]$1" && $1="[$]$1 " 407 $1="[$]{$1}$2" 408])dnl 409dnl --------------------------------------------------------------------------- 410dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 411dnl -------------- 412dnl Allow user to disable a normally-on option. 413AC_DEFUN([CF_ARG_DISABLE], 414[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl 415dnl --------------------------------------------------------------------------- 416dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 417dnl ------------- 418dnl Allow user to enable a normally-off option. 419AC_DEFUN([CF_ARG_ENABLE], 420[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl 421dnl --------------------------------------------------------------------------- 422dnl CF_ARG_OPTION version: 5 updated: 2015/05/10 19:52:14 423dnl ------------- 424dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus 425dnl values. 426dnl 427dnl Parameters: 428dnl $1 = option name 429dnl $2 = help-string 430dnl $3 = action to perform if option is not default 431dnl $4 = action if perform if option is default 432dnl $5 = default option value (either 'yes' or 'no') 433AC_DEFUN([CF_ARG_OPTION], 434[AC_ARG_ENABLE([$1],[$2],[test "$enableval" != ifelse([$5],no,yes,no) && enableval=ifelse([$5],no,no,yes) 435 if test "$enableval" != "$5" ; then 436ifelse([$3],,[ :]dnl 437,[ $3]) ifelse([$4],,,[ 438 else 439 $4]) 440 fi],[enableval=$5 ifelse([$4],,,[ 441 $4 442])dnl 443])])dnl 444dnl --------------------------------------------------------------------------- 445dnl CF_AR_FLAGS version: 6 updated: 2015/10/10 15:25:05 446dnl ----------- 447dnl Check for suitable "ar" (archiver) options for updating an archive. 448dnl 449dnl In particular, handle some obsolete cases where the "-" might be omitted, 450dnl as well as a workaround for breakage of make's archive rules by the GNU 451dnl binutils "ar" program. 452AC_DEFUN([CF_AR_FLAGS],[ 453AC_REQUIRE([CF_PROG_AR]) 454 455AC_CACHE_CHECK(for options to update archives, cf_cv_ar_flags,[ 456 cf_cv_ar_flags=unknown 457 for cf_ar_flags in -curvU -curv curv -crv crv -cqv cqv -rv rv 458 do 459 460 # check if $ARFLAGS already contains this choice 461 if test "x$ARFLAGS" != "x" ; then 462 cf_check_ar_flags=`echo "x$ARFLAGS" | sed -e "s/$cf_ar_flags\$//" -e "s/$cf_ar_flags / /"` 463 if test "x$ARFLAGS" != "$cf_check_ar_flags" ; then 464 cf_cv_ar_flags= 465 break 466 fi 467 fi 468 469 rm -f conftest.$ac_cv_objext 470 rm -f conftest.a 471 472 cat >conftest.$ac_ext <<EOF 473#line __oline__ "configure" 474int testdata[[3]] = { 123, 456, 789 }; 475EOF 476 if AC_TRY_EVAL(ac_compile) ; then 477 echo "$AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext" >&AC_FD_CC 478 $AR $ARFLAGS $cf_ar_flags conftest.a conftest.$ac_cv_objext 2>&AC_FD_CC 1>/dev/null 479 if test -f conftest.a ; then 480 cf_cv_ar_flags=$cf_ar_flags 481 break 482 fi 483 else 484 CF_VERBOSE(cannot compile test-program) 485 break 486 fi 487 done 488 rm -f conftest.a conftest.$ac_ext conftest.$ac_cv_objext 489]) 490 491if test -n "$ARFLAGS" ; then 492 if test -n "$cf_cv_ar_flags" ; then 493 ARFLAGS="$ARFLAGS $cf_cv_ar_flags" 494 fi 495else 496 ARFLAGS=$cf_cv_ar_flags 497fi 498 499AC_SUBST(ARFLAGS) 500]) 501dnl --------------------------------------------------------------------------- 502dnl CF_AWK_BIG_PRINTF version: 5 updated: 2015/04/17 21:13:04 503dnl ----------------- 504dnl Check if awk can handle big strings using printf. Some older versions of 505dnl awk choke on large strings passed via "%s". 506dnl 507dnl $1 = desired string size 508dnl $2 = variable to set with result 509AC_DEFUN([CF_AWK_BIG_PRINTF], 510[ 511 case x$AWK in 512 (x) 513 eval $2=no 514 ;; 515 (*) 516 if ( ${AWK} 'BEGIN { xx = "x"; while (length(xx) < $1) { xx = xx "x"; }; printf("%s\n", xx); }' 2>/dev/null \ 517 | $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 518 eval $2=yes 519 else 520 eval $2=no 521 fi 522 ;; 523 esac 524])dnl 525dnl --------------------------------------------------------------------------- 526dnl CF_BOOL_DECL version: 8 updated: 2004/01/30 15:51:18 527dnl ------------ 528dnl Test if 'bool' is a builtin type in the configured C++ compiler. Some 529dnl older compilers (e.g., gcc 2.5.8) don't support 'bool' directly; gcc 530dnl 2.6.3 does, in anticipation of the ANSI C++ standard. 531dnl 532dnl Treat the configuration-variable specially here, since we're directly 533dnl substituting its value (i.e., 1/0). 534dnl 535dnl $1 is the shell variable to store the result in, if not $cv_cv_builtin_bool 536AC_DEFUN([CF_BOOL_DECL], 537[ 538AC_MSG_CHECKING(if we should include stdbool.h) 539 540AC_CACHE_VAL(cf_cv_header_stdbool_h,[ 541 AC_TRY_COMPILE([],[bool foo = false], 542 [cf_cv_header_stdbool_h=0], 543 [AC_TRY_COMPILE([ 544#ifndef __BEOS__ 545#include <stdbool.h> 546#endif 547],[bool foo = false], 548 [cf_cv_header_stdbool_h=1], 549 [cf_cv_header_stdbool_h=0])])]) 550 551if test "$cf_cv_header_stdbool_h" = 1 552then AC_MSG_RESULT(yes) 553else AC_MSG_RESULT(no) 554fi 555 556AC_MSG_CHECKING([for builtin bool type]) 557 558AC_CACHE_VAL(ifelse($1,,cf_cv_builtin_bool,[$1]),[ 559 AC_TRY_COMPILE([ 560#include <stdio.h> 561#include <sys/types.h> 562],[bool x = false], 563 [ifelse($1,,cf_cv_builtin_bool,[$1])=1], 564 [ifelse($1,,cf_cv_builtin_bool,[$1])=0]) 565 ]) 566 567if test "$ifelse($1,,cf_cv_builtin_bool,[$1])" = 1 568then AC_MSG_RESULT(yes) 569else AC_MSG_RESULT(no) 570fi 571])dnl 572dnl --------------------------------------------------------------------------- 573dnl CF_BOOL_SIZE version: 15 updated: 2017/01/21 11:06:25 574dnl ------------ 575dnl Test for the size of 'bool' in the configured C++ compiler (e.g., a type). 576dnl Don't bother looking for bool.h, since it's been deprecated. 577dnl 578dnl If the current compiler is C rather than C++, we get the bool definition 579dnl from <stdbool.h>. 580AC_DEFUN([CF_BOOL_SIZE], 581[ 582AC_MSG_CHECKING([for size of bool]) 583AC_CACHE_VAL(cf_cv_type_of_bool,[ 584 rm -f cf_test.out 585 AC_TRY_RUN([ 586#include <stdlib.h> 587#include <stdio.h> 588 589#if defined(__cplusplus) 590 591#ifdef HAVE_GXX_BUILTIN_H 592#include <g++/builtin.h> 593#elif HAVE_GPP_BUILTIN_H 594#include <gpp/builtin.h> 595#elif HAVE_BUILTIN_H 596#include <builtin.h> 597#endif 598 599#else 600 601#if $cf_cv_header_stdbool_h 602#include <stdbool.h> 603#endif 604 605#endif 606 607int main(void) 608{ 609 FILE *fp = fopen("cf_test.out", "w"); 610 if (fp != 0) { 611 bool x = true; 612 if ((bool)(-x) >= 0) 613 fputs("unsigned ", fp); 614 if (sizeof(x) == sizeof(int)) fputs("int", fp); 615 else if (sizeof(x) == sizeof(char)) fputs("char", fp); 616 else if (sizeof(x) == sizeof(short))fputs("short",fp); 617 else if (sizeof(x) == sizeof(long)) fputs("long", fp); 618 fclose(fp); 619 } 620 ${cf_cv_main_return:-return}(0); 621} 622 ], 623 [cf_cv_type_of_bool=`cat cf_test.out` 624 if test -z "$cf_cv_type_of_bool"; then 625 cf_cv_type_of_bool=unknown 626 fi], 627 [cf_cv_type_of_bool=unknown], 628 [cf_cv_type_of_bool=unknown]) 629 ]) 630 rm -f cf_test.out 631AC_MSG_RESULT($cf_cv_type_of_bool) 632if test "$cf_cv_type_of_bool" = unknown ; then 633 case .$NCURSES_BOOL in 634 (.auto|.) NCURSES_BOOL=unsigned;; 635 esac 636 AC_MSG_WARN(Assuming $NCURSES_BOOL for type of bool) 637 cf_cv_type_of_bool=$NCURSES_BOOL 638fi 639])dnl 640dnl --------------------------------------------------------------------------- 641dnl CF_BUILD_CC version: 8 updated: 2018/01/04 20:31:04 642dnl ----------- 643dnl If we're cross-compiling, allow the user to override the tools and their 644dnl options. The configure script is oriented toward identifying the host 645dnl compiler, etc., but we need a build compiler to generate parts of the 646dnl source. 647dnl 648dnl $1 = default for $CPPFLAGS 649dnl $2 = default for $LIBS 650AC_DEFUN([CF_BUILD_CC],[ 651CF_ACVERSION_CHECK(2.52,, 652 [AC_REQUIRE([CF_PROG_EXT])]) 653if test "$cross_compiling" = yes ; then 654 655 # defaults that we might want to override 656 : ${BUILD_CFLAGS:=''} 657 : ${BUILD_CPPFLAGS:='ifelse([$1],,,[$1])'} 658 : ${BUILD_LDFLAGS:=''} 659 : ${BUILD_LIBS:='ifelse([$2],,,[$2])'} 660 : ${BUILD_EXEEXT:='$x'} 661 : ${BUILD_OBJEXT:='o'} 662 663 AC_ARG_WITH(build-cc, 664 [ --with-build-cc=XXX the build C compiler ($BUILD_CC)], 665 [BUILD_CC="$withval"], 666 [AC_CHECK_PROGS(BUILD_CC, [gcc clang c99 c89 cc cl],none)]) 667 AC_MSG_CHECKING(for native build C compiler) 668 AC_MSG_RESULT($BUILD_CC) 669 670 AC_MSG_CHECKING(for native build C preprocessor) 671 AC_ARG_WITH(build-cpp, 672 [ --with-build-cpp=XXX the build C preprocessor ($BUILD_CPP)], 673 [BUILD_CPP="$withval"], 674 [BUILD_CPP='${BUILD_CC} -E']) 675 AC_MSG_RESULT($BUILD_CPP) 676 677 AC_MSG_CHECKING(for native build C flags) 678 AC_ARG_WITH(build-cflags, 679 [ --with-build-cflags=XXX the build C compiler-flags ($BUILD_CFLAGS)], 680 [BUILD_CFLAGS="$withval"]) 681 AC_MSG_RESULT($BUILD_CFLAGS) 682 683 AC_MSG_CHECKING(for native build C preprocessor-flags) 684 AC_ARG_WITH(build-cppflags, 685 [ --with-build-cppflags=XXX the build C preprocessor-flags ($BUILD_CPPFLAGS)], 686 [BUILD_CPPFLAGS="$withval"]) 687 AC_MSG_RESULT($BUILD_CPPFLAGS) 688 689 AC_MSG_CHECKING(for native build linker-flags) 690 AC_ARG_WITH(build-ldflags, 691 [ --with-build-ldflags=XXX the build linker-flags ($BUILD_LDFLAGS)], 692 [BUILD_LDFLAGS="$withval"]) 693 AC_MSG_RESULT($BUILD_LDFLAGS) 694 695 AC_MSG_CHECKING(for native build linker-libraries) 696 AC_ARG_WITH(build-libs, 697 [ --with-build-libs=XXX the build libraries (${BUILD_LIBS})], 698 [BUILD_LIBS="$withval"]) 699 AC_MSG_RESULT($BUILD_LIBS) 700 701 # this assumes we're on Unix. 702 BUILD_EXEEXT= 703 BUILD_OBJEXT=o 704 705 : ${BUILD_CC:='${CC}'} 706 707 if ( test "$BUILD_CC" = "$CC" || test "$BUILD_CC" = '${CC}' ) ; then 708 AC_MSG_ERROR([Cross-build requires two compilers. 709Use --with-build-cc to specify the native compiler.]) 710 fi 711 712else 713 : ${BUILD_CC:='${CC}'} 714 : ${BUILD_CPP:='${CPP}'} 715 : ${BUILD_CFLAGS:='${CFLAGS}'} 716 : ${BUILD_CPPFLAGS:='${CPPFLAGS}'} 717 : ${BUILD_LDFLAGS:='${LDFLAGS}'} 718 : ${BUILD_LIBS:='${LIBS}'} 719 : ${BUILD_EXEEXT:='$x'} 720 : ${BUILD_OBJEXT:='o'} 721fi 722 723AC_SUBST(BUILD_CC) 724AC_SUBST(BUILD_CPP) 725AC_SUBST(BUILD_CFLAGS) 726AC_SUBST(BUILD_CPPFLAGS) 727AC_SUBST(BUILD_LDFLAGS) 728AC_SUBST(BUILD_LIBS) 729AC_SUBST(BUILD_EXEEXT) 730AC_SUBST(BUILD_OBJEXT) 731])dnl 732dnl --------------------------------------------------------------------------- 733dnl CF_CC_ENV_FLAGS version: 9 updated: 2018/07/29 18:03:26 734dnl --------------- 735dnl Check for user's environment-breakage by stuffing CFLAGS/CPPFLAGS content 736dnl into CC. This will not help with broken scripts that wrap the compiler 737dnl with options, but eliminates a more common category of user confusion. 738dnl 739dnl In particular, it addresses the problem of being able to run the C 740dnl preprocessor in a consistent manner. 741dnl 742dnl Caveat: this also disallows blanks in the pathname for the compiler, but 743dnl the nuisance of having inconsistent settings for compiler and preprocessor 744dnl outweighs that limitation. 745AC_DEFUN([CF_CC_ENV_FLAGS], 746[ 747# This should have been defined by AC_PROG_CC 748: ${CC:=cc} 749 750AC_MSG_CHECKING(\$CFLAGS variable) 751case "x$CFLAGS" in 752(*-[[IUD]]*) 753 AC_MSG_RESULT(broken) 754 AC_MSG_WARN(your environment uses the CFLAGS variable to hold CPPFLAGS options) 755 cf_flags="$CFLAGS" 756 CFLAGS= 757 for cf_arg in $cf_flags 758 do 759 CF_ADD_CFLAGS($cf_arg) 760 done 761 ;; 762(*) 763 AC_MSG_RESULT(ok) 764 ;; 765esac 766 767AC_MSG_CHECKING(\$CC variable) 768case "$CC" in 769(*[[\ \ ]]-*) 770 AC_MSG_RESULT(broken) 771 AC_MSG_WARN(your environment uses the CC variable to hold CFLAGS/CPPFLAGS options) 772 # humor him... 773 cf_prog=`echo "$CC" | sed -e 's/ / /g' -e 's/[[ ]]* / /g' -e 's/[[ ]]*[[ ]]-[[^ ]].*//'` 774 cf_flags=`echo "$CC" | ${AWK:-awk} -v prog="$cf_prog" '{ printf("%s", [substr]([$]0,1+length(prog))); }'` 775 CC="$cf_prog" 776 for cf_arg in $cf_flags 777 do 778 case "x$cf_arg" in 779 (x-[[IUDfgOW]]*) 780 CF_ADD_CFLAGS($cf_arg) 781 ;; 782 (*) 783 CC="$CC $cf_arg" 784 ;; 785 esac 786 done 787 CF_VERBOSE(resulting CC: '$CC') 788 CF_VERBOSE(resulting CFLAGS: '$CFLAGS') 789 CF_VERBOSE(resulting CPPFLAGS: '$CPPFLAGS') 790 ;; 791(*) 792 AC_MSG_RESULT(ok) 793 ;; 794esac 795])dnl 796dnl --------------------------------------------------------------------------- 797dnl CF_CFG_DEFAULTS version: 11 updated: 2015/04/17 21:13:04 798dnl --------------- 799dnl Determine the default configuration into which we'll install ncurses. This 800dnl can be overridden by the user's command-line options. There's two items to 801dnl look for: 802dnl 1. the prefix (e.g., /usr) 803dnl 2. the header files (e.g., /usr/include/ncurses) 804dnl We'll look for a previous installation of ncurses and use the same defaults. 805dnl 806dnl We don't use AC_PREFIX_DEFAULT, because it gets evaluated too soon, and 807dnl we don't use AC_PREFIX_PROGRAM, because we cannot distinguish ncurses's 808dnl programs from a vendor's. 809AC_DEFUN([CF_CFG_DEFAULTS], 810[ 811AC_MSG_CHECKING(for prefix) 812if test "x$prefix" = "xNONE" ; then 813 case "$cf_cv_system_name" in 814 # non-vendor systems don't have a conflict 815 (openbsd*|freebsd*|mirbsd*|linux*|cygwin*|msys*|k*bsd*-gnu|mingw*) 816 prefix=/usr 817 ;; 818 (*) prefix=$ac_default_prefix 819 ;; 820 esac 821fi 822AC_MSG_RESULT($prefix) 823 824if test "x$prefix" = "xNONE" ; then 825AC_MSG_CHECKING(for default include-directory) 826test -n "$verbose" && echo 1>&AC_FD_MSG 827for cf_symbol in \ 828 $includedir \ 829 $includedir/ncurses \ 830 $prefix/include \ 831 $prefix/include/ncurses \ 832 /usr/local/include \ 833 /usr/local/include/ncurses \ 834 /usr/include \ 835 /usr/include/ncurses 836do 837 cf_dir=`eval echo $cf_symbol` 838 if test -f $cf_dir/curses.h ; then 839 if ( fgrep NCURSES_VERSION $cf_dir/curses.h 2>&1 >/dev/null ) ; then 840 includedir="$cf_symbol" 841 test -n "$verbose" && echo $ac_n " found " 1>&AC_FD_MSG 842 break 843 fi 844 fi 845 test -n "$verbose" && echo " tested $cf_dir" 1>&AC_FD_MSG 846done 847AC_MSG_RESULT($includedir) 848fi 849])dnl 850dnl --------------------------------------------------------------------------- 851dnl CF_CGETENT version: 6 updated: 2017/01/21 11:06:25 852dnl ---------- 853dnl Check if the terminal-capability database functions are available. If not, 854dnl ncurses has a much-reduced version. 855AC_DEFUN([CF_CGETENT],[ 856AC_CACHE_CHECK(for terminal-capability database functions,cf_cv_cgetent,[ 857AC_TRY_LINK([ 858#include <stdlib.h>],[ 859 char temp[128]; 860 char *buf = temp; 861 char *db_array = temp; 862 cgetent(&buf, &db_array, "vt100"); 863 cgetcap(buf, "tc", '='); 864 cgetmatch(buf, "tc"); 865 ], 866 [cf_cv_cgetent=yes], 867 [cf_cv_cgetent=no]) 868]) 869 870if test "$cf_cv_cgetent" = yes 871then 872 AC_DEFINE(HAVE_BSD_CGETENT,1,[Define to 1 if we have BSD cgetent]) 873AC_CACHE_CHECK(if cgetent uses const parameter,cf_cv_cgetent_const,[ 874AC_TRY_LINK([ 875#pragma GCC diagnostic error "-Wincompatible-pointer-types-discards-qualifiers" 876#include <stdlib.h>],[ 877 char temp[128]; 878 char *buf = temp; 879#ifndef _NETBSD_SOURCE /* given, since April 2004 in stdlib.h */ 880 const char *db_array = temp; 881 cgetent(&buf, &db_array, "vt100"); 882#endif 883 cgetcap(buf, "tc", '='); 884 cgetmatch(buf, "tc"); 885 ], 886 [cf_cv_cgetent_const=yes], 887 [cf_cv_cgetent_const=no]) 888]) 889 if test "$cf_cv_cgetent_const" = yes 890 then 891 AC_DEFINE_UNQUOTED(CGETENT_CONST,const,[Define to const if needed for some BSD cgetent variations]) 892 fi 893fi 894])dnl 895dnl --------------------------------------------------------------------------- 896dnl CF_CHECK_CACHE version: 12 updated: 2012/10/02 20:55:03 897dnl -------------- 898dnl Check if we're accidentally using a cache from a different machine. 899dnl Derive the system name, as a check for reusing the autoconf cache. 900dnl 901dnl If we've packaged config.guess and config.sub, run that (since it does a 902dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow 903dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM 904dnl which is useful in cross-compiles. 905dnl 906dnl Note: we would use $ac_config_sub, but that is one of the places where 907dnl autoconf 2.5x broke compatibility with autoconf 2.13 908AC_DEFUN([CF_CHECK_CACHE], 909[ 910if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then 911 ifelse([$1],,[AC_CANONICAL_HOST],[$1]) 912 system_name="$host_os" 913else 914 system_name="`(uname -s -r) 2>/dev/null`" 915 if test -z "$system_name" ; then 916 system_name="`(hostname) 2>/dev/null`" 917 fi 918fi 919test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name",[Define to the system name.]) 920AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) 921 922test -z "$system_name" && system_name="$cf_cv_system_name" 923test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) 924 925if test ".$system_name" != ".$cf_cv_system_name" ; then 926 AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) 927 AC_MSG_ERROR("Please remove config.cache and try again.") 928fi 929])dnl 930dnl --------------------------------------------------------------------------- 931dnl CF_CHECK_ENVIRON version: 3 updated: 2010/05/26 16:44:57 932dnl ---------------- 933dnl Check for data that is usually declared in <unistd.h>, e.g., the 'environ' 934dnl variable. Define a DECL_xxx symbol if we must declare it ourselves. 935dnl 936dnl $1 = the name to check 937dnl $2 = the assumed type 938AC_DEFUN([CF_CHECK_ENVIRON], 939[ 940AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ 941 AC_TRY_COMPILE([ 942#ifdef HAVE_STDLIB_H 943#include <stdlib.h> 944#endif 945#include <unistd.h> ], 946 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1, 947 [cf_cv_dcl_$1=yes], 948 [cf_cv_dcl_$1=no]) 949]) 950 951if test "$cf_cv_dcl_$1" = no ; then 952 CF_UPPER(cf_result,decl_$1) 953 AC_DEFINE_UNQUOTED($cf_result) 954fi 955 956# It's possible (for near-UNIX clones) that the data doesn't exist 957CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2])) 958])dnl 959dnl --------------------------------------------------------------------------- 960dnl CF_CHECK_ERRNO version: 12 updated: 2015/04/18 08:56:57 961dnl -------------- 962dnl Check for data that is usually declared in <stdio.h> or <errno.h>, e.g., 963dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it 964dnl ourselves. 965dnl 966dnl $1 = the name to check 967dnl $2 = the assumed type 968AC_DEFUN([CF_CHECK_ERRNO], 969[ 970AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ 971 AC_TRY_COMPILE([ 972#ifdef HAVE_STDLIB_H 973#include <stdlib.h> 974#endif 975#include <stdio.h> 976#include <sys/types.h> 977#include <errno.h> ], 978 ifelse([$2],,int,[$2]) x = (ifelse([$2],,int,[$2])) $1, 979 [cf_cv_dcl_$1=yes], 980 [cf_cv_dcl_$1=no]) 981]) 982 983if test "$cf_cv_dcl_$1" = no ; then 984 CF_UPPER(cf_result,decl_$1) 985 AC_DEFINE_UNQUOTED($cf_result) 986fi 987 988# It's possible (for near-UNIX clones) that the data doesn't exist 989CF_CHECK_EXTERN_DATA($1,ifelse([$2],,int,[$2])) 990])dnl 991dnl --------------------------------------------------------------------------- 992dnl CF_CHECK_EXTERN_DATA version: 4 updated: 2015/04/18 08:56:57 993dnl -------------------- 994dnl Check for existence of external data in the current set of libraries. If 995dnl we can modify it, it's real enough. 996dnl $1 = the name to check 997dnl $2 = its type 998AC_DEFUN([CF_CHECK_EXTERN_DATA], 999[ 1000AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[ 1001 AC_TRY_LINK([ 1002#undef $1 1003extern $2 $1; 1004], 1005 [$1 = 2], 1006 [cf_cv_have_$1=yes], 1007 [cf_cv_have_$1=no]) 1008]) 1009 1010if test "$cf_cv_have_$1" = yes ; then 1011 CF_UPPER(cf_result,have_$1) 1012 AC_DEFINE_UNQUOTED($cf_result) 1013fi 1014 1015])dnl 1016dnl --------------------------------------------------------------------------- 1017dnl CF_CHECK_GETENV version: 1 updated: 2019/06/23 15:28:15 1018dnl --------------- 1019dnl Check if repeated getenv calls return the same pointer, e.g., it does not 1020dnl discard the previous pointer when returning a new one. 1021AC_DEFUN([CF_CHECK_GETENV], 1022[ 1023AC_REQUIRE([CF_CHECK_ENVIRON]) 1024AC_CHECK_FUNC( getenv, ,, AC_MSG_ERROR(getenv not found) ) 1025AC_CHECK_FUNCS( putenv setenv strdup ) 1026AC_CACHE_CHECK(if getenv returns consistent values,cf_cv_consistent_getenv,[ 1027AC_TRY_RUN([ 1028#include <stdlib.h> 1029#include <unistd.h> 1030#include <stdio.h> 1031#include <string.h> 1032#include <sys/types.h> 1033 1034#if defined(HAVE_ENVIRON) && defined(DECL_ENVIRON) && !defined(environ) 1035extern char **environ; /* POSIX, but some systems are not... */ 1036#endif 1037 1038#if defined(HAVE_STRDUP) 1039#define str_alloc(s) strdup(s) 1040#else 1041#define str_alloc(s) strcpy(malloc(strlen(s) + 1, s)) 1042#endif 1043 1044static void set_value(const char *name, const char *value) 1045{ 1046#if defined(HAVE_SETENV) 1047 setenv(name, value, 1); 1048#elif defined(HAVE_PUTENV) 1049 char buffer[1024]; 1050 sprintf(buffer, "%s=%s", name, value); 1051 putenv(str_alloc(buffer)); 1052#else 1053#error neither putenv/setenv found 1054#endif 1055} 1056int main(void) 1057{ 1058 int pass; 1059 size_t numenv, limit, j; 1060 char **mynames; 1061 char **myvalues; 1062 char **mypointer; 1063 char *equals; 1064 for (numenv = 0; environ[numenv]; ++numenv) ; 1065 limit = numenv + 10; 1066 mynames = (char **) calloc(limit + 1, sizeof(char *)); 1067 myvalues = (char **) calloc(limit + 1, sizeof(char *)); 1068 mypointer = (char **) calloc(limit + 1, sizeof(char *)); 1069#if defined(HAVE_ENVIRON) 1070 for (j = 0; environ[j]; ++j) { 1071 mynames[j] = str_alloc(environ[j]); 1072 equals = strchr(mynames[j], '='); 1073 if (equals != 0) { 1074 *equals++ = '\0'; 1075 myvalues[j] = str_alloc(equals); 1076 } else { 1077 myvalues[j] = str_alloc(""); 1078 } 1079 } 1080#endif 1081 for (j = numenv; j < limit; ++j) { 1082 char name[80]; 1083 char value[80]; 1084 size_t found; 1085 size_t k = 0; 1086 do { 1087 size_t jk; 1088 found = 0; 1089 sprintf(name, "TERM%lu", (unsigned long) k); 1090 for (jk = 0; jk < j; ++jk) { 1091 if (!strcmp(name, mynames[jk])) { 1092 found = 1; 1093 ++k; 1094 break; 1095 } 1096 } 1097 } while (found); 1098 sprintf(value, "%lu:%p", (unsigned long) k, &mynames[j]); 1099 set_value(name, value); 1100 mynames[j] = str_alloc(name); 1101 myvalues[j] = str_alloc(value); 1102 } 1103 for (pass = 0; pass < 3; ++pass) { 1104 for (j = 0; j < limit; ++j) { 1105 char *value = getenv(mynames[j]); 1106 if (pass) { 1107 if (value == 0) { 1108 fprintf(stderr, "getenv returned null for %s\n", mynames[j]); 1109 ${cf_cv_main_return:-return}(1); 1110 } else if (value != mypointer[j]) { 1111 fprintf(stderr, "getenv returned different pointer for %s\n", mynames[j]); 1112 ${cf_cv_main_return:-return}(1); 1113 } else if (strcmp(value, myvalues[j])) { 1114 fprintf(stderr, "getenv returned different value for %s\n", mynames[j]); 1115 ${cf_cv_main_return:-return}(1); 1116 } 1117 } else { 1118 size_t k; 1119 mypointer[j] = value; 1120 for (k = 0; k < j; ++k) { 1121 if (mypointer[j] == mypointer[k]) { 1122 fprintf(stderr, "getenv returned same pointer for %s and %s\n", mynames[j], mynames[k]); 1123 ${cf_cv_main_return:-return}(1); 1124 } 1125 } 1126 } 1127 } 1128 } 1129 ${cf_cv_main_return:-return}(0); 1130} 1131], 1132[cf_cv_consistent_getenv=yes], 1133[cf_cv_consistent_getenv=no], 1134[cf_cv_consistent_getenv=unknown]) 1135]) 1136 1137if test "x$cf_cv_consistent_getenv" = xno 1138then 1139 AC_DEFINE(HAVE_CONSISTENT_GETENV,1,[Define to 1 if getenv repeatably returns the same value for a given name]) 1140fi 1141])dnl 1142dnl --------------------------------------------------------------------------- 1143dnl CF_CHECK_GNAT_VERSION version: 2 updated: 2019/12/31 08:53:54 1144dnl --------------------- 1145AC_DEFUN([CF_CHECK_GNAT_VERSION], 1146[ 1147AC_REQUIRE([CF_GNAT_VERSION]) 1148case $cf_cv_gnat_version in 1149(3.1[[1-9]]*|3.[[2-9]]*|[[4-9]].*|20[[0-9]][[0-9]]) 1150 cf_cv_prog_gnat_correct=yes 1151 ;; 1152(*) 1153 AC_MSG_WARN(Unsupported GNAT version $cf_cv_gnat_version. We require 3.11 or better. Disabling Ada95 binding.) 1154 cf_cv_prog_gnat_correct=no 1155 ;; 1156esac 1157]) 1158dnl --------------------------------------------------------------------------- 1159dnl CF_CHECK_GPM_WGETCH version: 3 updated: 2017/01/21 11:06:25 1160dnl ------------------- 1161dnl Check if GPM is already linked with curses. If so - and if the linkage 1162dnl is not "weak" - warn about this because it can create problems linking 1163dnl applications with ncurses. 1164AC_DEFUN([CF_CHECK_GPM_WGETCH],[ 1165AC_CHECK_LIB(gpm,Gpm_Wgetch,[ 1166 1167AC_CACHE_CHECK(if GPM is weakly bound to curses library, cf_cv_check_gpm_wgetch,[ 1168cf_cv_check_gpm_wgetch=unknown 1169if test "$cross_compiling" != yes ; then 1170 1171cat >conftest.$ac_ext <<CF_EOF 1172#include <gpm.h> 1173int main(void) 1174{ 1175 Gpm_Wgetch(); 1176 ${cf_cv_main_return:-return}(0); 1177} 1178CF_EOF 1179 1180 cf_save_LIBS="$LIBS" 1181 # This only works if we can look at the symbol table. If a shared 1182 # library is stripped for install, we cannot use that. So we're forced 1183 # to rely on the static library, noting that some packagers may not 1184 # include it. 1185 LIBS="-static -lgpm -dynamic $LIBS" 1186 if AC_TRY_EVAL(ac_compile) ; then 1187 if AC_TRY_EVAL(ac_link) ; then 1188 cf_cv_check_gpm_wgetch=`nm conftest$ac_exeext | egrep '\<wgetch\>' | egrep '\<[[vVwW]]\>'` 1189 test -n "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=yes 1190 test -z "$cf_cv_check_gpm_wgetch" && cf_cv_check_gpm_wgetch=no 1191 fi 1192 fi 1193 rm -rf conftest* 1194 LIBS="$cf_save_LIBS" 1195fi 1196]) 1197 1198if test "$cf_cv_check_gpm_wgetch" != yes ; then 1199 AC_MSG_WARN(GPM library is already linked with curses - read the FAQ) 1200fi 1201])])dnl 1202dnl --------------------------------------------------------------------------- 1203dnl CF_CHECK_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09 1204dnl ------------------------ 1205dnl Show the version of libtool 1206dnl 1207dnl Save the version in a cache variable - this is not entirely a good thing, 1208dnl but the version string from libtool is very ugly, and for bug reports it 1209dnl might be useful to have the original string. 1210AC_DEFUN([CF_CHECK_LIBTOOL_VERSION],[ 1211if test -n "$LIBTOOL" && test "$LIBTOOL" != none 1212then 1213 AC_MSG_CHECKING(version of $LIBTOOL) 1214 CF_LIBTOOL_VERSION 1215 AC_MSG_RESULT($cf_cv_libtool_version) 1216 if test -z "$cf_cv_libtool_version" ; then 1217 AC_MSG_ERROR(This is not GNU libtool) 1218 fi 1219else 1220 AC_MSG_ERROR(GNU libtool has not been found) 1221fi 1222])dnl 1223dnl --------------------------------------------------------------------------- 1224dnl CF_CHECK_WCHAR_H version: 2 updated: 2017/01/21 11:06:25 1225dnl ---------------- 1226dnl Check if wchar.h can be used, i.e., without defining _XOPEN_SOURCE_EXTENDED 1227AC_DEFUN([CF_CHECK_WCHAR_H],[ 1228AC_CHECK_HEADERS( \ 1229wchar.h \ 1230wctype.h \ 1231) 1232AC_CACHE_CHECK(if wchar.h can be used as is,cf_cv_wchar_h_okay,[ 1233AC_TRY_COMPILE( 1234[ 1235#include <stdlib.h> 1236#ifdef HAVE_WCHAR_H 1237#include <wchar.h> 1238#endif 1239#ifdef HAVE_WCTYPE_H 1240#include <wctype.h> 1241#endif 1242],[ 1243 wint_t foo = 0; 1244 int bar = iswpunct(foo)], 1245 [cf_cv_wchar_h_okay=yes], 1246 [cf_cv_wchar_h_okay=no])]) 1247 1248if test $cf_cv_wchar_h_okay = no 1249then 1250 CF_PREDEFINE(_XOPEN_SOURCE_EXTENDED) 1251fi 1252])dnl 1253dnl --------------------------------------------------------------------------- 1254dnl CF_CHECK_WCWIDTH_GRAPHICS version: 1 updated: 2015/12/19 17:47:56 1255dnl ------------------------- 1256dnl Most "modern" terminal emulators are based to some degree on VT100, and 1257dnl should support line-drawing. Even with Unicode. There is a problem. 1258dnl 1259dnl While most of the VT100 graphics characters were incorporated into Unicode, 1260dnl all of those were combined into a page of useful graphics characters. 1261dnl 1262dnl So far, so good. 1263dnl 1264dnl However, while they are useful, there are other considerations. CJK 1265dnl is (because of poor device resolution) often rendered as double-width 1266dnl characters. So... for these generally-useful characters, what should 1267dnl be the width (to make them consistent with adjacent characters)? 1268dnl 1269dnl The obvious choice would have been to make this locale-dependent, and use 1270dnl wcwidth() to tell applications what the actual width is. That was too 1271dnl obvious. Instead, we have a slew of "ambiguous-width" characters. 1272dnl See for example 1273dnl http://www.unicode.org/reports/tr11/tr11-29.html 1274dnl http://www.cl.cam.ac.uk/~mgk25/ucs/scw-proposal.html 1275dnl 1276dnl The EastAsianWidth-6.2.0.txt file from the Unicode organization lists 1277dnl more than 22,000 characters, with 1281 of those as ambiguous-width. For 1278dnl instance, it lists half (44/96) of the Latin-1 characters as 1279dnl ambiguous-width. Also, all of the box-characters at 0x2500 are ambiguous. 1280dnl 1281dnl What this means for the implementor is that on some systems wcwidth() can 1282dnl give bad advice. On Solaris, some of the ambiguous widths are returned as 1283dnl 1 (the Latin-1 characters), while others are returned as 2 (line-drawing 1284dnl characters). These do not necessarily match the behavior of the terminal 1285dnl emulator. xterm, for instance, does an optional startup check to find if 1286dnl this problem (or similar) exists with the system's locale tables, rejecting 1287dnl them if they are too unreliable. 1288AC_DEFUN([CF_CHECK_WCWIDTH_GRAPHICS],[ 1289AC_CACHE_CHECK(if wcwidth agrees graphics are single-width, cf_cv_wcwidth_graphics,[ 1290cat >conftest.in <<CF_EOF 1291- VT100 symbols 12920x250c upper left corner 12930x2514 lower left corner 12940x2510 upper right corner 12950x2518 lower right corner 12960x251c tee pointing left 12970x2524 tee pointing right 12980x2534 tee pointing up 12990x252c tee pointing down 13000x2500 horizontal line 13010x2502 vertical line 13020x253c large plus or crossover 13030x23ba scan line 1 13040x23bd scan line 9 13050x25c6 diamond 13060x2592 checker board (stipple) 13070x00b0 degree symbol 13080x00b1 plus/minus 13090x00b7 bullet 1310- Teletype 5410v1 symbols 13110x2190 arrow pointing left 13120x2192 arrow pointing right 13130x2193 arrow pointing down 13140x2191 arrow pointing up 13150x2592 board of squares 13160x2603 lantern symbol 13170x25ae solid square block 1318- these defaults were invented for ncurses 13190x23bb scan line 3 13200x23bc scan line 7 13210x2264 less-than-or-equal-to 13220x2265 greater-than-or-equal-to 13230x03c0 greek pi 13240x2260 not-equal 13250x00a3 pound-sterling symbol 1326- thick-line-drawing 13270x250f upper left corner 13280x2517 lower left corner 13290x2513 upper right corner 13300x251b lower right corner 13310x2523 tee pointing left 13320x252b tee pointing right 13330x253b tee pointing up 13340x2533 tee pointing down 13350x2501 horizontal line 13360x2503 vertical line 13370x254b large plus or crossover 1338- double-line-drawing 13390x2554 upper left corner 13400x255a lower left corner 13410x2557 upper right corner 13420x255d lower right corner 13430x2563 tee pointing left 13440x2560 tee pointing right 13450x2569 tee pointing up 13460x2566 tee pointing down 13470x2550 horizontal line 13480x2551 vertical line 13490x256c large plus or crossover 1350CF_EOF 1351AC_TRY_RUN([ 1352#include <locale.h> 1353#include <stdio.h> 1354#include <wchar.h> 1355 1356#define MY_LEN 80 1357 1358int 1359main(void) 1360{ 1361 FILE *fp; 1362 int value; 1363 char buffer[MY_LEN + 1]; 1364 char notes[MY_LEN + 1]; 1365 int totals = 0; 1366 int passed = 0; 1367 1368 if (setlocale(LC_ALL, "en_US.UTF8") || 1369 setlocale(LC_ALL, "en_US.UTF-8") || 1370 setlocale(LC_ALL, "en_US.utf8") || 1371 setlocale(LC_ALL, "en_US.utf-8")) { 1372 if ((fp = fopen("conftest.in", "r")) != 0) { 1373 while (fgets(buffer, MY_LEN, fp) != 0) { 1374 if (*buffer == '-') { 1375 fprintf(stderr, "\t%s", buffer); 1376 } else if (sscanf(buffer, "%x %s", &value, notes) == 2) { 1377 ++totals; 1378 if (wcwidth(value) == 1) 1379 ++passed; 1380 fprintf(stderr, "%d\t%s", wcwidth(value), buffer); 1381 } else { 1382 fprintf(stderr, "?\t%s", buffer); 1383 } 1384 } 1385 } 1386 } 1387 fprintf(stderr, "%d/%d passed wcwidth/graphics check\n", passed, totals); 1388 return (totals == passed) ? 0 : 1; 1389} 1390], 1391[cf_cv_wcwidth_graphics=yes], 1392[cf_cv_wcwidth_graphics=no], 1393[cf_cv_wcwidth_graphics=unknown]) 1394]) 1395])dnl 1396dnl --------------------------------------------------------------------------- 1397dnl CF_CLANG_COMPILER version: 2 updated: 2013/11/19 19:23:35 1398dnl ----------------- 1399dnl Check if the given compiler is really clang. clang's C driver defines 1400dnl __GNUC__ (fooling the configure script into setting $GCC to yes) but does 1401dnl not ignore some gcc options. 1402dnl 1403dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to 1404dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from 1405dnl the wrappers for gcc and g++ warnings. 1406dnl 1407dnl $1 = GCC (default) or GXX 1408dnl $2 = CLANG_COMPILER (default) 1409dnl $3 = CFLAGS (default) or CXXFLAGS 1410AC_DEFUN([CF_CLANG_COMPILER],[ 1411ifelse([$2],,CLANG_COMPILER,[$2])=no 1412 1413if test "$ifelse([$1],,[$1],GCC)" = yes ; then 1414 AC_MSG_CHECKING(if this is really Clang ifelse([$1],GXX,C++,C) compiler) 1415 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" 1416 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -Qunused-arguments" 1417 AC_TRY_COMPILE([],[ 1418#ifdef __clang__ 1419#else 1420make an error 1421#endif 1422],[ifelse([$2],,CLANG_COMPILER,[$2])=yes 1423cf_save_CFLAGS="$cf_save_CFLAGS -Qunused-arguments" 1424],[]) 1425 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" 1426 AC_MSG_RESULT($ifelse([$2],,CLANG_COMPILER,[$2])) 1427fi 1428]) 1429dnl --------------------------------------------------------------------------- 1430dnl CF_CONST_X_STRING version: 3 updated: 2020/01/11 18:39:22 1431dnl ----------------- 1432dnl The X11R4-X11R6 Xt specification uses an ambiguous String type for most 1433dnl character-strings. 1434dnl 1435dnl It is ambiguous because the specification accommodated the pre-ANSI 1436dnl compilers bundled by more than one vendor in lieu of providing a standard C 1437dnl compiler other than by costly add-ons. Because of this, the specification 1438dnl did not take into account the use of const for telling the compiler that 1439dnl string literals would be in readonly memory. 1440dnl 1441dnl As a workaround, one could (starting with X11R5) define XTSTRINGDEFINES, to 1442dnl let the compiler decide how to represent Xt's strings which were #define'd. 1443dnl That does not solve the problem of using the block of Xt's strings which 1444dnl are compiled into the library (and is less efficient than one might want). 1445dnl 1446dnl Xt specification 7 introduces the _CONST_X_STRING symbol which is used both 1447dnl when compiling the library and compiling using the library, to tell the 1448dnl compiler that String is const. 1449AC_DEFUN([CF_CONST_X_STRING], 1450[ 1451AC_REQUIRE([AC_PATH_XTRA]) 1452 1453CF_SAVE_XTRA_FLAGS([CF_CONST_X_STRING]) 1454 1455AC_TRY_COMPILE( 1456[ 1457#include <stdlib.h> 1458#include <X11/Intrinsic.h> 1459], 1460[String foo = malloc(1)],[ 1461 1462AC_CACHE_CHECK(for X11/Xt const-feature,cf_cv_const_x_string,[ 1463 AC_TRY_COMPILE( 1464 [ 1465#define _CONST_X_STRING /* X11R7.8 (perhaps) */ 1466#undef XTSTRINGDEFINES /* X11R5 and later */ 1467#include <stdlib.h> 1468#include <X11/Intrinsic.h> 1469 ],[String foo = malloc(1); *foo = 0],[ 1470 cf_cv_const_x_string=no 1471 ],[ 1472 cf_cv_const_x_string=yes 1473 ]) 1474]) 1475 1476CF_RESTORE_XTRA_FLAGS([CF_CONST_X_STRING]) 1477 1478case $cf_cv_const_x_string in 1479(no) 1480 CF_APPEND_TEXT(CPPFLAGS,-DXTSTRINGDEFINES) 1481 ;; 1482(*) 1483 CF_APPEND_TEXT(CPPFLAGS,-D_CONST_X_STRING) 1484 ;; 1485esac 1486 1487]) 1488])dnl 1489dnl --------------------------------------------------------------------------- 1490dnl CF_CPP_PARAM_INIT version: 7 updated: 2017/01/21 11:06:25 1491dnl ----------------- 1492dnl Check if the C++ compiler accepts duplicate parameter initialization. This 1493dnl is a late feature for the standard and is not in some recent compilers 1494dnl (1999/9/11). 1495AC_DEFUN([CF_CPP_PARAM_INIT], 1496[ 1497if test -n "$CXX"; then 1498AC_CACHE_CHECK(if $CXX accepts parameter initialization,cf_cv_cpp_param_init,[ 1499 AC_LANG_SAVE 1500 AC_LANG_CPLUSPLUS 1501 AC_TRY_RUN([ 1502class TEST { 1503private: 1504 int value; 1505public: 1506 TEST(int x = 1); 1507 ~TEST(); 1508}; 1509 1510TEST::TEST(int x = 1) // some compilers do not like second initializer 1511{ 1512 value = x; 1513} 1514int main(void) { } 1515], 1516 [cf_cv_cpp_param_init=yes], 1517 [cf_cv_cpp_param_init=no], 1518 [cf_cv_cpp_param_init=unknown]) 1519 AC_LANG_RESTORE 1520]) 1521fi 1522test "$cf_cv_cpp_param_init" = yes && AC_DEFINE(CPP_HAS_PARAM_INIT,1,[Define to 1 if C++ has parameter initialization]) 1523])dnl 1524dnl --------------------------------------------------------------------------- 1525dnl CF_CPP_STATIC_CAST version: 3 updated: 2013/04/13 18:03:21 1526dnl ------------------ 1527dnl Check if the C++ compiler accepts static_cast in generics. This appears to 1528dnl not be supported in g++ before 3.0 1529AC_DEFUN([CF_CPP_STATIC_CAST], 1530[ 1531if test -n "$CXX"; then 1532 1533AC_CACHE_CHECK(if $CXX accepts static_cast,cf_cv_cpp_static_cast,[ 1534 AC_LANG_SAVE 1535 AC_LANG_CPLUSPLUS 1536 1537 AC_TRY_COMPILE([ 1538class NCursesPanel 1539{ 1540public: 1541 NCursesPanel(int nlines, 1542 int ncols, 1543 int begin_y = 0, 1544 int begin_x = 0) 1545 { 1546 } 1547 NCursesPanel(); 1548 ~NCursesPanel(); 1549}; 1550 1551template<class T> class NCursesUserPanel : public NCursesPanel 1552{ 1553public: 1554 NCursesUserPanel (int nlines, 1555 int ncols, 1556 int begin_y = 0, 1557 int begin_x = 0, 1558 const T* p_UserData = static_cast<T*>(0)) 1559 : NCursesPanel (nlines, ncols, begin_y, begin_x) 1560 { 1561 }; 1562 NCursesUserPanel(const T* p_UserData = static_cast<T*>(0)) : NCursesPanel() 1563 { 1564 }; 1565 1566 virtual ~NCursesUserPanel() {}; 1567}; 1568],[ 1569 const char* p_UserData = static_cast<char*>(0)], 1570 [cf_cv_cpp_static_cast=yes], 1571 [cf_cv_cpp_static_cast=no]) 1572 1573 AC_LANG_RESTORE 1574]) 1575 1576fi 1577 1578test "$cf_cv_cpp_static_cast" = yes && AC_DEFINE(CPP_HAS_STATIC_CAST,1,[Define to 1 if C++ has static_cast]) 1579])dnl 1580dnl --------------------------------------------------------------------------- 1581dnl CF_CXX_AR_FLAGS version: 2 updated: 2015/04/17 21:13:04 1582dnl --------------- 1583dnl Setup special archiver flags for given compilers. 1584AC_DEFUN([CF_CXX_AR_FLAGS],[ 1585 CXX_AR='$(AR)' 1586 CXX_ARFLAGS='$(ARFLAGS)' 1587 case $cf_cv_system_name in 1588 (irix*) 1589 if test "$GXX" != yes ; then 1590 CXX_AR='$(CXX)' 1591 CXX_ARFLAGS='-ar -o' 1592 fi 1593 ;; 1594 (sco3.2v5*) 1595 CXXLDFLAGS="-u main" 1596 ;; 1597 (solaris2*) 1598 if test "$GXX" != yes ; then 1599 CXX_AR='$(CXX)' 1600 CXX_ARFLAGS='-xar -o' 1601 fi 1602 ;; 1603 esac 1604 AC_SUBST(CXXLDFLAGS) 1605 AC_SUBST(CXX_AR) 1606 AC_SUBST(CXX_ARFLAGS) 1607])dnl 1608dnl --------------------------------------------------------------------------- 1609dnl CF_CXX_IOSTREAM_NAMESPACE version: 2 updated: 2012/10/06 17:56:13 1610dnl ------------------------- 1611dnl For c++, check if iostream uses "std::" namespace. 1612AC_DEFUN([CF_CXX_IOSTREAM_NAMESPACE],[ 1613AC_CHECK_HEADERS(iostream) 1614if test x"$ac_cv_header_iostream" = xyes ; then 1615 AC_MSG_CHECKING(if iostream uses std-namespace) 1616 AC_TRY_COMPILE([ 1617#include <iostream> 1618using std::endl; 1619using std::cerr;],[ 1620cerr << "testing" << endl; 1621],[cf_iostream_namespace=yes],[cf_iostream_namespace=no]) 1622 AC_MSG_RESULT($cf_iostream_namespace) 1623 if test "$cf_iostream_namespace" = yes ; then 1624 AC_DEFINE(IOSTREAM_NAMESPACE,1,[Define to 1 if C++ has namespace iostream]) 1625 fi 1626fi 1627])dnl 1628dnl --------------------------------------------------------------------------- 1629dnl CF_C_INLINE version: 6 updated: 2019/09/07 13:38:36 1630dnl ----------- 1631dnl Check if the C compiler supports "inline". 1632dnl $1 is the name of a shell variable to set if inline is supported 1633dnl $2 is the threshold for gcc 4.x's option controlling maximum inline size 1634AC_DEFUN([CF_C_INLINE],[ 1635AC_REQUIRE([CF_GCC_VERSION]) 1636AC_C_INLINE 1637$1= 1638if test "$ac_cv_c_inline" != no ; then 1639 $1=inline 1640 if test "$INTEL_COMPILER" = yes 1641 then 1642 : 1643 elif test "$CLANG_COMPILER" = yes 1644 then 1645 : 1646 elif test "$GCC" = yes 1647 then 1648 AC_CACHE_CHECK(if $CC supports options to tune inlining,cf_cv_gcc_inline,[ 1649 cf_save_CFLAGS=$CFLAGS 1650 CFLAGS="$CFLAGS --param max-inline-insns-single=$2" 1651 AC_TRY_COMPILE([inline int foo(void) { return 1; }], 1652 [${cf_cv_main_return:-return} foo()], 1653 [cf_cv_gcc_inline=yes], 1654 [cf_cv_gcc_inline=no]) 1655 CFLAGS=$cf_save_CFLAGS 1656 ]) 1657 if test "$cf_cv_gcc_inline" = yes ; then 1658 CF_ADD_CFLAGS([--param max-inline-insns-single=$2]) 1659 fi 1660 fi 1661fi 1662AC_SUBST($1) 1663])dnl 1664dnl --------------------------------------------------------------------------- 1665dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52 1666dnl ---------- 1667dnl "dirname" is not portable, so we fake it with a shell script. 1668AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl 1669dnl --------------------------------------------------------------------------- 1670dnl CF_DIRS_TO_MAKE version: 3 updated: 2002/02/23 20:38:31 1671dnl --------------- 1672AC_DEFUN([CF_DIRS_TO_MAKE], 1673[ 1674DIRS_TO_MAKE="lib" 1675for cf_item in $cf_list_models 1676do 1677 CF_OBJ_SUBDIR($cf_item,cf_subdir) 1678 for cf_item2 in $DIRS_TO_MAKE 1679 do 1680 test $cf_item2 = $cf_subdir && break 1681 done 1682 test ".$cf_item2" != ".$cf_subdir" && DIRS_TO_MAKE="$DIRS_TO_MAKE $cf_subdir" 1683done 1684for cf_dir in $DIRS_TO_MAKE 1685do 1686 test ! -d $cf_dir && mkdir $cf_dir 1687done 1688AC_SUBST(DIRS_TO_MAKE) 1689])dnl 1690dnl --------------------------------------------------------------------------- 1691dnl CF_DISABLE_ECHO version: 13 updated: 2015/04/18 08:56:57 1692dnl --------------- 1693dnl You can always use "make -n" to see the actual options, but it's hard to 1694dnl pick out/analyze warning messages when the compile-line is long. 1695dnl 1696dnl Sets: 1697dnl ECHO_LT - symbol to control if libtool is verbose 1698dnl ECHO_LD - symbol to prefix "cc -o" lines 1699dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) 1700dnl SHOW_CC - symbol to put before explicit "cc -c" lines 1701dnl ECHO_CC - symbol to put before any "cc" line 1702dnl 1703AC_DEFUN([CF_DISABLE_ECHO],[ 1704AC_MSG_CHECKING(if you want to see long compiling messages) 1705CF_ARG_DISABLE(echo, 1706 [ --disable-echo do not display "compiling" commands], 1707 [ 1708 ECHO_LT='--silent' 1709 ECHO_LD='@echo linking [$]@;' 1710 RULE_CC='@echo compiling [$]<' 1711 SHOW_CC='@echo compiling [$]@' 1712 ECHO_CC='@' 1713],[ 1714 ECHO_LT='' 1715 ECHO_LD='' 1716 RULE_CC='' 1717 SHOW_CC='' 1718 ECHO_CC='' 1719]) 1720AC_MSG_RESULT($enableval) 1721AC_SUBST(ECHO_LT) 1722AC_SUBST(ECHO_LD) 1723AC_SUBST(RULE_CC) 1724AC_SUBST(SHOW_CC) 1725AC_SUBST(ECHO_CC) 1726])dnl 1727dnl --------------------------------------------------------------------------- 1728dnl CF_DISABLE_GNAT_PROJECTS version: 1 updated: 2014/06/01 11:34:00 1729dnl ------------------------ 1730AC_DEFUN([CF_DISABLE_GNAT_PROJECTS],[ 1731AC_MSG_CHECKING(if we want to use GNAT projects) 1732CF_ARG_DISABLE(gnat-projects, 1733 [ --disable-gnat-projects test: disable GNAT projects even if usable], 1734 [enable_gnat_projects=no], 1735 [enable_gnat_projects=yes]) 1736AC_MSG_RESULT($enable_gnat_projects) 1737])dnl 1738dnl --------------------------------------------------------------------------- 1739dnl CF_DISABLE_LEAKS version: 7 updated: 2012/10/02 20:55:03 1740dnl ---------------- 1741dnl Combine no-leak checks with the libraries or tools that are used for the 1742dnl checks. 1743AC_DEFUN([CF_DISABLE_LEAKS],[ 1744 1745AC_REQUIRE([CF_WITH_DMALLOC]) 1746AC_REQUIRE([CF_WITH_DBMALLOC]) 1747AC_REQUIRE([CF_WITH_VALGRIND]) 1748 1749AC_MSG_CHECKING(if you want to perform memory-leak testing) 1750AC_ARG_ENABLE(leaks, 1751 [ --disable-leaks test: free permanent memory, analyze leaks], 1752 [if test "x$enableval" = xno; then with_no_leaks=yes; else with_no_leaks=no; fi], 1753 : ${with_no_leaks:=no}) 1754AC_MSG_RESULT($with_no_leaks) 1755 1756if test "$with_no_leaks" = yes ; then 1757 AC_DEFINE(NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.]) 1758 AC_DEFINE(YY_NO_LEAKS,1,[Define to 1 if you want to perform memory-leak testing.]) 1759fi 1760])dnl 1761dnl --------------------------------------------------------------------------- 1762dnl CF_DISABLE_LIBTOOL_VERSION version: 3 updated: 2015/04/17 21:13:04 1763dnl -------------------------- 1764dnl Check if we should use the libtool 1.5 feature "-version-number" instead of 1765dnl the older "-version-info" feature. The newer feature allows us to use 1766dnl version numbering on shared libraries which make them compatible with 1767dnl various systems. 1768AC_DEFUN([CF_DISABLE_LIBTOOL_VERSION], 1769[ 1770AC_MSG_CHECKING(if libtool -version-number should be used) 1771CF_ARG_DISABLE(libtool-version, 1772 [ --disable-libtool-version enable to use libtool's incompatible naming scheme], 1773 [cf_libtool_version=no], 1774 [cf_libtool_version=yes]) 1775AC_MSG_RESULT($cf_libtool_version) 1776 1777if test "$cf_libtool_version" = yes ; then 1778 LIBTOOL_VERSION="-version-number" 1779else 1780 LIBTOOL_VERSION="-version-info" 1781 case "x$VERSION" in 1782 (x) 1783 AC_MSG_WARN(VERSION was not set) 1784 ;; 1785 (x*.*.*) 1786 ABI_VERSION="$VERSION" 1787 CF_VERBOSE(ABI_VERSION: $ABI_VERSION) 1788 ;; 1789 (x*:*:*) 1790 ABI_VERSION=`echo "$VERSION" | sed -e 's/:/./g'` 1791 CF_VERBOSE(ABI_VERSION: $ABI_VERSION) 1792 ;; 1793 (*) 1794 AC_MSG_WARN(unexpected VERSION value: $VERSION) 1795 ;; 1796 esac 1797fi 1798 1799AC_SUBST(ABI_VERSION) 1800AC_SUBST(LIBTOOL_VERSION) 1801])dnl 1802dnl --------------------------------------------------------------------------- 1803dnl CF_DISABLE_RPATH_HACK version: 2 updated: 2011/02/13 13:31:33 1804dnl --------------------- 1805dnl The rpath-hack makes it simpler to build programs, particularly with the 1806dnl *BSD ports which may have essential libraries in unusual places. But it 1807dnl can interfere with building an executable for the base system. Use this 1808dnl option in that case. 1809AC_DEFUN([CF_DISABLE_RPATH_HACK], 1810[ 1811AC_MSG_CHECKING(if rpath-hack should be disabled) 1812CF_ARG_DISABLE(rpath-hack, 1813 [ --disable-rpath-hack don't add rpath options for additional libraries], 1814 [cf_disable_rpath_hack=yes], 1815 [cf_disable_rpath_hack=no]) 1816AC_MSG_RESULT($cf_disable_rpath_hack) 1817if test "$cf_disable_rpath_hack" = no ; then 1818 CF_RPATH_HACK 1819fi 1820]) 1821dnl --------------------------------------------------------------------------- 1822dnl CF_ENABLE_BROKEN_LINKER version: 1 updated: 2020/02/08 15:59:30 1823dnl ----------------------- 1824dnl Some linkers cannot reference a data-only object. Cygwin used to be one. 1825dnl This usually follows CF_LINK_DATAONLY, but is not required in case we need 1826dnl an unconditional feature. 1827AC_DEFUN([CF_ENABLE_BROKEN_LINKER],[ 1828 1829AC_MSG_CHECKING(if you want broken-linker support code) 1830AC_ARG_ENABLE(broken_linker, 1831 [ --enable-broken_linker compile with broken-linker support code], 1832 [with_broken_linker=$enableval], 1833 [with_broken_linker=no]) 1834AC_MSG_RESULT($with_broken_linker) 1835 1836: ${BROKEN_LINKER:=0} 1837if test "x$with_broken_linker" = xyes ; then 1838 AC_DEFINE(BROKEN_LINKER,1,[Define to 1 to work around linkers which cannot link data-only modules]) 1839 BROKEN_LINKER=1 1840fi 1841AC_SUBST(BROKEN_LINKER) 1842])dnl 1843dnl --------------------------------------------------------------------------- 1844dnl CF_ENABLE_PC_FILES version: 13 updated: 2015/11/01 05:27:39 1845dnl ------------------ 1846dnl This is the "--enable-pc-files" option, which is available if there is a 1847dnl pkg-config configuration on the local machine. 1848AC_DEFUN([CF_ENABLE_PC_FILES],[ 1849AC_REQUIRE([CF_PKG_CONFIG]) 1850AC_REQUIRE([CF_WITH_PKG_CONFIG_LIBDIR]) 1851 1852if test "x$PKG_CONFIG" != xnone 1853then 1854 AC_MSG_CHECKING(if we should install .pc files for $PKG_CONFIG) 1855else 1856 AC_MSG_CHECKING(if we should install .pc files) 1857fi 1858 1859AC_ARG_ENABLE(pc-files, 1860 [ --enable-pc-files generate and install .pc files for pkg-config], 1861 [enable_pc_files=$enableval], 1862 [enable_pc_files=no]) 1863AC_MSG_RESULT($enable_pc_files) 1864 1865if test "x$enable_pc_files" != xno 1866then 1867 MAKE_PC_FILES= 1868 case "x$PKG_CONFIG_LIBDIR" in 1869 (xno|xyes) 1870 AC_MSG_WARN(no PKG_CONFIG_LIBDIR was found) 1871 ;; 1872 (*) 1873 CF_PATH_SYNTAX(PKG_CONFIG_LIBDIR) 1874 ;; 1875 esac 1876else 1877 MAKE_PC_FILES="#" 1878fi 1879AC_SUBST(MAKE_PC_FILES) 1880])dnl 1881dnl --------------------------------------------------------------------------- 1882dnl CF_ENABLE_RPATH version: 2 updated: 2010/03/27 18:39:42 1883dnl --------------- 1884dnl Check if the rpath option should be used, setting cache variable 1885dnl cf_cv_enable_rpath if so. 1886AC_DEFUN([CF_ENABLE_RPATH], 1887[ 1888AC_MSG_CHECKING(if rpath option should be used) 1889AC_ARG_ENABLE(rpath, 1890[ --enable-rpath use rpath option when generating shared libraries], 1891[cf_cv_enable_rpath=$enableval], 1892[cf_cv_enable_rpath=no]) 1893AC_MSG_RESULT($cf_cv_enable_rpath) 1894])dnl 1895dnl --------------------------------------------------------------------------- 1896dnl CF_ENABLE_STRING_HACKS version: 5 updated: 2016/10/08 17:34:11 1897dnl ---------------------- 1898dnl On a few platforms, the compiler and/or loader nags with untruthful 1899dnl comments stating that "most" uses of strcat/strcpy/sprintf are incorrect, 1900dnl and implying that most uses of the recommended alternatives are correct. 1901dnl 1902dnl Factually speaking, no one has actually counted the number of uses of these 1903dnl functions versus the total of incorrect uses. Samples of a few thousand 1904dnl instances are meaningless compared to the hundreds of millions of lines of 1905dnl existing C code. 1906dnl 1907dnl strlcat/strlcpy are (as of 2012) non-standard, and are available on some 1908dnl platforms, in implementations of varying quality. Likewise, snprintf is 1909dnl standard - but evolved through phases, and older implementations are likely 1910dnl to yield surprising results, as documented in manpages on various systems. 1911AC_DEFUN([CF_ENABLE_STRING_HACKS], 1912[ 1913AC_MSG_CHECKING(if you want to work around bogus compiler/loader warnings) 1914AC_ARG_ENABLE(string-hacks, 1915 [ --enable-string-hacks work around bogus compiler/loader warnings], 1916 [with_string_hacks=$enableval], 1917 [with_string_hacks=no]) 1918AC_MSG_RESULT($with_string_hacks) 1919 1920if test "x$with_string_hacks" = "xyes"; then 1921 AC_DEFINE(USE_STRING_HACKS,1,[Define to 1 to work around bogus compiler/loader warnings]) 1922 AC_MSG_WARN(enabling string-hacks to work around bogus compiler/loader warnings) 1923 AC_CHECK_FUNC(strlcat,[ 1924 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function]) 1925 ],[ 1926 AC_CHECK_LIB(bsd,strlcat,[ 1927 CF_ADD_LIB(bsd) 1928 AC_CHECK_HEADERS(bsd/string.h) 1929 AC_DEFINE(HAVE_STRLCAT,1,[Define to 1 if we have strlcat function]) 1930 ]) 1931 ]) 1932 AC_CHECK_FUNCS( strlcpy snprintf ) 1933fi 1934])dnl 1935dnl --------------------------------------------------------------------------- 1936dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39 1937dnl -------- 1938dnl Check if 'errno' is declared in <errno.h> 1939AC_DEFUN([CF_ERRNO], 1940[ 1941CF_CHECK_ERRNO(errno) 1942])dnl 1943dnl --------------------------------------------------------------------------- 1944dnl CF_ETIP_DEFINES version: 5 updated: 2012/02/18 17:51:07 1945dnl --------------- 1946dnl Test for conflicting definitions of exception in gcc 2.8.0, etc., between 1947dnl math.h and builtin.h, only for ncurses 1948AC_DEFUN([CF_ETIP_DEFINES], 1949[ 1950AC_MSG_CHECKING(for special defines needed for etip.h) 1951cf_save_CXXFLAGS="$CXXFLAGS" 1952cf_result="none" 1953 1954# etip.h includes ncurses.h which includes ncurses_dll.h 1955# But ncurses_dll.h is generated - fix here. 1956test -d include || mkdir include 1957test -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 1958 1959for cf_math in "" MATH_H 1960do 1961for cf_excp in "" MATH_EXCEPTION 1962do 1963 CXXFLAGS="$cf_save_CXXFLAGS -I${srcdir}/c++ -I${srcdir}/menu -Iinclude -I${srcdir}/include" 1964 test -n "$cf_math" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_math}" 1965 test -n "$cf_excp" && CXXFLAGS="$CXXFLAGS -DETIP_NEEDS_${cf_excp}" 1966AC_TRY_COMPILE([ 1967#include <etip.h.in> 1968],[],[ 1969 test -n "$cf_math" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_math}) 1970 test -n "$cf_excp" && AC_DEFINE_UNQUOTED(ETIP_NEEDS_${cf_excp}) 1971 cf_result="$cf_math $cf_excp" 1972 break 2 1973],[]) 1974done 1975done 1976AC_MSG_RESULT($cf_result) 1977CXXFLAGS="$cf_save_CXXFLAGS" 1978]) 1979dnl --------------------------------------------------------------------------- 1980dnl CF_FIND_LINKAGE version: 21 updated: 2018/06/20 20:23:13 1981dnl --------------- 1982dnl Find a library (specifically the linkage used in the code fragment), 1983dnl searching for it if it is not already in the library path. 1984dnl See also CF_ADD_SEARCHPATH. 1985dnl 1986dnl Parameters (4-on are optional): 1987dnl $1 = headers for library entrypoint 1988dnl $2 = code fragment for library entrypoint 1989dnl $3 = the library name without the "-l" option or ".so" suffix. 1990dnl $4 = action to perform if successful (default: update CPPFLAGS, etc) 1991dnl $5 = action to perform if not successful 1992dnl $6 = module name, if not the same as the library name 1993dnl $7 = extra libraries 1994dnl 1995dnl Sets these variables: 1996dnl $cf_cv_find_linkage_$3 - yes/no according to whether linkage is found 1997dnl $cf_cv_header_path_$3 - include-directory if needed 1998dnl $cf_cv_library_path_$3 - library-directory if needed 1999dnl $cf_cv_library_file_$3 - library-file if needed, e.g., -l$3 2000AC_DEFUN([CF_FIND_LINKAGE],[ 2001 2002# If the linkage is not already in the $CPPFLAGS/$LDFLAGS configuration, these 2003# will be set on completion of the AC_TRY_LINK below. 2004cf_cv_header_path_$3= 2005cf_cv_library_path_$3= 2006 2007CF_MSG_LOG([Starting [FIND_LINKAGE]($3,$6)]) 2008 2009cf_save_LIBS="$LIBS" 2010 2011AC_TRY_LINK([$1],[$2],[ 2012 cf_cv_find_linkage_$3=yes 2013 cf_cv_header_path_$3=/usr/include 2014 cf_cv_library_path_$3=/usr/lib 2015],[ 2016 2017LIBS="-l$3 $7 $cf_save_LIBS" 2018 2019AC_TRY_LINK([$1],[$2],[ 2020 cf_cv_find_linkage_$3=yes 2021 cf_cv_header_path_$3=/usr/include 2022 cf_cv_library_path_$3=/usr/lib 2023 cf_cv_library_file_$3="-l$3" 2024],[ 2025 cf_cv_find_linkage_$3=no 2026 LIBS="$cf_save_LIBS" 2027 2028 CF_VERBOSE(find linkage for $3 library) 2029 CF_MSG_LOG([Searching for headers in [FIND_LINKAGE]($3,$6)]) 2030 2031 cf_save_CPPFLAGS="$CPPFLAGS" 2032 cf_test_CPPFLAGS="$CPPFLAGS" 2033 2034 CF_HEADER_PATH(cf_search,ifelse([$6],,[$3],[$6])) 2035 for cf_cv_header_path_$3 in $cf_search 2036 do 2037 if test -d $cf_cv_header_path_$3 ; then 2038 CF_VERBOSE(... testing $cf_cv_header_path_$3) 2039 CPPFLAGS="$cf_save_CPPFLAGS" 2040 CF_APPEND_TEXT(CPPFLAGS,-I$cf_cv_header_path_$3) 2041 AC_TRY_COMPILE([$1],[$2],[ 2042 CF_VERBOSE(... found $3 headers in $cf_cv_header_path_$3) 2043 cf_cv_find_linkage_$3=maybe 2044 cf_test_CPPFLAGS="$CPPFLAGS" 2045 break],[ 2046 CPPFLAGS="$cf_save_CPPFLAGS" 2047 ]) 2048 fi 2049 done 2050 2051 if test "$cf_cv_find_linkage_$3" = maybe ; then 2052 2053 CF_MSG_LOG([Searching for $3 library in [FIND_LINKAGE]($3,$6)]) 2054 2055 cf_save_LIBS="$LIBS" 2056 cf_save_LDFLAGS="$LDFLAGS" 2057 2058 ifelse([$6],,,[ 2059 CPPFLAGS="$cf_test_CPPFLAGS" 2060 LIBS="-l$3 $7 $cf_save_LIBS" 2061 AC_TRY_LINK([$1],[$2],[ 2062 CF_VERBOSE(... found $3 library in system) 2063 cf_cv_find_linkage_$3=yes]) 2064 CPPFLAGS="$cf_save_CPPFLAGS" 2065 LIBS="$cf_save_LIBS" 2066 ]) 2067 2068 if test "$cf_cv_find_linkage_$3" != yes ; then 2069 CF_LIBRARY_PATH(cf_search,$3) 2070 for cf_cv_library_path_$3 in $cf_search 2071 do 2072 if test -d $cf_cv_library_path_$3 ; then 2073 CF_VERBOSE(... testing $cf_cv_library_path_$3) 2074 CPPFLAGS="$cf_test_CPPFLAGS" 2075 LIBS="-l$3 $7 $cf_save_LIBS" 2076 LDFLAGS="$cf_save_LDFLAGS -L$cf_cv_library_path_$3" 2077 AC_TRY_LINK([$1],[$2],[ 2078 CF_VERBOSE(... found $3 library in $cf_cv_library_path_$3) 2079 cf_cv_find_linkage_$3=yes 2080 cf_cv_library_file_$3="-l$3" 2081 break],[ 2082 CPPFLAGS="$cf_save_CPPFLAGS" 2083 LIBS="$cf_save_LIBS" 2084 LDFLAGS="$cf_save_LDFLAGS" 2085 ]) 2086 fi 2087 done 2088 CPPFLAGS="$cf_save_CPPFLAGS" 2089 LDFLAGS="$cf_save_LDFLAGS" 2090 fi 2091 2092 else 2093 cf_cv_find_linkage_$3=no 2094 fi 2095 ],$7) 2096]) 2097 2098LIBS="$cf_save_LIBS" 2099 2100if test "$cf_cv_find_linkage_$3" = yes ; then 2101ifelse([$4],,[ 2102 CF_ADD_INCDIR($cf_cv_header_path_$3) 2103 CF_ADD_LIBDIR($cf_cv_library_path_$3) 2104 CF_ADD_LIB($3) 2105],[$4]) 2106else 2107ifelse([$5],,AC_MSG_WARN(Cannot find $3 library),[$5]) 2108fi 2109])dnl 2110dnl --------------------------------------------------------------------------- 2111dnl CF_FIND_SUB_INCDIR version: 2 updated: 2015/04/17 21:13:04 2112dnl ------------------ 2113dnl Find an include-directory with the given leaf-name. This is useful for 2114dnl example with FreeBSD ports, which use this convention to distinguish 2115dnl different versions of the same port. 2116AC_DEFUN([CF_FIND_SUB_INCDIR],[ 2117 CF_SUBDIR_PATH(cf_search,$1,include) 2118 for cf_item in $cf_search 2119 do 2120 case $cf_item in 2121 (*/$1) 2122 CF_ADD_INCDIR($cf_item) 2123 ;; 2124 esac 2125 done 2126])dnl 2127dnl --------------------------------------------------------------------------- 2128dnl CF_FIND_SUB_LIBDIR version: 2 updated: 2015/04/17 21:13:04 2129dnl ------------------ 2130dnl Find a library-directory with the given leaf-name. This is useful for 2131dnl example with FreeBSD ports, which use this convention to distinguish 2132dnl different versions of the same port. 2133AC_DEFUN([CF_FIND_SUB_LIBDIR],[ 2134 CF_SUBDIR_PATH(cf_search,$1,lib) 2135 for cf_item in $cf_search 2136 do 2137 case $cf_item in 2138 (*/$1) 2139 CF_ADD_LIBDIR($cf_item) 2140 ;; 2141 esac 2142 done 2143])dnl 2144dnl --------------------------------------------------------------------------- 2145dnl CF_FIXUP_ADAFLAGS version: 2 updated: 2015/04/17 21:13:04 2146dnl ----------------- 2147dnl make ADAFLAGS consistent with CFLAGS 2148AC_DEFUN([CF_FIXUP_ADAFLAGS],[ 2149 AC_MSG_CHECKING(optimization options for ADAFLAGS) 2150 case "$CFLAGS" in 2151 (*-g*) 2152 CF_ADD_ADAFLAGS(-g) 2153 ;; 2154 esac 2155 case "$CFLAGS" in 2156 (*-O*) 2157 cf_O_flag=`echo "$CFLAGS" |sed -e 's/^.*-O/-O/' -e 's/[[ ]].*//'` 2158 CF_ADD_ADAFLAGS($cf_O_flag) 2159 ;; 2160 esac 2161 AC_MSG_RESULT($ADAFLAGS) 2162])dnl 2163dnl --------------------------------------------------------------------------- 2164dnl CF_FOPEN_BIN_R version: 2 updated: 2019/12/31 08:53:54 2165dnl -------------- 2166dnl Check if fopen works when the "b" (binary) flag is added to the mode 2167dnl parameter. POSIX ignores the "b", which c89 specified. Some very old 2168dnl systems do not accept it. 2169AC_DEFUN([CF_FOPEN_BIN_R],[ 2170AC_CACHE_CHECK(if fopen accepts explicit binary mode,cf_cv_fopen_bin_r,[ 2171 AC_TRY_RUN([ 2172#include <stdio.h> 2173int main(void) { 2174 FILE *fp = fopen("conftest.tmp", "wb"); 2175 int rc = 0; 2176 if (fp != 0) { 2177 int p, q; 2178 for (p = 0; p < 256; ++p) { 2179 fputc(p, fp); 2180 } 2181 fclose(fp); 2182 fp = fopen("conftest.tmp", "rb"); 2183 if (fp != 0) { 2184 for (p = 0; p < 256; ++p) { 2185 q = fgetc(fp); 2186 if (q != p) { 2187 rc = 1; 2188 break; 2189 } 2190 } 2191 } else { 2192 rc = 1; 2193 } 2194 } else { 2195 rc = 1; 2196 } 2197 ${cf_cv_main_return:-return} (rc); 2198} 2199], 2200 [cf_cv_fopen_bin_r=yes], 2201 [cf_cv_fopen_bin_r=no], 2202 [cf_cv_fopen_bin_r=unknown]) 2203]) 2204test "x$cf_cv_fopen_bin_r" != xno && AC_DEFINE(USE_FOPEN_BIN_R,1,[Define to 1 if fopen accepts explicit binary mode]) 2205])dnl 2206dnl --------------------------------------------------------------------------- 2207dnl CF_FORGET_TOOL version: 1 updated: 2013/04/06 18:03:09 2208dnl -------------- 2209dnl Forget that we saw the given tool. 2210AC_DEFUN([CF_FORGET_TOOL],[ 2211unset ac_cv_prog_ac_ct_$1 2212unset ac_ct_$1 2213unset $1 2214])dnl 2215dnl --------------------------------------------------------------------------- 2216dnl CF_FUNC_DLSYM version: 4 updated: 2015/09/12 14:46:44 2217dnl ------------- 2218dnl Test for dlsym() and related functions, as well as libdl. 2219dnl 2220dnl Sets 2221dnl $cf_have_dlsym 2222dnl $cf_have_libdl 2223AC_DEFUN([CF_FUNC_DLSYM],[ 2224cf_have_dlsym=no 2225AC_CHECK_FUNC(dlsym,cf_have_dlsym=yes,[ 2226 2227cf_have_libdl=no 2228AC_CHECK_LIB(dl,dlsym,[ 2229 cf_have_dlsym=yes 2230 cf_have_libdl=yes])]) 2231 2232if test "$cf_have_dlsym" = yes ; then 2233 test "$cf_have_libdl" = yes && { CF_ADD_LIB(dl) } 2234 2235 AC_MSG_CHECKING(whether able to link to dl*() functions) 2236 AC_TRY_LINK([#include <dlfcn.h>],[ 2237 void *obj; 2238 if ((obj = dlopen("filename", 0)) != 0) { 2239 if (dlsym(obj, "symbolname") == 0) { 2240 dlclose(obj); 2241 } 2242 }],[ 2243 AC_DEFINE(HAVE_LIBDL,1,[Define to 1 if we have dl library])],[ 2244 AC_MSG_ERROR(Cannot link test program for libdl)]) 2245 AC_MSG_RESULT(ok) 2246else 2247 AC_MSG_ERROR(Cannot find dlsym function) 2248fi 2249]) 2250dnl --------------------------------------------------------------------------- 2251dnl CF_FUNC_MEMMOVE version: 9 updated: 2017/01/21 11:06:25 2252dnl --------------- 2253dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither 2254dnl is found, add our own version of memmove to the list of objects. 2255AC_DEFUN([CF_FUNC_MEMMOVE], 2256[ 2257AC_CHECK_FUNC(memmove,,[ 2258AC_CHECK_FUNC(bcopy,[ 2259 AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ 2260 AC_TRY_RUN([ 2261int main(void) { 2262 static char data[] = "abcdefghijklmnopqrstuwwxyz"; 2263 char temp[40]; 2264 bcopy(data, temp, sizeof(data)); 2265 bcopy(temp+10, temp, 15); 2266 bcopy(temp+5, temp+15, 10); 2267 ${cf_cv_main_return:-return} (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); 2268} 2269 ], 2270 [cf_cv_good_bcopy=yes], 2271 [cf_cv_good_bcopy=no], 2272 [cf_cv_good_bcopy=unknown]) 2273 ]) 2274 ],[cf_cv_good_bcopy=no]) 2275 if test "$cf_cv_good_bcopy" = yes ; then 2276 AC_DEFINE(USE_OK_BCOPY,1,[Define to 1 to use bcopy when memmove is unavailable]) 2277 else 2278 AC_DEFINE(USE_MY_MEMMOVE,1,[Define to 1 to use replacement function when memmove is unavailable]) 2279 fi 2280])])dnl 2281dnl --------------------------------------------------------------------------- 2282dnl CF_FUNC_NANOSLEEP version: 5 updated: 2017/01/21 11:06:25 2283dnl ----------------- 2284dnl Check for existence of workable nanosleep() function. Some systems, e.g., 2285dnl AIX 4.x, provide a non-working version. 2286AC_DEFUN([CF_FUNC_NANOSLEEP],[ 2287AC_CACHE_CHECK(if nanosleep really works,cf_cv_func_nanosleep,[ 2288AC_TRY_RUN([ 2289#include <stdio.h> 2290#include <errno.h> 2291#include <time.h> 2292 2293#ifdef HAVE_SYS_TIME_H 2294#include <sys/time.h> 2295#endif 2296 2297int main(void) { 2298 struct timespec ts1, ts2; 2299 int code; 2300 ts1.tv_sec = 0; 2301 ts1.tv_nsec = 750000000; 2302 ts2.tv_sec = 0; 2303 ts2.tv_nsec = 0; 2304 errno = 0; 2305 code = nanosleep(&ts1, &ts2); /* on failure errno is ENOSYS. */ 2306 ${cf_cv_main_return:-return}(code != 0); 2307} 2308], 2309 [cf_cv_func_nanosleep=yes], 2310 [cf_cv_func_nanosleep=no], 2311 [cf_cv_func_nanosleep=unknown])]) 2312 2313test "$cf_cv_func_nanosleep" = "yes" && AC_DEFINE(HAVE_NANOSLEEP,1,[Define to 1 if we have nanosleep()]) 2314]) 2315dnl --------------------------------------------------------------------------- 2316dnl CF_FUNC_OPENPTY version: 5 updated: 2015/09/12 14:46:50 2317dnl --------------- 2318dnl Check for openpty() function, along with <pty.h> header. It may need the 2319dnl "util" library as well. 2320AC_DEFUN([CF_FUNC_OPENPTY], 2321[ 2322AC_CHECK_LIB(util,openpty,cf_cv_lib_util=yes,cf_cv_lib_util=no) 2323AC_CACHE_CHECK(for openpty header,cf_cv_func_openpty,[ 2324 cf_save_LIBS="$LIBS" 2325 test $cf_cv_lib_util = yes && { CF_ADD_LIB(util) } 2326 for cf_header in pty.h libutil.h util.h 2327 do 2328 AC_TRY_LINK([ 2329#include <$cf_header> 2330],[ 2331 int x = openpty((int *)0, (int *)0, (char *)0, 2332 (struct termios *)0, (struct winsize *)0); 2333],[ 2334 cf_cv_func_openpty=$cf_header 2335 break 2336],[ 2337 cf_cv_func_openpty=no 2338]) 2339 done 2340 LIBS="$cf_save_LIBS" 2341]) 2342])dnl 2343dnl --------------------------------------------------------------------------- 2344dnl CF_FUNC_POLL version: 9 updated: 2015/10/10 13:27:32 2345dnl ------------ 2346dnl See if the poll function really works. Some platforms have poll(), but 2347dnl it does not work for terminals or files. 2348AC_DEFUN([CF_FUNC_POLL],[ 2349tty 2>&1 >/dev/null || { AC_CHECK_FUNCS(posix_openpt) } 2350AC_CACHE_CHECK(if poll really works,cf_cv_working_poll,[ 2351AC_TRY_RUN([ 2352#include <stdlib.h> 2353#include <stdio.h> 2354#include <unistd.h> 2355#include <fcntl.h> 2356#ifdef HAVE_POLL_H 2357#include <poll.h> 2358#else 2359#include <sys/poll.h> 2360#endif 2361int main(void) { 2362 struct pollfd myfds; 2363 int ret; 2364 2365 /* check for Darwin bug with respect to "devices" */ 2366 myfds.fd = open("/dev/null", 1); /* O_WRONLY */ 2367 if (myfds.fd < 0) 2368 myfds.fd = 0; 2369 myfds.events = POLLIN; 2370 myfds.revents = 0; 2371 2372 ret = poll(&myfds, 1, 100); 2373 2374 if (ret < 0 || (myfds.revents & POLLNVAL)) { 2375 ret = -1; 2376 } else { 2377 int fd = 0; 2378 if (!isatty(fd)) { 2379 fd = open("/dev/tty", 2); /* O_RDWR */ 2380 } 2381#ifdef HAVE_POSIX_OPENPT 2382 if (fd < 0) { 2383 fd = posix_openpt(O_RDWR); 2384 } 2385#endif 2386 2387 if (fd >= 0) { 2388 /* also check with standard input */ 2389 myfds.fd = fd; 2390 myfds.events = POLLIN; 2391 myfds.revents = 0; 2392 ret = poll(&myfds, 1, 100); 2393 } else { 2394 ret = -1; 2395 } 2396 } 2397 ${cf_cv_main_return:-return}(ret < 0); 2398}], 2399 [cf_cv_working_poll=yes], 2400 [cf_cv_working_poll=no], 2401 [cf_cv_working_poll=unknown])]) 2402test "$cf_cv_working_poll" = "yes" && AC_DEFINE(HAVE_WORKING_POLL,1,[Define to 1 if the poll function seems to work]) 2403])dnl 2404dnl --------------------------------------------------------------------------- 2405dnl CF_FUNC_TERMIOS version: 3 updated: 2012/10/06 17:56:13 2406dnl --------------- 2407dnl Some old/broken variations define tcgetattr() only as a macro in 2408dnl termio(s).h 2409AC_DEFUN([CF_FUNC_TERMIOS],[ 2410AC_REQUIRE([CF_STRUCT_TERMIOS]) 2411AC_CACHE_CHECK(for tcgetattr, cf_cv_have_tcgetattr,[ 2412AC_TRY_LINK([ 2413#include <sys/types.h> 2414#ifdef HAVE_UNISTD_H 2415#include <unistd.h> 2416#endif 2417#ifdef HAVE_TERMIOS_H 2418#include <termios.h> 2419#define TTY struct termios 2420#else 2421#ifdef HAVE_TERMIO_H 2422#include <termio.h> 2423#define TTY struct termio 2424#endif 2425#endif 2426],[ 2427TTY foo; 2428tcgetattr(1, &foo);], 2429[cf_cv_have_tcgetattr=yes], 2430[cf_cv_have_tcgetattr=no])]) 2431test "$cf_cv_have_tcgetattr" = yes && AC_DEFINE(HAVE_TCGETATTR,1,[Define to 1 if we have tcgetattr]) 2432])dnl 2433dnl --------------------------------------------------------------------------- 2434dnl CF_FUNC_VSSCANF version: 6 updated: 2015/04/18 08:56:57 2435dnl --------------- 2436dnl Check for vsscanf() function, which is in c9x but generally not in earlier 2437dnl versions of C. It is in the GNU C library, and can often be simulated by 2438dnl other functions. 2439AC_DEFUN([CF_FUNC_VSSCANF], 2440[ 2441AC_CACHE_CHECK(for vsscanf function or workaround,cf_cv_func_vsscanf,[ 2442AC_TRY_LINK([ 2443#include <stdarg.h> 2444#include <stdio.h>],[ 2445 va_list ap; 2446 vsscanf("from", "%d", ap)],[cf_cv_func_vsscanf=vsscanf],[ 2447AC_TRY_LINK([ 2448#include <stdarg.h> 2449#include <stdio.h>],[ 2450 FILE strbuf; 2451 char *str = "from"; 2452 2453 strbuf._flag = _IOREAD; 2454 strbuf._ptr = strbuf._base = (unsigned char *) str; 2455 strbuf._cnt = strlen(str); 2456 strbuf._file = _NFILE; 2457 return (vfscanf(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=vfscanf],[ 2458AC_TRY_LINK([ 2459#include <stdarg.h> 2460#include <stdio.h>],[ 2461 FILE strbuf; 2462 char *str = "from"; 2463 2464 strbuf._flag = _IOREAD; 2465 strbuf._ptr = strbuf._base = (unsigned char *) str; 2466 strbuf._cnt = strlen(str); 2467 strbuf._file = _NFILE; 2468 return (_doscan(&strbuf, "%d", ap))],[cf_cv_func_vsscanf=_doscan],[ 2469cf_cv_func_vsscanf=no])])])]) 2470 2471case $cf_cv_func_vsscanf in 2472(vsscanf) AC_DEFINE(HAVE_VSSCANF,1,[Define to 1 if we have vsscanf]);; 2473(vfscanf) AC_DEFINE(HAVE_VFSCANF,1,[Define to 1 if we have vfscanf]);; 2474(_doscan) AC_DEFINE(HAVE__DOSCAN,1,[Define to 1 if we have _doscan]);; 2475esac 2476 2477])dnl 2478dnl --------------------------------------------------------------------------- 2479dnl CF_GCC_ATTRIBUTES version: 17 updated: 2015/04/12 15:39:00 2480dnl ----------------- 2481dnl Test for availability of useful gcc __attribute__ directives to quiet 2482dnl compiler warnings. Though useful, not all are supported -- and contrary 2483dnl to documentation, unrecognized directives cause older compilers to barf. 2484AC_DEFUN([CF_GCC_ATTRIBUTES], 2485[ 2486if test "$GCC" = yes 2487then 2488cat > conftest.i <<EOF 2489#ifndef GCC_PRINTF 2490#define GCC_PRINTF 0 2491#endif 2492#ifndef GCC_SCANF 2493#define GCC_SCANF 0 2494#endif 2495#ifndef GCC_NORETURN 2496#define GCC_NORETURN /* nothing */ 2497#endif 2498#ifndef GCC_UNUSED 2499#define GCC_UNUSED /* nothing */ 2500#endif 2501EOF 2502if test "$GCC" = yes 2503then 2504 AC_CHECKING([for $CC __attribute__ directives]) 2505cat > conftest.$ac_ext <<EOF 2506#line __oline__ "${as_me:-configure}" 2507#include "confdefs.h" 2508#include "conftest.h" 2509#include "conftest.i" 2510#if GCC_PRINTF 2511#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var))) 2512#else 2513#define GCC_PRINTFLIKE(fmt,var) /*nothing*/ 2514#endif 2515#if GCC_SCANF 2516#define GCC_SCANFLIKE(fmt,var) __attribute__((format(scanf,fmt,var))) 2517#else 2518#define GCC_SCANFLIKE(fmt,var) /*nothing*/ 2519#endif 2520extern void wow(char *,...) GCC_SCANFLIKE(1,2); 2521extern void oops(char *,...) GCC_PRINTFLIKE(1,2) GCC_NORETURN; 2522extern void foo(void) GCC_NORETURN; 2523int main(int argc GCC_UNUSED, char *argv[[]] GCC_UNUSED) { return 0; } 2524EOF 2525 cf_printf_attribute=no 2526 cf_scanf_attribute=no 2527 for cf_attribute in scanf printf unused noreturn 2528 do 2529 CF_UPPER(cf_ATTRIBUTE,$cf_attribute) 2530 cf_directive="__attribute__(($cf_attribute))" 2531 echo "checking for $CC $cf_directive" 1>&AC_FD_CC 2532 2533 case $cf_attribute in 2534 (printf) 2535 cf_printf_attribute=yes 2536 cat >conftest.h <<EOF 2537#define GCC_$cf_ATTRIBUTE 1 2538EOF 2539 ;; 2540 (scanf) 2541 cf_scanf_attribute=yes 2542 cat >conftest.h <<EOF 2543#define GCC_$cf_ATTRIBUTE 1 2544EOF 2545 ;; 2546 (*) 2547 cat >conftest.h <<EOF 2548#define GCC_$cf_ATTRIBUTE $cf_directive 2549EOF 2550 ;; 2551 esac 2552 2553 if AC_TRY_EVAL(ac_compile); then 2554 test -n "$verbose" && AC_MSG_RESULT(... $cf_attribute) 2555 cat conftest.h >>confdefs.h 2556 case $cf_attribute in 2557 (noreturn) 2558 AC_DEFINE_UNQUOTED(GCC_NORETURN,$cf_directive,[Define to noreturn-attribute for gcc]) 2559 ;; 2560 (printf) 2561 cf_value='/* nothing */' 2562 if test "$cf_printf_attribute" != no ; then 2563 cf_value='__attribute__((format(printf,fmt,var)))' 2564 AC_DEFINE(GCC_PRINTF,1,[Define to 1 if the compiler supports gcc-like printf attribute.]) 2565 fi 2566 AC_DEFINE_UNQUOTED(GCC_PRINTFLIKE(fmt,var),$cf_value,[Define to printf-attribute for gcc]) 2567 ;; 2568 (scanf) 2569 cf_value='/* nothing */' 2570 if test "$cf_scanf_attribute" != no ; then 2571 cf_value='__attribute__((format(scanf,fmt,var)))' 2572 AC_DEFINE(GCC_SCANF,1,[Define to 1 if the compiler supports gcc-like scanf attribute.]) 2573 fi 2574 AC_DEFINE_UNQUOTED(GCC_SCANFLIKE(fmt,var),$cf_value,[Define to sscanf-attribute for gcc]) 2575 ;; 2576 (unused) 2577 AC_DEFINE_UNQUOTED(GCC_UNUSED,$cf_directive,[Define to unused-attribute for gcc]) 2578 ;; 2579 esac 2580 fi 2581 done 2582else 2583 fgrep define conftest.i >>confdefs.h 2584fi 2585rm -rf conftest* 2586fi 2587])dnl 2588dnl --------------------------------------------------------------------------- 2589dnl CF_GCC_VERSION version: 8 updated: 2019/09/07 13:38:36 2590dnl -------------- 2591dnl Find version of gcc, and (because icc/clang pretend to be gcc without being 2592dnl compatible), attempt to determine if icc/clang is actually used. 2593AC_DEFUN([CF_GCC_VERSION],[ 2594AC_REQUIRE([AC_PROG_CC]) 2595GCC_VERSION=none 2596if test "$GCC" = yes ; then 2597 AC_MSG_CHECKING(version of $CC) 2598 GCC_VERSION="`${CC} --version 2>/dev/null | sed -e '2,$d' -e 's/^.*(GCC[[^)]]*) //' -e 's/^.*(Debian[[^)]]*) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" 2599 test -z "$GCC_VERSION" && GCC_VERSION=unknown 2600 AC_MSG_RESULT($GCC_VERSION) 2601fi 2602CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS) 2603CF_CLANG_COMPILER(GCC,CLANG_COMPILER,CFLAGS) 2604])dnl 2605dnl --------------------------------------------------------------------------- 2606dnl CF_GCC_WARNINGS version: 37 updated: 2020/01/05 20:04:12 2607dnl --------------- 2608dnl Check if the compiler supports useful warning options. There's a few that 2609dnl we don't use, simply because they're too noisy: 2610dnl 2611dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) 2612dnl -Winline (usually not worthwhile) 2613dnl -Wredundant-decls (system headers make this too noisy) 2614dnl -Wtraditional (combines too many unrelated messages, only a few useful) 2615dnl -Wwrite-strings (too noisy, but should review occasionally). This 2616dnl is enabled for ncurses using "--enable-const". 2617dnl -pedantic 2618dnl 2619dnl Parameter: 2620dnl $1 is an optional list of gcc warning flags that a particular 2621dnl application might want to use, e.g., "no-unused" for 2622dnl -Wno-unused 2623dnl Special: 2624dnl If $with_ext_const is "yes", add a check for -Wwrite-strings 2625dnl 2626AC_DEFUN([CF_GCC_WARNINGS], 2627[ 2628AC_REQUIRE([CF_GCC_VERSION]) 2629if test "x$have_x" = xyes; then CF_CONST_X_STRING fi 2630cat > conftest.$ac_ext <<EOF 2631#line __oline__ "${as_me:-configure}" 2632int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; } 2633EOF 2634if test "$INTEL_COMPILER" = yes 2635then 2636# The "-wdXXX" options suppress warnings: 2637# remark #1419: external declaration in primary source file 2638# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 2639# remark #1684: conversion from pointer to same-sized integral type (potential portability problem) 2640# remark #193: zero used for undefined preprocessing identifier 2641# remark #593: variable "curs_sb_left_arrow" was set but never used 2642# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits 2643# remark #869: parameter "tw" was never referenced 2644# remark #981: operands are evaluated in unspecified order 2645# warning #279: controlling expression is constant 2646 2647 AC_CHECKING([for $CC warning options]) 2648 cf_save_CFLAGS="$CFLAGS" 2649 EXTRA_CFLAGS="-Wall" 2650 for cf_opt in \ 2651 wd1419 \ 2652 wd1683 \ 2653 wd1684 \ 2654 wd193 \ 2655 wd593 \ 2656 wd279 \ 2657 wd810 \ 2658 wd869 \ 2659 wd981 2660 do 2661 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" 2662 if AC_TRY_EVAL(ac_compile); then 2663 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 2664 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" 2665 fi 2666 done 2667 CFLAGS="$cf_save_CFLAGS" 2668elif test "$GCC" = yes && test "$GCC_VERSION" != "unknown" 2669then 2670 AC_CHECKING([for $CC warning options]) 2671 cf_save_CFLAGS="$CFLAGS" 2672 EXTRA_CFLAGS= 2673 cf_warn_CONST="" 2674 test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings" 2675 cf_gcc_warnings="Wignored-qualifiers Wlogical-op Wvarargs" 2676 test "x$CLANG_COMPILER" = xyes && cf_gcc_warnings= 2677 for cf_opt in W Wall \ 2678 Wbad-function-cast \ 2679 Wcast-align \ 2680 Wcast-qual \ 2681 Wdeclaration-after-statement \ 2682 Wextra \ 2683 Winline \ 2684 Wmissing-declarations \ 2685 Wmissing-prototypes \ 2686 Wnested-externs \ 2687 Wpointer-arith \ 2688 Wshadow \ 2689 Wstrict-prototypes \ 2690 Wundef Wno-inline $cf_gcc_warnings $cf_warn_CONST $1 2691 do 2692 CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" 2693 if AC_TRY_EVAL(ac_compile); then 2694 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 2695 case $cf_opt in 2696 (Winline) 2697 case $GCC_VERSION in 2698 ([[34]].*) 2699 CF_VERBOSE(feature is broken in gcc $GCC_VERSION) 2700 continue;; 2701 esac 2702 ;; 2703 (Wpointer-arith) 2704 case $GCC_VERSION in 2705 ([[12]].*) 2706 CF_VERBOSE(feature is broken in gcc $GCC_VERSION) 2707 continue;; 2708 esac 2709 ;; 2710 esac 2711 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" 2712 fi 2713 done 2714 CFLAGS="$cf_save_CFLAGS" 2715fi 2716rm -rf conftest* 2717 2718AC_SUBST(EXTRA_CFLAGS) 2719])dnl 2720dnl --------------------------------------------------------------------------- 2721dnl CF_GETOPT_HEADER version: 6 updated: 2014/07/22 14:45:54 2722dnl ---------------- 2723dnl Check for getopt's variables which are commonly defined in stdlib.h, 2724dnl unistd.h or (nonstandard) in getopt.h 2725AC_DEFUN([CF_GETOPT_HEADER], 2726[ 2727AC_HAVE_HEADERS(unistd.h getopt.h) 2728AC_CACHE_CHECK(for header declaring getopt variables,cf_cv_getopt_header,[ 2729cf_cv_getopt_header=none 2730for cf_header in stdio.h stdlib.h unistd.h getopt.h 2731do 2732AC_TRY_COMPILE([ 2733#include <$cf_header>], 2734[int x = optind; char *y = optarg], 2735[cf_cv_getopt_header=$cf_header 2736 break]) 2737done 2738]) 2739if test $cf_cv_getopt_header != none ; then 2740 AC_DEFINE(HAVE_GETOPT_HEADER,1,[Define to 1 if getopt variables are declared in header]) 2741fi 2742if test $cf_cv_getopt_header = getopt.h ; then 2743 AC_DEFINE(NEED_GETOPT_H,1,[Define to 1 if we must include getopt.h]) 2744fi 2745])dnl 2746dnl --------------------------------------------------------------------------- 2747dnl CF_GNATPREP_OPT_T version: 1 updated: 2014/08/02 18:37:25 2748dnl ----------------- 2749AC_DEFUN([CF_GNATPREP_OPT_T],[ 2750AC_CACHE_CHECK(if GNATPREP supports -T option,cf_cv_gnatprep_opt_t,[ 2751cf_cv_gnatprep_opt_t=no 2752gnatprep -T 2>/dev/null >/dev/null && cf_cv_gnatprep_opt_t=yes 2753]) 2754test "$cf_cv_gnatprep_opt_t" = yes && GNATPREP_OPTS="-T $GNATPREP_OPTS" 2755AC_SUBST(GNATPREP_OPTS) 2756])dnl 2757dnl --------------------------------------------------------------------------- 2758dnl CF_GNAT_GENERICS version: 4 updated: 2019/12/31 08:53:54 2759dnl ---------------- 2760AC_DEFUN([CF_GNAT_GENERICS], 2761[ 2762AC_REQUIRE([CF_GNAT_VERSION]) 2763 2764AC_MSG_CHECKING(if GNAT supports generics) 2765case $cf_cv_gnat_version in 2766(3.[[1-9]]*|[[4-9]].*) 2767 cf_gnat_generics=yes 2768 ;; 2769(*) 2770 cf_gnat_generics=no 2771 ;; 2772esac 2773AC_MSG_RESULT($cf_gnat_generics) 2774 2775if test "$cf_gnat_generics" = yes 2776then 2777 cf_compile_generics=generics 2778 cf_generic_objects="\${GENOBJS}" 2779else 2780 cf_compile_generics= 2781 cf_generic_objects= 2782fi 2783 2784AC_SUBST(cf_compile_generics) 2785AC_SUBST(cf_generic_objects) 2786])dnl 2787dnl --------------------------------------------------------------------------- 2788dnl CF_GNAT_PROJECTS version: 10 updated: 2019/12/31 08:53:54 2789dnl ---------------- 2790dnl GNAT projects are configured with ".gpr" project files. 2791dnl GNAT libraries are a further development, using the project feature. 2792AC_DEFUN([CF_GNAT_PROJECTS], 2793[ 2794AC_REQUIRE([CF_GNAT_VERSION]) 2795AC_REQUIRE([CF_DISABLE_GNAT_PROJECTS]) 2796 2797cf_gnat_libraries=no 2798cf_gnat_projects=no 2799 2800if test "$enable_gnat_projects" != no ; then 2801AC_MSG_CHECKING(if GNAT supports project files) 2802case $cf_cv_gnat_version in 2803(3.[[0-9]]*) 2804 ;; 2805(*) 2806 case $cf_cv_system_name in 2807 (cygwin*|msys*) 2808 ;; 2809 (*) 2810 rm -rf conftest* *~conftest* 2811 if mkdir conftest.src conftest.bin conftest.lib 2812 then 2813 cd conftest.src 2814 rm -rf conftest* *~conftest* 2815 cat >>library.gpr <<CF_EOF 2816project Library is 2817 Kind := External ("LIB_KIND"); 2818 for Library_Name use "ConfTest"; 2819 for Object_Dir use "."; 2820 for Library_ALI_Dir use External("LIBRARY_DIR"); 2821 for Library_Version use External ("SONAME"); 2822 for Library_Kind use Kind; 2823 for Library_Dir use External("BUILD_DIR"); 2824 Source_Dir := External ("SOURCE_DIR"); 2825 for Source_Dirs use (Source_Dir); 2826end Library; 2827CF_EOF 2828 cat >>confpackage.ads <<CF_EOF 2829package ConfPackage is 2830 procedure conftest; 2831end ConfPackage; 2832CF_EOF 2833 cat >>confpackage.adb <<CF_EOF 2834with Text_IO; 2835package body ConfPackage is 2836 procedure conftest is 2837 begin 2838 Text_IO.Put ("Hello World"); 2839 Text_IO.New_Line; 2840 end conftest; 2841end ConfPackage; 2842CF_EOF 2843 if ( $cf_ada_make $ADAFLAGS \ 2844 -Plibrary.gpr \ 2845 -XBUILD_DIR=`cd ../conftest.bin;pwd` \ 2846 -XLIBRARY_DIR=`cd ../conftest.lib;pwd` \ 2847 -XSOURCE_DIR=`pwd` \ 2848 -XSONAME=libConfTest.so.1 \ 2849 -XLIB_KIND=static 1>&AC_FD_CC 2>&1 ) ; then 2850 cf_gnat_projects=yes 2851 fi 2852 cd .. 2853 fi 2854 if test -f conftest.lib/confpackage.ali 2855 then 2856 cf_gnat_libraries=yes 2857 fi 2858 rm -rf conftest* *~conftest* 2859 ;; 2860 esac 2861 ;; 2862esac 2863AC_MSG_RESULT($cf_gnat_projects) 2864fi # enable_gnat_projects 2865 2866if test $cf_gnat_projects = yes 2867then 2868 AC_MSG_CHECKING(if GNAT supports libraries) 2869 AC_MSG_RESULT($cf_gnat_libraries) 2870fi 2871 2872if test "$cf_gnat_projects" = yes 2873then 2874 USE_OLD_MAKERULES="#" 2875 USE_GNAT_PROJECTS="" 2876else 2877 USE_OLD_MAKERULES="" 2878 USE_GNAT_PROJECTS="#" 2879fi 2880 2881if test "$cf_gnat_libraries" = yes 2882then 2883 USE_GNAT_LIBRARIES="" 2884else 2885 USE_GNAT_LIBRARIES="#" 2886fi 2887 2888AC_SUBST(USE_OLD_MAKERULES) 2889AC_SUBST(USE_GNAT_PROJECTS) 2890AC_SUBST(USE_GNAT_LIBRARIES) 2891])dnl 2892dnl --------------------------------------------------------------------------- 2893dnl CF_GNAT_SIGINT version: 1 updated: 2011/03/27 20:07:59 2894dnl -------------- 2895dnl Check if gnat supports SIGINT, and presumably tasking. For the latter, it 2896dnl is noted that gnat may compile a tasking unit even for configurations which 2897dnl fail at runtime. 2898AC_DEFUN([CF_GNAT_SIGINT],[ 2899AC_CACHE_CHECK(if GNAT supports SIGINT,cf_cv_gnat_sigint,[ 2900CF_GNAT_TRY_LINK([with Ada.Interrupts.Names; 2901 2902package ConfTest is 2903 2904 pragma Warnings (Off); -- the next pragma exists since 3.11p 2905 pragma Unreserve_All_Interrupts; 2906 pragma Warnings (On); 2907 2908 protected Process is 2909 procedure Stop; 2910 function Continue return Boolean; 2911 pragma Attach_Handler (Stop, Ada.Interrupts.Names.SIGINT); 2912 private 2913 Done : Boolean := False; 2914 end Process; 2915 2916end ConfTest;], 2917[package body ConfTest is 2918 protected body Process is 2919 procedure Stop is 2920 begin 2921 Done := True; 2922 end Stop; 2923 function Continue return Boolean is 2924 begin 2925 return not Done; 2926 end Continue; 2927 end Process; 2928end ConfTest;], 2929 [cf_cv_gnat_sigint=yes], 2930 [cf_cv_gnat_sigint=no])]) 2931 2932if test $cf_cv_gnat_sigint = yes ; then 2933 USE_GNAT_SIGINT="" 2934else 2935 USE_GNAT_SIGINT="#" 2936fi 2937AC_SUBST(USE_GNAT_SIGINT) 2938])dnl 2939dnl --------------------------------------------------------------------------- 2940dnl CF_GNAT_TRY_LINK version: 3 updated: 2011/03/19 14:47:45 2941dnl ---------------- 2942dnl Verify that a test program compiles/links with GNAT. 2943dnl $cf_ada_make is set to the program that compiles/links 2944dnl $ADAFLAGS may be set to the GNAT flags. 2945dnl 2946dnl $1 is the text of the spec 2947dnl $2 is the text of the body 2948dnl $3 is the shell command to execute if successful 2949dnl $4 is the shell command to execute if not successful 2950AC_DEFUN([CF_GNAT_TRY_LINK], 2951[ 2952rm -rf conftest* *~conftest* 2953cat >>conftest.ads <<CF_EOF 2954$1 2955CF_EOF 2956cat >>conftest.adb <<CF_EOF 2957$2 2958CF_EOF 2959if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then 2960ifelse($3,, :,[ $3]) 2961ifelse($4,,,[else 2962 $4]) 2963fi 2964rm -rf conftest* *~conftest* 2965])dnl 2966dnl --------------------------------------------------------------------------- 2967dnl CF_GNAT_TRY_RUN version: 5 updated: 2011/03/19 14:47:45 2968dnl --------------- 2969dnl Verify that a test program compiles and runs with GNAT 2970dnl $cf_ada_make is set to the program that compiles/links 2971dnl $ADAFLAGS may be set to the GNAT flags. 2972dnl 2973dnl $1 is the text of the spec 2974dnl $2 is the text of the body 2975dnl $3 is the shell command to execute if successful 2976dnl $4 is the shell command to execute if not successful 2977AC_DEFUN([CF_GNAT_TRY_RUN], 2978[ 2979rm -rf conftest* *~conftest* 2980cat >>conftest.ads <<CF_EOF 2981$1 2982CF_EOF 2983cat >>conftest.adb <<CF_EOF 2984$2 2985CF_EOF 2986if ( $cf_ada_make $ADAFLAGS conftest 1>&AC_FD_CC 2>&1 ) ; then 2987 if ( ./conftest 1>&AC_FD_CC 2>&1 ) ; then 2988ifelse($3,, :,[ $3]) 2989ifelse($4,,,[ else 2990 $4]) 2991 fi 2992ifelse($4,,,[else 2993 $4]) 2994fi 2995rm -rf conftest* *~conftest* 2996])dnl 2997dnl --------------------------------------------------------------------------- 2998dnl CF_GNAT_VERSION version: 22 updated: 2019/12/31 08:53:54 2999dnl --------------- 3000dnl $1 = cache variable to update 3001dnl $2 = program name 3002dnl Verify version of GNAT or related tool 3003AC_DEFUN([CF_GNAT_VERSION], 3004[ 3005AC_CACHE_CHECK(for ifelse($2,,gnat,$2) version, cf_cv_gnat_version,[ 3006cf_cv_gnat_version=`ifelse($2,,${cf_ada_make:-gnatmake},$2) --version 2>&1 | \ 3007 grep '[[0-9]].[[0-9]][[0-9]]*' |\ 3008 sed -e '2,$d' -e 's/[[^0-9 \.]]//g' -e 's/^[[ ]]*//' -e 's/ .*//'` 3009]) 3010test -z "$cf_cv_gnat_version" && cf_cv_gnat_version=no 3011ifelse($1,,,[eval $1=$cf_cv_gnat_version; unset cf_cv_gnat_version]) 3012])dnl 3013dnl --------------------------------------------------------------------------- 3014dnl CF_GNU_SOURCE version: 10 updated: 2018/12/10 20:09:41 3015dnl ------------- 3016dnl Check if we must define _GNU_SOURCE to get a reasonable value for 3017dnl _XOPEN_SOURCE, upon which many POSIX definitions depend. This is a defect 3018dnl (or misfeature) of glibc2, which breaks portability of many applications, 3019dnl since it is interwoven with GNU extensions. 3020dnl 3021dnl Well, yes we could work around it... 3022dnl 3023dnl Parameters: 3024dnl $1 is the nominal value for _XOPEN_SOURCE 3025AC_DEFUN([CF_GNU_SOURCE], 3026[ 3027cf_gnu_xopen_source=ifelse($1,,500,$1) 3028 3029AC_CACHE_CHECK(if this is the GNU C library,cf_cv_gnu_library,[ 3030AC_TRY_COMPILE([#include <sys/types.h>],[ 3031 #if __GLIBC__ > 0 && __GLIBC_MINOR__ >= 0 3032 return 0; 3033 #elif __NEWLIB__ > 0 && __NEWLIB_MINOR__ >= 0 3034 return 0; 3035 #else 3036 # error not GNU C library 3037 #endif], 3038 [cf_cv_gnu_library=yes], 3039 [cf_cv_gnu_library=no]) 3040]) 3041 3042if test x$cf_cv_gnu_library = xyes; then 3043 3044 # With glibc 2.19 (13 years after this check was begun), _DEFAULT_SOURCE 3045 # was changed to help a little. newlib incorporated the change about 4 3046 # years later. 3047 AC_CACHE_CHECK(if _DEFAULT_SOURCE can be used as a basis,cf_cv_gnu_library_219,[ 3048 cf_save="$CPPFLAGS" 3049 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE) 3050 AC_TRY_COMPILE([#include <sys/types.h>],[ 3051 #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 19) || (__GLIBC__ > 2) 3052 return 0; 3053 #elif (__NEWLIB__ == 2 && __NEWLIB_MINOR__ >= 4) || (__GLIBC__ > 3) 3054 return 0; 3055 #else 3056 # error GNU C library __GLIBC__.__GLIBC_MINOR__ is too old 3057 #endif], 3058 [cf_cv_gnu_library_219=yes], 3059 [cf_cv_gnu_library_219=no]) 3060 CPPFLAGS="$cf_save" 3061 ]) 3062 3063 if test "x$cf_cv_gnu_library_219" = xyes; then 3064 cf_save="$CPPFLAGS" 3065 AC_CACHE_CHECK(if _XOPEN_SOURCE=$cf_gnu_xopen_source works with _DEFAULT_SOURCE,cf_cv_gnu_dftsrc_219,[ 3066 CF_ADD_CFLAGS(-D_DEFAULT_SOURCE -D_XOPEN_SOURCE=$cf_gnu_xopen_source) 3067 AC_TRY_COMPILE([ 3068 #include <limits.h> 3069 #include <sys/types.h> 3070 ],[ 3071 #if (_XOPEN_SOURCE >= $cf_gnu_xopen_source) && (MB_LEN_MAX > 1) 3072 return 0; 3073 #else 3074 # error GNU C library is too old 3075 #endif], 3076 [cf_cv_gnu_dftsrc_219=yes], 3077 [cf_cv_gnu_dftsrc_219=no]) 3078 ]) 3079 test "x$cf_cv_gnu_dftsrc_219" = "xyes" || CPPFLAGS="$cf_save" 3080 else 3081 cf_cv_gnu_dftsrc_219=maybe 3082 fi 3083 3084 if test "x$cf_cv_gnu_dftsrc_219" != xyes; then 3085 3086 AC_CACHE_CHECK(if we must define _GNU_SOURCE,cf_cv_gnu_source,[ 3087 AC_TRY_COMPILE([#include <sys/types.h>],[ 3088 #ifndef _XOPEN_SOURCE 3089 #error expected _XOPEN_SOURCE to be defined 3090 #endif], 3091 [cf_cv_gnu_source=no], 3092 [cf_save="$CPPFLAGS" 3093 CF_ADD_CFLAGS(-D_GNU_SOURCE) 3094 AC_TRY_COMPILE([#include <sys/types.h>],[ 3095 #ifdef _XOPEN_SOURCE 3096 #error expected _XOPEN_SOURCE to be undefined 3097 #endif], 3098 [cf_cv_gnu_source=no], 3099 [cf_cv_gnu_source=yes]) 3100 CPPFLAGS="$cf_save" 3101 ]) 3102 ]) 3103 3104 if test "$cf_cv_gnu_source" = yes 3105 then 3106 AC_CACHE_CHECK(if we should also define _DEFAULT_SOURCE,cf_cv_default_source,[ 3107 CF_APPEND_TEXT(CPPFLAGS,-D_GNU_SOURCE) 3108 AC_TRY_COMPILE([#include <sys/types.h>],[ 3109 #ifdef _DEFAULT_SOURCE 3110 #error expected _DEFAULT_SOURCE to be undefined 3111 #endif], 3112 [cf_cv_default_source=no], 3113 [cf_cv_default_source=yes]) 3114 ]) 3115 if test "$cf_cv_default_source" = yes 3116 then 3117 CF_APPEND_TEXT(CPPFLAGS,-D_DEFAULT_SOURCE) 3118 fi 3119 fi 3120 fi 3121 3122fi 3123])dnl 3124dnl --------------------------------------------------------------------------- 3125dnl CF_GPP_LIBRARY version: 12 updated: 2015/04/17 21:13:04 3126dnl -------------- 3127dnl If we're trying to use g++, test if libg++ is installed (a rather common 3128dnl problem :-). If we have the compiler but no library, we'll be able to 3129dnl configure, but won't be able to build the c++ demo program. 3130AC_DEFUN([CF_GPP_LIBRARY], 3131[ 3132cf_cxx_library=unknown 3133case $cf_cv_system_name in 3134(os2*) 3135 cf_gpp_libname=gpp 3136 ;; 3137(*) 3138 cf_gpp_libname=g++ 3139 ;; 3140esac 3141if test "$GXX" = yes; then 3142 AC_MSG_CHECKING([for lib$cf_gpp_libname]) 3143 cf_save="$LIBS" 3144 CF_ADD_LIB($cf_gpp_libname) 3145 AC_TRY_LINK([ 3146#include <$cf_gpp_libname/builtin.h> 3147 ], 3148 [two_arg_error_handler_t foo2 = lib_error_handler], 3149 [cf_cxx_library=yes 3150 CF_ADD_LIB($cf_gpp_libname,CXXLIBS) 3151 if test "$cf_gpp_libname" = cpp ; then 3152 AC_DEFINE(HAVE_GPP_BUILTIN_H,1,[Define to 1 if we have gpp builtin.h]) 3153 else 3154 AC_DEFINE(HAVE_GXX_BUILTIN_H,1,[Define to 1 if we have g++ builtin.h]) 3155 fi], 3156 [AC_TRY_LINK([ 3157#include <builtin.h> 3158 ], 3159 [two_arg_error_handler_t foo2 = lib_error_handler], 3160 [cf_cxx_library=yes 3161 CF_ADD_LIB($cf_gpp_libname,CXXLIBS) 3162 AC_DEFINE(HAVE_BUILTIN_H,1,[Define to 1 if we have builtin.h])], 3163 [cf_cxx_library=no])]) 3164 LIBS="$cf_save" 3165 AC_MSG_RESULT($cf_cxx_library) 3166fi 3167])dnl 3168dnl --------------------------------------------------------------------------- 3169dnl CF_GXX_VERSION version: 8 updated: 2017/02/11 14:48:57 3170dnl -------------- 3171dnl Check for version of g++ 3172AC_DEFUN([CF_GXX_VERSION],[ 3173AC_REQUIRE([AC_PROG_CPP]) 3174GXX_VERSION=none 3175if test "$GXX" = yes; then 3176 AC_MSG_CHECKING(version of ${CXX:-g++}) 3177 GXX_VERSION="`${CXX:-g++} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" 3178 if test -z "$GXX_VERSION" 3179 then 3180 GXX_VERSION=unknown 3181 GXX=no 3182 fi 3183 AC_MSG_RESULT($GXX_VERSION) 3184fi 3185])dnl 3186dnl --------------------------------------------------------------------------- 3187dnl CF_GXX_WARNINGS version: 9 updated: 2015/04/17 21:13:04 3188dnl --------------- 3189dnl Check if the compiler supports useful warning options. 3190dnl 3191dnl Most of gcc's options apply to g++, except: 3192dnl -Wbad-function-cast 3193dnl -Wmissing-declarations 3194dnl -Wnested-externs 3195dnl 3196dnl Omit a few (for now): 3197dnl -Winline 3198dnl 3199dnl Parameter: 3200dnl $1 is an optional list of g++ warning flags that a particular 3201dnl application might want to use, e.g., "no-unused" for 3202dnl -Wno-unused 3203dnl Special: 3204dnl If $with_ext_const is "yes", add a check for -Wwrite-strings 3205dnl 3206AC_DEFUN([CF_GXX_WARNINGS], 3207[ 3208 3209CF_INTEL_COMPILER(GXX,INTEL_CPLUSPLUS,CXXFLAGS) 3210CF_CLANG_COMPILER(GXX,CLANG_CPLUSPLUS,CXXFLAGS) 3211 3212AC_REQUIRE([CF_GXX_VERSION]) 3213 3214AC_LANG_SAVE 3215AC_LANG_CPLUSPLUS 3216 3217cat > conftest.$ac_ext <<EOF 3218#line __oline__ "configure" 3219int main(int argc, char *argv[[]]) { return (argv[[argc-1]] == 0) ; } 3220EOF 3221 3222if test "$INTEL_CPLUSPLUS" = yes 3223then 3224# The "-wdXXX" options suppress warnings: 3225# remark #1419: external declaration in primary source file 3226# remark #1682: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 3227# remark #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 3228# remark #1684: conversion from pointer to same-sized integral type (potential portability problem) 3229# remark #193: zero used for undefined preprocessing identifier 3230# remark #593: variable "curs_sb_left_arrow" was set but never used 3231# remark #810: conversion from "int" to "Dimension={unsigned short}" may lose significant bits 3232# remark #869: parameter "tw" was never referenced 3233# remark #981: operands are evaluated in unspecified order 3234# warning #269: invalid format string conversion 3235 3236 AC_CHECKING([for $CC warning options]) 3237 cf_save_CXXFLAGS="$CXXFLAGS" 3238 EXTRA_CXXFLAGS="-Wall" 3239 for cf_opt in \ 3240 wd1419 \ 3241 wd1682 \ 3242 wd1683 \ 3243 wd1684 \ 3244 wd193 \ 3245 wd279 \ 3246 wd593 \ 3247 wd810 \ 3248 wd869 \ 3249 wd981 3250 do 3251 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -$cf_opt" 3252 if AC_TRY_EVAL(ac_compile); then 3253 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3254 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt" 3255 fi 3256 done 3257 CXXFLAGS="$cf_save_CXXFLAGS" 3258 3259elif test "$GXX" = yes 3260then 3261 AC_CHECKING([for $CXX warning options]) 3262 cf_save_CXXFLAGS="$CXXFLAGS" 3263 EXTRA_CXXFLAGS="-W -Wall" 3264 cf_gxx_extra_warnings="" 3265 test "$with_ext_const" = yes && cf_gxx_extra_warnings="Wwrite-strings" 3266 case "$GCC_VERSION" in 3267 ([[1-2]].*) 3268 ;; 3269 (*) 3270 cf_gxx_extra_warnings="$cf_gxx_extra_warnings Weffc++" 3271 ;; 3272 esac 3273 for cf_opt in \ 3274 Wabi \ 3275 fabi-version=0 \ 3276 Wextra \ 3277 Wignored-qualifiers \ 3278 Wlogical-op \ 3279 Woverloaded-virtual \ 3280 Wsign-promo \ 3281 Wsynth \ 3282 Wold-style-cast \ 3283 Wcast-align \ 3284 Wcast-qual \ 3285 Wpointer-arith \ 3286 Wshadow \ 3287 Wundef $cf_gxx_extra_warnings $1 3288 do 3289 CXXFLAGS="$cf_save_CXXFLAGS $EXTRA_CXXFLAGS -Werror -$cf_opt" 3290 if AC_TRY_EVAL(ac_compile); then 3291 test -n "$verbose" && AC_MSG_RESULT(... -$cf_opt) 3292 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -$cf_opt" 3293 else 3294 test -n "$verbose" && AC_MSG_RESULT(... no -$cf_opt) 3295 fi 3296 done 3297 CXXFLAGS="$cf_save_CXXFLAGS" 3298fi 3299 3300rm -rf conftest* 3301AC_LANG_RESTORE 3302AC_SUBST(EXTRA_CXXFLAGS) 3303])dnl 3304dnl --------------------------------------------------------------------------- 3305dnl CF_HASHED_DB version: 7 updated: 2015/04/18 08:56:57 3306dnl ------------ 3307dnl Look for an instance of the Berkeley hashed database. 3308dnl 3309dnl $1 = optional parameter, to specify install-prefix for the database. 3310AC_DEFUN([CF_HASHED_DB], 3311[ 3312ifelse([$1],,,[ 3313case $1 in 3314(yes|*able*) 3315 ;; 3316(*) 3317 if test -d "$1" ; then 3318 CF_ADD_INCDIR($1/include) 3319 CF_ADD_LIBDIR($1/lib) 3320 else 3321 case "$1" in 3322 (./*|../*|/*) 3323 AC_MSG_WARN(no such directory $1) 3324 ;; 3325 (*) 3326 CF_FIND_SUB_INCDIR($1) 3327 CF_FIND_SUB_LIBDIR($1) 3328 ;; 3329 esac 3330 fi 3331esac 3332]) 3333AC_CHECK_HEADER(db.h,[ 3334CF_HASHED_DB_VERSION 3335if test "$cf_cv_hashed_db_version" = unknown ; then 3336 AC_MSG_ERROR(Cannot determine version of db) 3337else 3338 CF_HASHED_DB_LIBS 3339 if test "$cf_cv_hashed_db_libs" = unknown ; then 3340 AC_MSG_ERROR(Cannot determine library for db) 3341 elif test "$cf_cv_hashed_db_libs" != default ; then 3342 CF_ADD_LIB($cf_cv_hashed_db_libs) 3343 fi 3344fi 3345],[ 3346 AC_MSG_ERROR(Cannot find db.h) 3347]) 3348])dnl 3349dnl --------------------------------------------------------------------------- 3350dnl CF_HASHED_DB_LIBS version: 9 updated: 2010/05/29 16:31:02 3351dnl ----------------- 3352dnl Given that we have the header and version for hashed database, find the 3353dnl library information. 3354AC_DEFUN([CF_HASHED_DB_LIBS], 3355[ 3356AC_CACHE_CHECK(for db libraries, cf_cv_hashed_db_libs,[ 3357cf_cv_hashed_db_libs=unknown 3358for cf_db_libs in "" db$cf_cv_hashed_db_version db-$cf_cv_hashed_db_version db '' 3359do 3360 cf_save_libs="$LIBS" 3361 if test -n "$cf_db_libs"; then 3362 CF_ADD_LIB($cf_db_libs) 3363 fi 3364 CF_MSG_LOG(checking for library "$cf_db_libs") 3365 AC_TRY_LINK([ 3366$ac_includes_default 3367#include <db.h> 3368],[ 3369 char *path = "/tmp/foo"; 3370#ifdef DB_VERSION_MAJOR 3371#if DB_VERSION_MAJOR >= 4 3372 DB *result = 0; 3373 db_create(&result, NULL, 0); 3374 result->open(result, 3375 NULL, 3376 path, 3377 path, 3378 DB_HASH, 3379 DB_CREATE, 3380 0644); 3381#elif DB_VERSION_MAJOR >= 3 3382 DB *result = 0; 3383 db_create(&result, NULL, 0); 3384 result->open(result, 3385 path, 3386 path, 3387 DB_HASH, 3388 DB_CREATE, 3389 0644); 3390#elif DB_VERSION_MAJOR >= 2 3391 DB *result = 0; 3392 db_open(path, 3393 DB_HASH, 3394 DB_CREATE, 3395 0644, 3396 (DB_ENV *) 0, 3397 (DB_INFO *) 0, 3398 &result); 3399#endif /* DB_VERSION_MAJOR */ 3400#else 3401 DB *result = dbopen(path, 3402 2, 3403 0644, 3404 DB_HASH, 3405 0); 3406#endif 3407 ${cf_cv_main_return:-return}(result != 0) 3408],[ 3409 if test -n "$cf_db_libs" ; then 3410 cf_cv_hashed_db_libs=$cf_db_libs 3411 else 3412 cf_cv_hashed_db_libs=default 3413 fi 3414 LIBS="$cf_save_libs" 3415 break 3416]) 3417 LIBS="$cf_save_libs" 3418done 3419]) 3420])dnl 3421dnl --------------------------------------------------------------------------- 3422dnl CF_HASHED_DB_VERSION version: 4 updated: 2014/04/12 16:47:01 3423dnl -------------------- 3424dnl Given that we have the header file for hashed database, find the version 3425dnl information. 3426AC_DEFUN([CF_HASHED_DB_VERSION], 3427[ 3428AC_CACHE_CHECK(for version of db, cf_cv_hashed_db_version,[ 3429cf_cv_hashed_db_version=unknown 3430 3431for cf_db_version in 1 2 3 4 5 6 3432do 3433 CF_MSG_LOG(checking for db version $cf_db_version) 3434 AC_TRY_COMPILE([ 3435$ac_includes_default 3436#include <db.h> 3437 3438#ifdef DB_VERSION_MAJOR 3439 /* db2 (DB_VERSION_MAJOR=2) has also DB_VERSION_MINOR, tested with 7 */ 3440#if $cf_db_version == DB_VERSION_MAJOR 3441 /* ok */ 3442#else 3443 make an error 3444#endif 3445#else 3446#if $cf_db_version == 1 3447 /* ok: assuming this is DB 1.8.5 */ 3448#else 3449 make an error 3450#endif 3451#endif 3452],[DBT *foo = 0],[ 3453 cf_cv_hashed_db_version=$cf_db_version 3454 break 3455 ]) 3456done 3457]) 3458])dnl 3459dnl --------------------------------------------------------------------------- 3460dnl CF_HEADER_PATH version: 13 updated: 2015/04/15 19:08:48 3461dnl -------------- 3462dnl Construct a search-list of directories for a nonstandard header-file 3463dnl 3464dnl Parameters 3465dnl $1 = the variable to return as result 3466dnl $2 = the package name 3467AC_DEFUN([CF_HEADER_PATH], 3468[ 3469$1= 3470 3471# collect the current set of include-directories from compiler flags 3472cf_header_path_list="" 3473if test -n "${CFLAGS}${CPPFLAGS}" ; then 3474 for cf_header_path in $CPPFLAGS $CFLAGS 3475 do 3476 case $cf_header_path in 3477 (-I*) 3478 cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` 3479 CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE) 3480 cf_header_path_list="$cf_header_path_list [$]$1" 3481 ;; 3482 esac 3483 done 3484fi 3485 3486# add the variations for the package we are looking for 3487CF_SUBDIR_PATH($1,$2,include) 3488 3489test "$includedir" != NONE && \ 3490test "$includedir" != "/usr/include" && \ 3491test -d "$includedir" && { 3492 test -d $includedir && $1="[$]$1 $includedir" 3493 test -d $includedir/$2 && $1="[$]$1 $includedir/$2" 3494} 3495 3496test "$oldincludedir" != NONE && \ 3497test "$oldincludedir" != "/usr/include" && \ 3498test -d "$oldincludedir" && { 3499 test -d $oldincludedir && $1="[$]$1 $oldincludedir" 3500 test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2" 3501} 3502 3503$1="[$]$1 $cf_header_path_list" 3504])dnl 3505dnl --------------------------------------------------------------------------- 3506dnl CF_HELP_MESSAGE version: 4 updated: 2019/12/31 08:53:54 3507dnl --------------- 3508dnl Insert text into the help-message, for readability, from AC_ARG_WITH. 3509AC_DEFUN([CF_HELP_MESSAGE], 3510[CF_ACVERSION_CHECK(2.53,[],[ 3511AC_DIVERT_HELP($1)])dnl 3512])dnl 3513dnl --------------------------------------------------------------------------- 3514dnl CF_INCLUDE_DIRS version: 10 updated: 2014/09/19 20:58:42 3515dnl --------------- 3516dnl Construct the list of include-options according to whether we're building 3517dnl in the source directory or using '--srcdir=DIR' option. 3518AC_DEFUN([CF_INCLUDE_DIRS], 3519[ 3520if test "$srcdir" != "."; then 3521 CPPFLAGS="-I\${srcdir}/../include $CPPFLAGS" 3522fi 3523CPPFLAGS="-I../include $CPPFLAGS" 3524if test "$srcdir" != "."; then 3525 CPPFLAGS="-I\${srcdir} $CPPFLAGS" 3526fi 3527CPPFLAGS="-I. $CPPFLAGS" 3528AC_SUBST(CPPFLAGS) 3529])dnl 3530dnl --------------------------------------------------------------------------- 3531dnl CF_INSTALL_OPTS version: 2 updated: 2018/08/18 12:19:21 3532dnl --------------- 3533dnl prompt for/fill-in useful install-program options 3534AC_DEFUN([CF_INSTALL_OPTS], 3535[ 3536CF_INSTALL_OPT_S 3537CF_INSTALL_OPT_P 3538CF_INSTALL_OPT_O 3539])dnl 3540dnl --------------------------------------------------------------------------- 3541dnl CF_INSTALL_OPT_O version: 2 updated: 2015/05/15 19:45:35 3542dnl ---------------- 3543dnl Almost all "install" programs default to the current user's ownership. 3544dnl Almost - MINIX is an exception. 3545AC_DEFUN([CF_INSTALL_OPT_O], 3546[ 3547AC_MSG_CHECKING(if install needs to be told about ownership) 3548case `$ac_config_guess` in 3549(*minix) 3550 with_install_o=yes 3551 ;; 3552(*) 3553 with_install_o=no 3554 ;; 3555esac 3556 3557AC_MSG_RESULT($with_install_o) 3558if test "x$with_install_o" = xyes 3559then 3560 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'` 3561else 3562 INSTALL_OPT_O= 3563fi 3564 3565AC_SUBST(INSTALL_OPT_O) 3566])dnl 3567dnl --------------------------------------------------------------------------- 3568dnl CF_INSTALL_OPT_P version: 1 updated: 2018/08/18 12:19:21 3569dnl ---------------- 3570dnl Some install-programs accept a "-p" option to preserve file modification 3571dnl timestamps. That can be useful as an install option, as well as a way to 3572dnl avoid the need for ranlib after copying a static archive. 3573AC_DEFUN([CF_INSTALL_OPT_P], 3574[ 3575: ${INSTALL:=install} 3576AC_CACHE_CHECK(if install accepts -p option, cf_cv_install_p,[ 3577 rm -rf conftest* 3578 date >conftest.in 3579 mkdir conftest.out 3580 sleep 3 3581 if $INSTALL -p conftest.in conftest.out 2>/dev/null 3582 then 3583 if test -f conftest.out/conftest.in 3584 then 3585 test conftest.in -nt conftest.out/conftest.in 2>conftest.err && \ 3586 test conftest.out/conftest.in -nt conftest.in 2>conftest.err 3587 if test -s conftest.err 3588 then 3589 cf_cv_install_p=no 3590 else 3591 cf_cv_install_p=yes 3592 fi 3593 else 3594 cf_cv_install_p=no 3595 fi 3596 else 3597 cf_cv_install_p=no 3598 fi 3599 rm -rf conftest* 3600]) 3601])dnl 3602dnl --------------------------------------------------------------------------- 3603dnl CF_INSTALL_OPT_S version: 2 updated: 2018/08/18 12:19:21 3604dnl ---------------- 3605dnl By default, we should strip executables which are installed, but leave the 3606dnl ability to suppress that for unit-testing. 3607AC_DEFUN([CF_INSTALL_OPT_S], 3608[ 3609AC_MSG_CHECKING(if you want to install stripped executables) 3610CF_ARG_DISABLE(stripping, 3611 [ --disable-stripping do not strip (debug info) installed executables], 3612 [with_stripping=no], 3613 [with_stripping=yes]) 3614AC_MSG_RESULT($with_stripping) 3615 3616if test "$with_stripping" = yes 3617then 3618 INSTALL_OPT_S="-s" 3619else 3620 INSTALL_OPT_S= 3621fi 3622AC_SUBST(INSTALL_OPT_S) 3623])dnl 3624dnl --------------------------------------------------------------------------- 3625dnl CF_INTEL_COMPILER version: 7 updated: 2015/04/12 15:39:00 3626dnl ----------------- 3627dnl Check if the given compiler is really the Intel compiler for Linux. It 3628dnl tries to imitate gcc, but does not return an error when it finds a mismatch 3629dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK. 3630dnl 3631dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to 3632dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from 3633dnl the wrappers for gcc and g++ warnings. 3634dnl 3635dnl $1 = GCC (default) or GXX 3636dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS 3637dnl $3 = CFLAGS (default) or CXXFLAGS 3638AC_DEFUN([CF_INTEL_COMPILER],[ 3639AC_REQUIRE([AC_CANONICAL_HOST]) 3640ifelse([$2],,INTEL_COMPILER,[$2])=no 3641 3642if test "$ifelse([$1],,[$1],GCC)" = yes ; then 3643 case $host_os in 3644 (linux*|gnu*) 3645 AC_MSG_CHECKING(if this is really Intel ifelse([$1],GXX,C++,C) compiler) 3646 cf_save_CFLAGS="$ifelse([$3],,CFLAGS,[$3])" 3647 ifelse([$3],,CFLAGS,[$3])="$ifelse([$3],,CFLAGS,[$3]) -no-gcc" 3648 AC_TRY_COMPILE([],[ 3649#ifdef __INTEL_COMPILER 3650#else 3651make an error 3652#endif 3653],[ifelse([$2],,INTEL_COMPILER,[$2])=yes 3654cf_save_CFLAGS="$cf_save_CFLAGS -we147" 3655],[]) 3656 ifelse([$3],,CFLAGS,[$3])="$cf_save_CFLAGS" 3657 AC_MSG_RESULT($ifelse([$2],,INTEL_COMPILER,[$2])) 3658 ;; 3659 esac 3660fi 3661])dnl 3662dnl --------------------------------------------------------------------------- 3663dnl CF_ISASCII version: 4 updated: 2012/10/06 17:56:13 3664dnl ---------- 3665dnl Check if we have either a function or macro for 'isascii()'. 3666AC_DEFUN([CF_ISASCII], 3667[ 3668AC_MSG_CHECKING(for isascii) 3669AC_CACHE_VAL(cf_cv_have_isascii,[ 3670 AC_TRY_LINK([#include <ctype.h>],[int x = isascii(' ')], 3671 [cf_cv_have_isascii=yes], 3672 [cf_cv_have_isascii=no]) 3673])dnl 3674AC_MSG_RESULT($cf_cv_have_isascii) 3675test "$cf_cv_have_isascii" = yes && AC_DEFINE(HAVE_ISASCII,1,[Define to 1 if we have isascii()]) 3676])dnl 3677dnl --------------------------------------------------------------------------- 3678dnl CF_LARGEFILE version: 11 updated: 2018/06/20 20:23:13 3679dnl ------------ 3680dnl Add checks for large file support. 3681AC_DEFUN([CF_LARGEFILE],[ 3682ifdef([AC_FUNC_FSEEKO],[ 3683 AC_SYS_LARGEFILE 3684 if test "$enable_largefile" != no ; then 3685 AC_FUNC_FSEEKO 3686 3687 # Normally we would collect these definitions in the config.h, 3688 # but (like _XOPEN_SOURCE), some environments rely on having these 3689 # defined before any of the system headers are included. Another 3690 # case comes up with C++, e.g., on AIX the compiler compiles the 3691 # header files by themselves before looking at the body files it is 3692 # told to compile. For ncurses, those header files do not include 3693 # the config.h 3694 if test "$ac_cv_sys_large_files" != no 3695 then 3696 CF_APPEND_TEXT(CPPFLAGS,-D_LARGE_FILES) 3697 fi 3698 if test "$ac_cv_sys_largefile_source" != no 3699 then 3700 CF_APPEND_TEXT(CPPFLAGS,-D_LARGEFILE_SOURCE) 3701 fi 3702 if test "$ac_cv_sys_file_offset_bits" != no 3703 then 3704 CF_APPEND_TEXT(CPPFLAGS,-D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits) 3705 fi 3706 3707 AC_CACHE_CHECK(whether to use struct dirent64, cf_cv_struct_dirent64,[ 3708 AC_TRY_COMPILE([ 3709#pragma GCC diagnostic error "-Wincompatible-pointer-types" 3710#include <sys/types.h> 3711#include <dirent.h> 3712 ],[ 3713 /* if transitional largefile support is setup, this is true */ 3714 extern struct dirent64 * readdir(DIR *); 3715 struct dirent64 *x = readdir((DIR *)0); 3716 struct dirent *y = readdir((DIR *)0); 3717 int z = x - y; 3718 ], 3719 [cf_cv_struct_dirent64=yes], 3720 [cf_cv_struct_dirent64=no]) 3721 ]) 3722 test "$cf_cv_struct_dirent64" = yes && AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Define to 1 if we have struct dirent64]) 3723 fi 3724]) 3725]) 3726dnl --------------------------------------------------------------------------- 3727dnl CF_LDFLAGS_STATIC version: 12 updated: 2015/04/18 08:56:57 3728dnl ----------------- 3729dnl Check for compiler/linker flags used to temporarily force usage of static 3730dnl libraries. This depends on the compiler and platform. Use this to help 3731dnl ensure that the linker picks up a given library based on its position in 3732dnl the list of linker options and libraries. 3733AC_DEFUN([CF_LDFLAGS_STATIC],[ 3734 3735if test "$GCC" = yes ; then 3736 case $cf_cv_system_name in 3737 (OS/2*|os2*|aix[[4]]*|solaris2.1[[0-9]]|darwin*) 3738 LDFLAGS_STATIC= 3739 LDFLAGS_SHARED= 3740 ;; 3741 (*) # normally, except when broken 3742 LDFLAGS_STATIC=-static 3743 LDFLAGS_SHARED=-dynamic 3744 ;; 3745 esac 3746else 3747 case $cf_cv_system_name in 3748 (aix[[4-7]]*) # from ld manpage 3749 LDFLAGS_STATIC=-bstatic 3750 LDFLAGS_SHARED=-bdynamic 3751 ;; 3752 (hpux*) # from ld manpage for hpux10.20, hpux11.11 3753 # We could also use just "archive" and "shared". 3754 LDFLAGS_STATIC=-Wl,-a,archive_shared 3755 LDFLAGS_SHARED=-Wl,-a,shared_archive 3756 ;; 3757 (irix*) # from ld manpage IRIX64 3758 LDFLAGS_STATIC=-Bstatic 3759 LDFLAGS_SHARED=-Bdynamic 3760 ;; 3761 (osf[[45]]*) # from ld manpage osf4.0d, osf5.1 3762 # alternative "-oldstyle_liblookup" (not in cc manpage) 3763 LDFLAGS_STATIC=-noso 3764 LDFLAGS_SHARED=-so_archive 3765 ;; 3766 (solaris2*) 3767 LDFLAGS_STATIC=-Bstatic 3768 LDFLAGS_SHARED=-Bdynamic 3769 ;; 3770 esac 3771fi 3772 3773if test -n "$LDFLAGS_STATIC" && test -n "$LDFLAGS_SHARED" 3774then 3775 AC_MSG_CHECKING(if linker supports switching between static/dynamic) 3776 3777 rm -f libconftest.a 3778 cat >conftest.$ac_ext <<EOF 3779#line __oline__ "configure" 3780#include <stdio.h> 3781int cf_ldflags_static(FILE *fp) { return fflush(fp); } 3782EOF 3783 if AC_TRY_EVAL(ac_compile) ; then 3784 ( $AR $ARFLAGS libconftest.a conftest.o ) 2>&AC_FD_CC 1>/dev/null 3785 ( eval $RANLIB libconftest.a ) 2>&AC_FD_CC >/dev/null 3786 fi 3787 rm -f conftest.* 3788 3789 cf_save_LIBS="$LIBS" 3790 3791 LIBS="$LDFLAGS_STATIC -L`pwd` -lconftest $LDFLAGS_DYNAMIC $LIBS" 3792 AC_TRY_LINK([ 3793#line __oline__ "configure" 3794#include <stdio.h> 3795int cf_ldflags_static(FILE *fp); 3796],[ 3797 return cf_ldflags_static(stdin); 3798],[ 3799 # some linkers simply ignore the -dynamic 3800 case x`file conftest$ac_exeext 2>/dev/null` in 3801 (*static*) 3802 cf_ldflags_static=no 3803 ;; 3804 (*) 3805 cf_ldflags_static=yes 3806 ;; 3807 esac 3808],[cf_ldflags_static=no]) 3809 3810 rm -f libconftest.* 3811 LIBS="$cf_save_LIBS" 3812 3813 AC_MSG_RESULT($cf_ldflags_static) 3814 3815 if test $cf_ldflags_static != yes 3816 then 3817 LDFLAGS_STATIC= 3818 LDFLAGS_SHARED= 3819 fi 3820else 3821 LDFLAGS_STATIC= 3822 LDFLAGS_SHARED= 3823fi 3824 3825AC_SUBST(LDFLAGS_STATIC) 3826AC_SUBST(LDFLAGS_SHARED) 3827]) 3828dnl --------------------------------------------------------------------------- 3829dnl CF_LD_RPATH_OPT version: 8 updated: 2018/08/18 16:36:35 3830dnl --------------- 3831dnl For the given system and compiler, find the compiler flags to pass to the 3832dnl loader to use the "rpath" feature. 3833AC_DEFUN([CF_LD_RPATH_OPT], 3834[ 3835AC_REQUIRE([CF_CHECK_CACHE]) 3836 3837LD_RPATH_OPT= 3838if test "x$cf_cv_enable_rpath" != xno 3839then 3840 AC_MSG_CHECKING(for an rpath option) 3841 case $cf_cv_system_name in 3842 (irix*) 3843 if test "$GCC" = yes; then 3844 LD_RPATH_OPT="-Wl,-rpath," 3845 else 3846 LD_RPATH_OPT="-rpath " 3847 fi 3848 ;; 3849 (linux*|gnu*|k*bsd*-gnu|freebsd*) 3850 LD_RPATH_OPT="-Wl,-rpath," 3851 ;; 3852 (openbsd[[2-9]].*|mirbsd*) 3853 LD_RPATH_OPT="-Wl,-rpath," 3854 ;; 3855 (dragonfly*) 3856 LD_RPATH_OPT="-rpath " 3857 ;; 3858 (netbsd*) 3859 LD_RPATH_OPT="-Wl,-rpath," 3860 ;; 3861 (osf*|mls+*) 3862 LD_RPATH_OPT="-rpath " 3863 ;; 3864 (solaris2*) 3865 LD_RPATH_OPT="-R" 3866 ;; 3867 (*) 3868 ;; 3869 esac 3870 AC_MSG_RESULT($LD_RPATH_OPT) 3871 3872 case "x$LD_RPATH_OPT" in 3873 (x-R*) 3874 AC_MSG_CHECKING(if we need a space after rpath option) 3875 cf_save_LIBS="$LIBS" 3876 CF_ADD_LIBS(${LD_RPATH_OPT}$libdir) 3877 AC_TRY_LINK(, , cf_rpath_space=no, cf_rpath_space=yes) 3878 LIBS="$cf_save_LIBS" 3879 AC_MSG_RESULT($cf_rpath_space) 3880 test "$cf_rpath_space" = yes && LD_RPATH_OPT="$LD_RPATH_OPT " 3881 ;; 3882 esac 3883fi 3884])dnl 3885dnl --------------------------------------------------------------------------- 3886dnl CF_LD_SEARCHPATH version: 2 updated: 2019/09/26 20:34:14 3887dnl ---------------- 3888dnl Try to obtain the linker's search-path, for use in scripts. 3889dnl 3890dnl Ignore LD_LIBRARY_PATH, etc. 3891AC_DEFUN([CF_LD_SEARCHPATH],[ 3892AC_CACHE_CHECK(for linker search path,cf_cv_ld_searchpath,[ 3893 3894if test "$cross_compiling" != yes ; then 3895 3896# GNU binutils' ld does not involve permissions which may stop ldconfig. 3897cf_pathlist=`ld --verbose 2>/dev/null | grep SEARCH_DIR | sed -e 's,SEARCH_DIR[[("=]][[("=]]*,,g' -e 's/"[[)]];//gp' | sort -u` 3898 3899# The -NX options tell newer versions of Linux ldconfig to not attempt to 3900# update the cache, which makes it run faster. 3901test -z "$cf_pathlist" && \ 3902 cf_pathlist=`ldconfig -NX -v 2>/dev/null | sed -e '/^[[ ]]/d' -e 's/:$//' | sort -u` 3903 3904test -z "$cf_pathlist" && 3905 cf_pathlist=`ldconfig -v 2>/dev/null | sed -n -e '/^[[ ]]/d' -e 's/:$//p' | sort -u` 3906 3907# This works with OpenBSD 6.5, which lists only filenames 3908test -z "$cf_pathlist" && 3909 cf_pathlist=`ldconfig -v 2>/dev/null | sed -n -e 's,^Adding \(.*\)/.*[$],\1,p' | sort -u` 3910 3911if test -z "$cf_pathlist" 3912then 3913 # dyld default path with MacOS 3914 if test -f /usr/bin/otool && test "x`uname -s`" = xDarwin 3915 then 3916 # do this to bypass check 3917 cf_cv_ld_searchpath='$HOME/lib' 3918 cf_pathlist="/usr/local/lib /lib /usr/lib" 3919 fi 3920fi 3921 3922if test -z "$cf_pathlist" 3923then 3924 # Solaris is hardcoded 3925 if test -d /opt/SUNWspro/lib 3926 then 3927 cf_pathlist="/opt/SUNWspro/lib /usr/ccs/lib /usr/lib" 3928 elif test -d /usr/ccs/lib 3929 then 3930 cf_pathlist="/usr/ccs/lib /usr/lib" 3931 fi 3932fi 3933 3934fi 3935 3936# If nothing else, assume it is conventional 3937test -z "$cf_pathlist" && cf_pathlist="/usr/lib /lib" 3938 3939# Finally, check that this is only directories 3940for cf_path in [$]0 $cf_pathlist 3941do 3942 if test -d "$cf_path"; then 3943 test -n "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath="${cf_cv_ld_searchpath} " 3944 cf_cv_ld_searchpath="${cf_cv_ld_searchpath}${cf_path}" 3945 fi 3946done 3947 3948# Ensure that it is nonempty 3949test -z "$cf_cv_ld_searchpath" && cf_cv_ld_searchpath=/usr/lib 3950]) 3951 3952LD_SEARCHPATH=`echo "$cf_cv_ld_searchpath"|sed -e 's/ /|/g'` 3953AC_SUBST(LD_SEARCHPATH) 3954])dnl 3955dnl --------------------------------------------------------------------------- 3956dnl CF_LIBRARY_PATH version: 10 updated: 2015/04/15 19:08:48 3957dnl --------------- 3958dnl Construct a search-list of directories for a nonstandard library-file 3959dnl 3960dnl Parameters 3961dnl $1 = the variable to return as result 3962dnl $2 = the package name 3963AC_DEFUN([CF_LIBRARY_PATH], 3964[ 3965$1= 3966cf_library_path_list="" 3967if test -n "${LDFLAGS}${LIBS}" ; then 3968 for cf_library_path in $LDFLAGS $LIBS 3969 do 3970 case $cf_library_path in 3971 (-L*) 3972 cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` 3973 CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE) 3974 cf_library_path_list="$cf_library_path_list [$]$1" 3975 ;; 3976 esac 3977 done 3978fi 3979 3980CF_SUBDIR_PATH($1,$2,lib) 3981 3982$1="$cf_library_path_list [$]$1" 3983])dnl 3984dnl --------------------------------------------------------------------------- 3985dnl CF_LIBTOOL_VERSION version: 1 updated: 2013/04/06 18:03:09 3986dnl ------------------ 3987AC_DEFUN([CF_LIBTOOL_VERSION],[ 3988if test -n "$LIBTOOL" && test "$LIBTOOL" != none 3989then 3990 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.]].*//'` 3991else 3992 cf_cv_libtool_version= 3993fi 3994test -z "$cf_cv_libtool_version" && unset cf_cv_libtool_version 3995])dnl 3996dnl --------------------------------------------------------------------------- 3997dnl CF_LIB_PREFIX version: 12 updated: 2015/10/17 19:03:33 3998dnl ------------- 3999dnl Compute the library-prefix for the given host system 4000dnl $1 = variable to set 4001define([CF_LIB_PREFIX], 4002[ 4003 case $cf_cv_system_name in 4004 (OS/2*|os2*) 4005 if test "$DFT_LWR_MODEL" = libtool; then 4006 LIB_PREFIX='lib' 4007 else 4008 LIB_PREFIX='' 4009 fi 4010 ;; 4011 (*) LIB_PREFIX='lib' 4012 ;; 4013 esac 4014ifelse($1,,,[$1=$LIB_PREFIX]) 4015 AC_SUBST(LIB_PREFIX) 4016])dnl 4017dnl --------------------------------------------------------------------------- 4018dnl CF_LIB_RULES version: 88 updated: 2018/08/18 12:19:21 4019dnl ------------ 4020dnl Append definitions and rules for the given models to the subdirectory 4021dnl Makefiles, and the recursion rule for the top-level Makefile. If the 4022dnl subdirectory is a library-source directory, modify the Libs_To_Make list in 4023dnl the corresponding makefile to list the models that we'll generate. 4024dnl 4025dnl For shared libraries, make a list of symbolic links to construct when 4026dnl generating each library. The convention used for Linux is the simplest 4027dnl one: 4028dnl lib<name>.so -> 4029dnl lib<name>.so.<major> -> 4030dnl lib<name>.so.<maj>.<minor> 4031dnl 4032dnl Note: Libs_To_Make is mixed case, since it is not a pure autoconf variable. 4033AC_DEFUN([CF_LIB_RULES], 4034[ 4035cf_prefix=$LIB_PREFIX 4036AC_REQUIRE([CF_SUBST_NCURSES_VERSION]) 4037 4038case $cf_cv_shlib_version in 4039(cygdll|msysdll|mingw) 4040 TINFO_NAME=$TINFO_ARG_SUFFIX 4041 TINFO_SUFFIX=.dll 4042 ;; 4043esac 4044 4045if test -n "$TINFO_SUFFIX" ; then 4046 case $TINFO_SUFFIX in 4047 (tw*) 4048 TINFO_NAME="${TINFO_NAME}tw${EXTRA_SUFFIX}" 4049 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^tw'$EXTRA_SUFFIX'//'` 4050 ;; 4051 (t*) 4052 TINFO_NAME="${TINFO_NAME}t${EXTRA_SUFFIX}" 4053 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^t'$EXTRA_SUFFIX'//'` 4054 ;; 4055 (w*) 4056 TINFO_NAME="${TINFO_NAME}w${EXTRA_SUFFIX}" 4057 TINFO_SUFFIX=`echo $TINFO_SUFFIX | sed 's/^w'$EXTRA_SUFFIX'//'` 4058 ;; 4059 esac 4060fi 4061 4062for cf_dir in $SRC_SUBDIRS 4063do 4064 if test ! -d $srcdir/$cf_dir ; then 4065 continue 4066 elif test -f $srcdir/$cf_dir/modules; then 4067 4068 SHARED_LIB= 4069 Libs_To_Make= 4070 cf_awk_program= 4071 if test -n "${cf_cv_abi_version}" && test "x${cf_cv_abi_version}" != "x5" 4072 then 4073 cf_awk_program="$cf_awk_program\ 4074/deprecated in ABI${cf_cv_abi_version}/ { next; }\ 4075{ sub(\"NCURSES([[WT]]+)?\", \"&${cf_cv_abi_version}\"); }\ 4076" 4077 fi 4078 4079 if test "x$WILDCARD_SYMS" = xno 4080 then 4081 cf_awk_program="$cf_awk_program\ 4082/[[ ]]_\\*;/ { skip=1; next; }\ 4083" 4084 fi 4085 4086 if test "x$cf_awk_program" != "x" 4087 then 4088 cat >>$cf_dir/Makefile <<CF_EOF 4089 4090# Generated by CF_LIB_RULES 4091resulting.map: $UNALTERED_SYMS 4092 $AWK 'BEGIN { skip = 1; last=""; } \ 4093$cf_awk_program \ 4094{ if ( last != "" && ( skip == 0 || \[$]\[$]0 !~ /}/ ) ) { print last; }\ 4095 skip = 0; last = \[$]\[$]0; } \ 4096END { print last; }' < $UNALTERED_SYMS >\[$]@ 4097 4098distclean:: 4099 rm -f resulting.map 4100CF_EOF 4101 fi 4102 4103 for cf_item in $cf_LIST_MODELS 4104 do 4105 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf) 4106 cf_libname=$cf_dir 4107 test "$cf_dir" = c++ && cf_libname=ncurses++ 4108 if test $cf_item = shared ; then 4109 if test -n "${LIB_SUFFIX}" 4110 then 4111 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'` 4112 else 4113 cf_shared_suffix="$cf_suffix" 4114 fi 4115 if test "$cf_cv_do_symlinks" = yes ; then 4116 cf_version_name= 4117 4118 case "$cf_cv_shlib_version" in 4119 (rel) 4120 cf_version_name=REL_VERSION 4121 ;; 4122 (abi) 4123 cf_version_name=ABI_VERSION 4124 ;; 4125 esac 4126 4127 if test -n "$cf_version_name" 4128 then 4129 case "$cf_cv_system_name" in 4130 (darwin*) 4131 # "w", etc? 4132 cf_suffix="${USE_LIB_SUFFIX}"'.${'$cf_version_name'}'"$cf_shared_suffix" 4133 ;; 4134 (*) 4135 cf_suffix="$cf_suffix"'.${'$cf_version_name'}' 4136 ;; 4137 esac 4138 fi 4139 if test -n "${USE_LIB_SUFFIX}" 4140 then 4141 cf_shared_suffix=`echo "$cf_suffix" | sed 's/^'"${USE_LIB_SUFFIX}"'//'` 4142 else 4143 cf_shared_suffix="$cf_suffix" 4144 fi 4145 fi 4146 # cygwin needs import library, and has unique naming convention 4147 # use autodetected ${cf_prefix} for import lib and static lib, but 4148 # use 'cyg' prefix for shared lib. 4149 case $cf_cv_shlib_version in 4150 (cygdll) 4151 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4152 cf_add_lib="../lib/cyg${cf_libname}${cf_cygsuf}" 4153 ;; 4154 (msysdll) 4155 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4156 cf_add_lib="../lib/msys-${cf_libname}${cf_cygsuf}" 4157 ;; 4158 (mingw) 4159 cf_cygsuf=`echo "$cf_suffix" | sed -e 's/\.dll/\${ABI_VERSION}.dll/'` 4160 cf_add_lib="../lib/lib${cf_libname}${cf_cygsuf}" 4161 ;; 4162 (*) 4163 cf_add_lib= 4164 ;; 4165 esac 4166 if test -n "$cf_add_lib" 4167 then 4168 Libs_To_Make="$Libs_To_Make $cf_add_lib" 4169 continue 4170 fi 4171 fi 4172 cf_add_lib="../lib/${cf_prefix}${cf_libname}${cf_suffix}" 4173 Libs_To_Make="$Libs_To_Make $cf_add_lib" 4174 done 4175 4176 if test $cf_dir = ncurses ; then 4177 cf_subsets="$LIB_SUBSETS" 4178 cf_r_parts="$cf_subsets" 4179 cf_liblist="$Libs_To_Make" 4180 4181 while test -n "$cf_r_parts" 4182 do 4183 cf_l_parts=`echo "$cf_r_parts" |sed -e 's/ .*$//'` 4184 cf_r_parts=`echo "$cf_r_parts" |sed -e 's/^[[^ ]]* //'` 4185 if test "$cf_l_parts" != "$cf_r_parts" ; then 4186 cf_add_lib= 4187 case $cf_l_parts in 4188 (*termlib*) 4189 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TINFO_LIB_SUFFIX}%g` 4190 ;; 4191 (*ticlib*) 4192 cf_add_lib=`echo $cf_liblist |sed -e s%${LIB_NAME}${USE_LIB_SUFFIX}%${TICS_LIB_SUFFIX}%g` 4193 ;; 4194 (*) 4195 break 4196 ;; 4197 esac 4198 if test -n "$cf_add_lib"; then 4199 Libs_To_Make="$cf_add_lib $Libs_To_Make" 4200 fi 4201 else 4202 break 4203 fi 4204 done 4205 else 4206 cf_subsets=`echo "$LIB_SUBSETS" | sed -e 's/^termlib.* //'` 4207 fi 4208 4209 if test $cf_dir = c++; then 4210 if test "x$with_shared_cxx" != xyes && test -n "$cf_shared_suffix"; then 4211 cf_list= 4212 for cf_item in $Libs_To_Make 4213 do 4214 case $cf_item in 4215 (*.a) 4216 ;; 4217 (*) 4218 cf_item=`echo "$cf_item" | sed -e "s,"$cf_shared_suffix",.a,"` 4219 ;; 4220 esac 4221 for cf_test in $cf_list 4222 do 4223 if test "$cf_test" = "$cf_item" 4224 then 4225 cf_LIST_MODELS=`echo "$cf_LIST_MODELS" | sed -e 's/normal//'` 4226 cf_item= 4227 break 4228 fi 4229 done 4230 test -n "$cf_item" && cf_list="$cf_list $cf_item" 4231 done 4232 Libs_To_Make="$cf_list" 4233 fi 4234 fi 4235 4236 sed -e "s%@Libs_To_Make@%$Libs_To_Make%" \ 4237 -e "s%@SHARED_LIB@%$SHARED_LIB%" \ 4238 $cf_dir/Makefile >$cf_dir/Makefile.out 4239 mv $cf_dir/Makefile.out $cf_dir/Makefile 4240 4241 $AWK -f $srcdir/mk-0th.awk \ 4242 libname="${cf_dir}${LIB_SUFFIX}" subsets="$LIB_SUBSETS" ticlib="$TICS_LIB_SUFFIX" termlib="$TINFO_LIB_SUFFIX" \ 4243 $srcdir/$cf_dir/modules >>$cf_dir/Makefile 4244 4245 for cf_subset in $cf_subsets 4246 do 4247 cf_subdirs= 4248 for cf_item in $cf_LIST_MODELS 4249 do 4250 4251 echo "Appending rules for ${cf_item} model (${cf_dir}: ${cf_subset})" 4252 CF_UPPER(cf_ITEM,$cf_item) 4253 4254 CXX_MODEL=$cf_ITEM 4255 if test "$CXX_MODEL" = SHARED; then 4256 case $cf_cv_shlib_version in 4257 (cygdll|msysdll|mingw) 4258 test "x$with_shared_cxx" = xno && CF_VERBOSE(overriding CXX_MODEL to SHARED) 4259 with_shared_cxx=yes 4260 ;; 4261 (*) 4262 test "x$with_shared_cxx" = xno && CXX_MODEL=NORMAL 4263 ;; 4264 esac 4265 fi 4266 4267 CF_LIB_SUFFIX($cf_item,cf_suffix,cf_depsuf) 4268 CF_OBJ_SUBDIR($cf_item,cf_subdir) 4269 4270 # Test for case where we build libtinfo with a different name. 4271 cf_libname=$cf_dir 4272 if test $cf_dir = ncurses ; then 4273 case $cf_subset in 4274 (*base*) 4275 cf_libname=${cf_libname}$USE_LIB_SUFFIX 4276 ;; 4277 (*termlib*) 4278 cf_libname=$TINFO_LIB_SUFFIX 4279 ;; 4280 (ticlib*) 4281 cf_libname=$TICS_LIB_SUFFIX 4282 ;; 4283 esac 4284 elif test $cf_dir = c++ ; then 4285 cf_libname=ncurses++$USE_LIB_SUFFIX 4286 else 4287 cf_libname=${cf_libname}$USE_LIB_SUFFIX 4288 fi 4289 if test -n "${USE_ARG_SUFFIX}" ; then 4290 # undo $USE_LIB_SUFFIX add-on in CF_LIB_SUFFIX 4291 cf_suffix=`echo $cf_suffix |sed -e "s%^${USE_LIB_SUFFIX}%%"` 4292 fi 4293 4294 # These dependencies really are for development, not 4295 # builds, but they are useful in porting, too. 4296 cf_depend="../include/ncurses_cfg.h" 4297 if test "$srcdir" = "."; then 4298 cf_reldir="." 4299 else 4300 cf_reldir="\${srcdir}" 4301 fi 4302 4303 if test -f $srcdir/$cf_dir/$cf_dir.priv.h; then 4304 cf_depend="$cf_depend $cf_reldir/$cf_dir.priv.h" 4305 elif test -f $srcdir/$cf_dir/curses.priv.h; then 4306 cf_depend="$cf_depend $cf_reldir/curses.priv.h" 4307 fi 4308 4309 cf_dir_suffix= 4310 old_cf_suffix="$cf_suffix" 4311 if test "$cf_cv_shlib_version_infix" = yes ; then 4312 if test -n "$USE_LIB_SUFFIX" ; then 4313 case $USE_LIB_SUFFIX in 4314 (tw*) 4315 cf_libname=`echo $cf_libname | sed 's/tw'$EXTRA_SUFFIX'$//'` 4316 cf_suffix=`echo $cf_suffix | sed 's/^tw'$EXTRA_SUFFIX'//'` 4317 cf_dir_suffix=tw$EXTRA_SUFFIX 4318 ;; 4319 (t*) 4320 cf_libname=`echo $cf_libname | sed 's/t'$EXTRA_SUFFIX'$//'` 4321 cf_suffix=`echo $cf_suffix | sed 's/^t'$EXTRA_SUFFIX'//'` 4322 cf_dir_suffix=t$EXTRA_SUFFIX 4323 ;; 4324 (w*) 4325 cf_libname=`echo $cf_libname | sed 's/w'$EXTRA_SUFFIX'$//'` 4326 cf_suffix=`echo $cf_suffix | sed 's/^w'$EXTRA_SUFFIX'//'` 4327 cf_dir_suffix=w$EXTRA_SUFFIX 4328 ;; 4329 (*) 4330 cf_libname=`echo $cf_libname | sed 's/'$EXTRA_SUFFIX'$//'` 4331 cf_suffix=`echo $cf_suffix | sed 's/^'$EXTRA_SUFFIX'//'` 4332 cf_dir_suffix=$EXTRA_SUFFIX 4333 ;; 4334 esac 4335 fi 4336 fi 4337 4338 $AWK -f $srcdir/mk-1st.awk \ 4339 name=${cf_libname}${cf_dir_suffix} \ 4340 traces=$LIB_TRACING \ 4341 MODEL=$cf_ITEM \ 4342 CXX_MODEL=$CXX_MODEL \ 4343 model=$cf_subdir \ 4344 prefix=$cf_prefix \ 4345 suffix=$cf_suffix \ 4346 subset=$cf_subset \ 4347 driver=$cf_cv_term_driver \ 4348 SymLink="$LN_S" \ 4349 TermlibRoot=$TINFO_NAME \ 4350 TermlibSuffix=$TINFO_SUFFIX \ 4351 ShlibVer=$cf_cv_shlib_version \ 4352 ShlibVerInfix=$cf_cv_shlib_version_infix \ 4353 ReLink=${cf_cv_do_relink:-no} \ 4354 ReRanlib=${cf_cv_do_reranlib:-yes} \ 4355 DoLinks=$cf_cv_do_symlinks \ 4356 rmSoLocs=$cf_cv_rm_so_locs \ 4357 ldconfig="$LDCONFIG" \ 4358 overwrite=$WITH_OVERWRITE \ 4359 depend="$cf_depend" \ 4360 host="$host" \ 4361 libtool_version="$LIBTOOL_VERSION" \ 4362 $srcdir/$cf_dir/modules >>$cf_dir/Makefile 4363 4364 cf_suffix="$old_cf_suffix" 4365 4366 for cf_subdir2 in $cf_subdirs lib 4367 do 4368 test $cf_subdir = $cf_subdir2 && break 4369 done 4370 test "${cf_subset}.${cf_subdir2}" != "${cf_subset}.${cf_subdir}" && \ 4371 $AWK -f $srcdir/mk-2nd.awk \ 4372 name=$cf_dir \ 4373 traces=$LIB_TRACING \ 4374 MODEL=$cf_ITEM \ 4375 model=$cf_subdir \ 4376 subset=$cf_subset \ 4377 srcdir=$srcdir \ 4378 echo=$WITH_ECHO \ 4379 crenames=$cf_cv_prog_CC_c_o \ 4380 cxxrenames=$cf_cv_prog_CXX_c_o \ 4381 $srcdir/$cf_dir/modules >>$cf_dir/Makefile 4382 cf_subdirs="$cf_subdirs $cf_subdir" 4383 done 4384 done 4385 fi 4386 4387 echo ' cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >>Makefile 4388done 4389 4390for cf_dir in $SRC_SUBDIRS 4391do 4392 if test ! -d $srcdir/$cf_dir ; then 4393 continue 4394 fi 4395 4396 if test -f $cf_dir/Makefile ; then 4397 case "$cf_dir" in 4398 (Ada95) 4399 echo 'libs \' >> Makefile 4400 echo 'install.libs \' >> Makefile 4401 echo 'uninstall.libs ::' >> Makefile 4402 echo ' cd '$cf_dir' && ${MAKE} ${TOP_MFLAGS} [$]@' >> Makefile 4403 ;; 4404 esac 4405 fi 4406 4407 if test -f $srcdir/$cf_dir/modules; then 4408 echo >> Makefile 4409 if test -f $srcdir/$cf_dir/headers; then 4410cat >> Makefile <<CF_EOF 4411install.includes \\ 4412uninstall.includes \\ 4413CF_EOF 4414 fi 4415if test "$cf_dir" != "c++" ; then 4416echo 'lint \' >> Makefile 4417fi 4418cat >> Makefile <<CF_EOF 4419libs \\ 4420lintlib \\ 4421install.libs \\ 4422uninstall.libs \\ 4423install.$cf_dir \\ 4424uninstall.$cf_dir :: 4425 cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@ 4426CF_EOF 4427 elif test -f $srcdir/$cf_dir/headers; then 4428cat >> Makefile <<CF_EOF 4429 4430libs \\ 4431install.libs \\ 4432uninstall.libs \\ 4433install.includes \\ 4434uninstall.includes :: 4435 cd $cf_dir && \${MAKE} \${TOP_MFLAGS} \[$]@ 4436CF_EOF 4437fi 4438done 4439 4440if test "x$cf_with_db_install" = xyes; then 4441cat >> Makefile <<CF_EOF 4442 4443install.libs uninstall.libs \\ 4444install.data uninstall.data :: 4445$MAKE_TERMINFO cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ 4446CF_EOF 4447else 4448cat >> Makefile <<CF_EOF 4449 4450install.libs uninstall.libs :: 4451 cd misc && \${MAKE} \${TOP_MFLAGS} \[$]@ 4452CF_EOF 4453fi 4454 4455if test "x$cf_with_manpages" = xyes; then 4456cat >> Makefile <<CF_EOF 4457 4458install.man \\ 4459uninstall.man :: 4460 cd man && \${MAKE} \${TOP_MFLAGS} \[$]@ 4461CF_EOF 4462fi 4463 4464cat >> Makefile <<CF_EOF 4465 4466distclean :: 4467 rm -f config.cache config.log config.status Makefile include/ncurses_cfg.h 4468 rm -f headers.sh headers.sed mk_shared_lib.sh 4469 rm -f edit_man.* man_alias.* 4470 rm -rf \${DIRS_TO_MAKE} 4471CF_EOF 4472 4473# Special case: tack's manpage lives in its own directory. 4474if test "x$cf_with_manpages" = xyes; then 4475if test "x$cf_with_tack" = "xyes"; then 4476cat >> Makefile <<CF_EOF 4477 4478install.man \\ 4479uninstall.man :: 4480 cd tack && \${MAKE} \${TOP_MFLAGS} \[$]@ 4481CF_EOF 4482fi 4483fi 4484 4485dnl If we're installing into a subdirectory of /usr/include, etc., we should 4486dnl prepend the subdirectory's name to the "#include" paths. It won't hurt 4487dnl anything, and will make it more standardized. It's awkward to decide this 4488dnl at configuration because of quoting, so we'll simply make all headers 4489dnl installed via a script that can do the right thing. 4490 4491rm -f headers.sed headers.sh 4492 4493dnl ( generating this script makes the makefiles a little tidier :-) 4494echo creating headers.sh 4495cat >headers.sh <<CF_EOF 4496#! $SHELL 4497# This shell script is generated by the 'configure' script. It is invoked in a 4498# subdirectory of the build tree. It generates a sed-script in the parent 4499# directory that is used to adjust includes for header files that reside in a 4500# subdirectory of /usr/include, etc. 4501PRG="" 4502while test \[$]# != 3 4503do 4504PRG="\$PRG \[$]1"; shift 4505done 4506DST=\[$]1 4507REF=\[$]2 4508SRC=\[$]3 4509TMPSRC=\${TMPDIR:-/tmp}/\`basename \$SRC\`\$\$ 4510TMPSED=\${TMPDIR:-/tmp}/headers.sed\$\$ 4511echo installing \$SRC in \$DST 4512CF_EOF 4513 4514if test $WITH_CURSES_H = yes; then 4515 cat >>headers.sh <<CF_EOF 4516case \$DST in 4517(/*/include/*) 4518 END=\`basename \$DST\` 4519 for i in \`cat \$REF/../*/headers |fgrep -v "#"\` 4520 do 4521 NAME=\`basename \$i\` 4522 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED 4523 done 4524 ;; 4525(*) 4526 echo "" >> \$TMPSED 4527 ;; 4528esac 4529CF_EOF 4530 4531else 4532 cat >>headers.sh <<CF_EOF 4533case \$DST in 4534(/*/include/*) 4535 END=\`basename \$DST\` 4536 for i in \`cat \$REF/../*/headers |fgrep -v "#"\` 4537 do 4538 NAME=\`basename \$i\` 4539 if test "\$NAME" = "curses.h" 4540 then 4541 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED 4542 NAME=ncurses.h 4543 fi 4544 echo "s/<\$NAME>/<\$END\/\$NAME>/" >> \$TMPSED 4545 done 4546 ;; 4547(*) 4548 echo "s/<curses.h>/<ncurses.h>/" >> \$TMPSED 4549 ;; 4550esac 4551CF_EOF 4552fi 4553cat >>headers.sh <<CF_EOF 4554rm -f \$TMPSRC 4555sed -f \$TMPSED \$SRC > \$TMPSRC 4556NAME=\`basename \$SRC\` 4557CF_EOF 4558if test $WITH_CURSES_H != yes; then 4559 cat >>headers.sh <<CF_EOF 4560test "\$NAME" = "curses.h" && NAME=ncurses.h 4561CF_EOF 4562fi 4563cat >>headers.sh <<CF_EOF 4564# Just in case someone gzip'd manpages, remove the conflicting copy. 4565test -f \$DST/\$NAME.gz && rm -f \$DST/\$NAME.gz 4566 4567eval \$PRG \$TMPSRC \$DST/\$NAME 4568rm -f \$TMPSRC \$TMPSED 4569CF_EOF 4570 4571chmod 0755 headers.sh 4572 4573for cf_dir in $SRC_SUBDIRS 4574do 4575 if test ! -d $srcdir/$cf_dir ; then 4576 continue 4577 fi 4578 4579 if test -f $srcdir/$cf_dir/headers; then 4580 $AWK -f $srcdir/mk-hdr.awk \ 4581 subset="$LIB_SUBSETS" \ 4582 compat="$WITH_CURSES_H" \ 4583 $srcdir/$cf_dir/headers >>$cf_dir/Makefile 4584 fi 4585 4586 if test -f $srcdir/$cf_dir/modules; then 4587 if test "$cf_dir" != "c++" ; then 4588 cat >>$cf_dir/Makefile <<"CF_EOF" 4589depend : ${AUTO_SRC} 4590 makedepend -- ${CPPFLAGS} -- ${C_SRC} 4591 4592# DO NOT DELETE THIS LINE -- make depend depends on it. 4593CF_EOF 4594 fi 4595 fi 4596done 4597AC_SUBST(Libs_To_Make) 4598])dnl 4599dnl --------------------------------------------------------------------------- 4600dnl CF_LIB_SONAME version: 6 updated: 2017/01/21 11:06:25 4601dnl ------------- 4602dnl Find the and soname for the given shared library. Set the cache variable 4603dnl cf_cv_$3_soname to this, unless it is not found. Then set the cache 4604dnl variable to "unknown". 4605dnl 4606dnl $1 = headers 4607dnl $2 = code 4608dnl $3 = library name 4609AC_DEFUN([CF_LIB_SONAME], 4610[ 4611AC_CACHE_CHECK(for soname of $3 library,cf_cv_$3_soname,[ 4612 4613cf_cv_$3_soname=unknown 4614if test "$cross_compiling" != yes ; then 4615cat >conftest.$ac_ext <<CF_EOF 4616$1 4617int main(void) 4618{ 4619$2 4620 ${cf_cv_main_return:-return}(0); 4621} 4622CF_EOF 4623cf_save_LIBS="$LIBS" 4624 CF_ADD_LIB($3) 4625 if AC_TRY_EVAL(ac_compile) ; then 4626 if AC_TRY_EVAL(ac_link) ; then 4627 cf_cv_$3_soname=`ldd conftest$ac_exeext 2>/dev/null | sed -e 's,^.*/,,' -e 's, .*$,,' | fgrep lib$3.` 4628 test -z "$cf_cv_$3_soname" && cf_cv_$3_soname=unknown 4629 fi 4630 fi 4631rm -rf conftest* 4632LIBS="$cf_save_LIBS" 4633fi 4634]) 4635]) 4636dnl --------------------------------------------------------------------------- 4637dnl CF_LIB_SUFFIX version: 25 updated: 2015/04/17 21:13:04 4638dnl ------------- 4639dnl Compute the library file-suffix from the given model name 4640dnl $1 = model name 4641dnl $2 = variable to set (the nominal library suffix) 4642dnl $3 = dependency variable to set (actual filename) 4643dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. 4644AC_DEFUN([CF_LIB_SUFFIX], 4645[ 4646 case X$1 in 4647 (Xlibtool) 4648 $2='.la' 4649 $3=[$]$2 4650 ;; 4651 (Xdebug) 4652 $2='_g.a' 4653 $3=[$]$2 4654 ;; 4655 (Xprofile) 4656 $2='_p.a' 4657 $3=[$]$2 4658 ;; 4659 (Xshared) 4660 case $cf_cv_system_name in 4661 (aix[[5-7]]*) 4662 $2='.so' 4663 $3=[$]$2 4664 ;; 4665 (cygwin*|msys*|mingw*) 4666 $2='.dll' 4667 $3='.dll.a' 4668 ;; 4669 (darwin*) 4670 $2='.dylib' 4671 $3=[$]$2 4672 ;; 4673 (hpux*) 4674 case $target in 4675 (ia64*) 4676 $2='.so' 4677 $3=[$]$2 4678 ;; 4679 (*) 4680 $2='.sl' 4681 $3=[$]$2 4682 ;; 4683 esac 4684 ;; 4685 (*) 4686 $2='.so' 4687 $3=[$]$2 4688 ;; 4689 esac 4690 ;; 4691 (*) 4692 $2='.a' 4693 $3=[$]$2 4694 ;; 4695 esac 4696 if test -n "${LIB_SUFFIX}${EXTRA_SUFFIX}" 4697 then 4698 $2="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$2}" 4699 $3="${LIB_SUFFIX}${EXTRA_SUFFIX}[$]{$3}" 4700 fi 4701])dnl 4702dnl --------------------------------------------------------------------------- 4703dnl CF_LIB_TYPE version: 5 updated: 2015/04/17 21:13:04 4704dnl ----------- 4705dnl Compute the string to append to -library from the given model name 4706dnl $1 = model name 4707dnl $2 = variable to set 4708dnl The variable $LIB_SUFFIX, if set, prepends the variable to set. 4709AC_DEFUN([CF_LIB_TYPE], 4710[ 4711 case $1 in 4712 (libtool) $2='' ;; 4713 (normal) $2='' ;; 4714 (debug) $2='_g' ;; 4715 (profile) $2='_p' ;; 4716 (shared) $2='' ;; 4717 esac 4718 test -n "$LIB_SUFFIX" && $2="${LIB_SUFFIX}[$]{$2}" 4719])dnl 4720dnl --------------------------------------------------------------------------- 4721dnl CF_LINK_DATAONLY version: 13 updated: 2020/02/08 15:59:30 4722dnl ---------------- 4723dnl Some systems have a non-ANSI linker that doesn't pull in modules that have 4724dnl only data (i.e., no functions), for example NeXT. On those systems we'll 4725dnl have to provide wrappers for global tables to ensure they're linked 4726dnl properly. 4727AC_DEFUN([CF_LINK_DATAONLY], 4728[ 4729AC_MSG_CHECKING([if data-only library module links]) 4730AC_CACHE_VAL(cf_cv_link_dataonly,[ 4731 rm -f conftest.a 4732 cat >conftest.$ac_ext <<EOF 4733#line __oline__ "configure" 4734int testdata[[3]] = { 123, 456, 789 }; 4735EOF 4736 if AC_TRY_EVAL(ac_compile) ; then 4737 mv conftest.o data.o && \ 4738 ( $AR $ARFLAGS conftest.a data.o ) 2>&AC_FD_CC 1>/dev/null 4739 fi 4740 rm -f conftest.$ac_ext data.o 4741 cat >conftest.$ac_ext <<EOF 4742#line __oline__ "configure" 4743int testfunc(void) 4744{ 4745#if defined(NeXT) 4746 ${cf_cv_main_return:-return}(1); /* I'm told this linker is broken */ 4747#else 4748 extern int testdata[[3]]; 4749 return testdata[[0]] == 123 4750 && testdata[[1]] == 456 4751 && testdata[[2]] == 789; 4752#endif 4753} 4754EOF 4755 if AC_TRY_EVAL(ac_compile); then 4756 mv conftest.o func.o && \ 4757 ( $AR $ARFLAGS conftest.a func.o ) 2>&AC_FD_CC 1>/dev/null 4758 fi 4759 rm -f conftest.$ac_ext func.o 4760 ( eval $RANLIB conftest.a ) 2>&AC_FD_CC >/dev/null 4761 cf_saveLIBS="$LIBS" 4762 LIBS="conftest.a $LIBS" 4763 AC_TRY_RUN([ 4764 int main(void) 4765 { 4766 extern int testfunc(); 4767 ${cf_cv_main_return:-return} (!testfunc()); 4768 } 4769 ], 4770 [cf_cv_link_dataonly=yes], 4771 [cf_cv_link_dataonly=no], 4772 [cf_cv_link_dataonly=unknown]) 4773 LIBS="$cf_saveLIBS" 4774 ]) 4775AC_MSG_RESULT($cf_cv_link_dataonly) 4776 4777if test "$cf_cv_link_dataonly" = no ; then 4778 AC_DEFINE(BROKEN_LINKER,1,[if data-only library module does not link]) 4779 BROKEN_LINKER=1 4780fi 4781AC_SUBST(BROKEN_LINKER) 4782 4783])dnl 4784dnl --------------------------------------------------------------------------- 4785dnl CF_LINK_FUNCS version: 9 updated: 2017/01/21 11:11:02 4786dnl ------------- 4787dnl Most Unix systems have both link and symlink, a few don't have symlink. 4788dnl A few non-Unix systems implement symlink, but not link. 4789dnl A few non-systems implement neither (or have nonfunctional versions). 4790AC_DEFUN([CF_LINK_FUNCS], 4791[ 4792AC_CHECK_HEADERS( \ 4793unistd.h \ 4794) 4795AC_CHECK_FUNCS( \ 4796 remove \ 4797 unlink ) 4798 4799if test "$cross_compiling" = yes ; then 4800 AC_CHECK_FUNCS( \ 4801 link \ 4802 symlink ) 4803else 4804 AC_CACHE_CHECK(if link/symlink functions work,cf_cv_link_funcs,[ 4805 cf_cv_link_funcs= 4806 for cf_func in link symlink ; do 4807 AC_TRY_RUN([ 4808#include <sys/types.h> 4809#include <sys/stat.h> 4810#ifdef HAVE_UNISTD_H 4811#include <unistd.h> 4812#endif 4813int main(void) 4814{ 4815 int fail = 0; 4816 char *src = "config.log"; 4817 char *dst = "conftest.chk"; 4818 struct stat src_sb; 4819 struct stat dst_sb; 4820 4821 stat(src, &src_sb); 4822 fail = ($cf_func("config.log", "conftest.chk") < 0) 4823 || (stat(dst, &dst_sb) < 0) 4824 || (dst_sb.st_mtime != src_sb.st_mtime); 4825#ifdef HAVE_UNLINK 4826 unlink(dst); 4827#else 4828 remove(dst); 4829#endif 4830 ${cf_cv_main_return:-return} (fail); 4831} 4832 ],[ 4833 cf_cv_link_funcs="$cf_cv_link_funcs $cf_func" 4834 eval 'ac_cv_func_'$cf_func'=yes'],[ 4835 eval 'ac_cv_func_'$cf_func'=no'],[ 4836 eval 'ac_cv_func_'$cf_func'=error']) 4837 done 4838 test -z "$cf_cv_link_funcs" && cf_cv_link_funcs=no 4839 ]) 4840 test "$ac_cv_func_link" = yes && AC_DEFINE(HAVE_LINK,1,[Define to 1 if we have link() function]) 4841 test "$ac_cv_func_symlink" = yes && AC_DEFINE(HAVE_SYMLINK,1,[Define to 1 if we have symlink() function]) 4842fi 4843])dnl 4844dnl --------------------------------------------------------------------------- 4845dnl CF_MAKEFLAGS version: 18 updated: 2018/02/21 21:26:03 4846dnl ------------ 4847dnl Some 'make' programs support ${MAKEFLAGS}, some ${MFLAGS}, to pass 'make' 4848dnl options to lower-levels. It's very useful for "make -n" -- if we have it. 4849dnl (GNU 'make' does both, something POSIX 'make', which happens to make the 4850dnl ${MAKEFLAGS} variable incompatible because it adds the assignments :-) 4851AC_DEFUN([CF_MAKEFLAGS], 4852[ 4853AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[ 4854 cf_cv_makeflags='' 4855 for cf_option in '-${MAKEFLAGS}' '${MFLAGS}' 4856 do 4857 cat >cf_makeflags.tmp <<CF_EOF 4858SHELL = $SHELL 4859all : 4860 @ echo '.$cf_option' 4861CF_EOF 4862 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp 2>/dev/null | fgrep -v "ing directory" | sed -e 's,[[ ]]*$,,'` 4863 case "$cf_result" in 4864 (.*k|.*kw) 4865 cf_result=`${MAKE:-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null` 4866 case "$cf_result" in 4867 (.*CC=*) cf_cv_makeflags= 4868 ;; 4869 (*) cf_cv_makeflags=$cf_option 4870 ;; 4871 esac 4872 break 4873 ;; 4874 (.-) 4875 ;; 4876 (*) 4877 CF_MSG_LOG(given option \"$cf_option\", no match \"$cf_result\") 4878 ;; 4879 esac 4880 done 4881 rm -f cf_makeflags.tmp 4882]) 4883 4884AC_SUBST(cf_cv_makeflags) 4885])dnl 4886dnl --------------------------------------------------------------------------- 4887dnl CF_MAKE_TAGS version: 6 updated: 2010/10/23 15:52:32 4888dnl ------------ 4889dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have 4890dnl a monocase filesystem. 4891AC_DEFUN([CF_MAKE_TAGS],[ 4892AC_REQUIRE([CF_MIXEDCASE_FILENAMES]) 4893 4894AC_CHECK_PROGS(CTAGS, exctags ctags) 4895AC_CHECK_PROGS(ETAGS, exetags etags) 4896 4897AC_CHECK_PROG(MAKE_LOWER_TAGS, ${CTAGS:-ctags}, yes, no) 4898 4899if test "$cf_cv_mixedcase" = yes ; then 4900 AC_CHECK_PROG(MAKE_UPPER_TAGS, ${ETAGS:-etags}, yes, no) 4901else 4902 MAKE_UPPER_TAGS=no 4903fi 4904 4905if test "$MAKE_UPPER_TAGS" = yes ; then 4906 MAKE_UPPER_TAGS= 4907else 4908 MAKE_UPPER_TAGS="#" 4909fi 4910 4911if test "$MAKE_LOWER_TAGS" = yes ; then 4912 MAKE_LOWER_TAGS= 4913else 4914 MAKE_LOWER_TAGS="#" 4915fi 4916 4917AC_SUBST(CTAGS) 4918AC_SUBST(ETAGS) 4919 4920AC_SUBST(MAKE_UPPER_TAGS) 4921AC_SUBST(MAKE_LOWER_TAGS) 4922])dnl 4923dnl --------------------------------------------------------------------------- 4924dnl CF_MANPAGE_FORMAT version: 11 updated: 2015/04/18 08:56:57 4925dnl ----------------- 4926dnl Option to allow user to override automatic configuration of manpage format. 4927dnl There are several special cases: 4928dnl 4929dnl gzip - man checks for, can display gzip'd files 4930dnl compress - man checks for, can display compressed files 4931dnl BSDI - files in the cat-directories are suffixed ".0" 4932dnl formatted - installer should format (put files in cat-directory) 4933dnl catonly - installer should only format, e.g., for a turnkey system. 4934dnl 4935dnl There are other configurations which this macro does not test, e.g., HPUX's 4936dnl compressed manpages (but uncompressed manpages are fine, and HPUX's naming 4937dnl convention would not match our use). 4938AC_DEFUN([CF_MANPAGE_FORMAT], 4939[ 4940AC_REQUIRE([CF_PATHSEP]) 4941AC_MSG_CHECKING(format of man-pages) 4942 4943AC_ARG_WITH(manpage-format, 4944 [ --with-manpage-format specify manpage-format: gzip/compress/BSDI/normal and 4945 optionally formatted/catonly, e.g., gzip,formatted], 4946 [MANPAGE_FORMAT=$withval], 4947 [MANPAGE_FORMAT=unknown]) 4948 4949test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=unknown 4950MANPAGE_FORMAT=`echo "$MANPAGE_FORMAT" | sed -e 's/,/ /g'` 4951 4952cf_unknown= 4953 4954case $MANPAGE_FORMAT in 4955(unknown) 4956 if test -z "$MANPATH" ; then 4957 MANPATH="/usr/man:/usr/share/man" 4958 fi 4959 4960 # look for the 'date' man-page (it's most likely to be installed!) 4961 MANPAGE_FORMAT= 4962 cf_preform=no 4963 cf_catonly=yes 4964 cf_example=date 4965 4966 IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}" 4967 for cf_dir in $MANPATH; do 4968 test -z "$cf_dir" && cf_dir=/usr/man 4969 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 4970 do 4971 cf_test=`echo $cf_name | sed -e 's/*//'` 4972 if test "x$cf_test" = "x$cf_name" ; then 4973 4974 case "$cf_name" in 4975 (*.gz) MANPAGE_FORMAT="$MANPAGE_FORMAT gzip";; 4976 (*.Z) MANPAGE_FORMAT="$MANPAGE_FORMAT compress";; 4977 (*.0) MANPAGE_FORMAT="$MANPAGE_FORMAT BSDI";; 4978 (*) MANPAGE_FORMAT="$MANPAGE_FORMAT normal";; 4979 esac 4980 4981 case "$cf_name" in 4982 ($cf_dir/man*) 4983 cf_catonly=no 4984 ;; 4985 ($cf_dir/cat*) 4986 cf_preform=yes 4987 ;; 4988 esac 4989 break 4990 fi 4991 4992 # if we found a match in either man* or cat*, stop looking 4993 if test -n "$MANPAGE_FORMAT" ; then 4994 cf_found=no 4995 test "$cf_preform" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT formatted" 4996 test "$cf_catonly" = yes && MANPAGE_FORMAT="$MANPAGE_FORMAT catonly" 4997 case "$cf_name" in 4998 ($cf_dir/cat*) 4999 cf_found=yes 5000 ;; 5001 esac 5002 test $cf_found=yes && break 5003 fi 5004 done 5005 # only check the first directory in $MANPATH where we find manpages 5006 if test -n "$MANPAGE_FORMAT" ; then 5007 break 5008 fi 5009 done 5010 # if we did not find the example, just assume it is normal 5011 test -z "$MANPAGE_FORMAT" && MANPAGE_FORMAT=normal 5012 IFS="$ac_save_ifs" 5013 ;; 5014(*) 5015 for cf_option in $MANPAGE_FORMAT; do 5016 case $cf_option in 5017 (gzip|compress|BSDI|normal|formatted|catonly) 5018 ;; 5019 (*) 5020 cf_unknown="$cf_unknown $cf_option" 5021 ;; 5022 esac 5023 done 5024 ;; 5025esac 5026 5027AC_MSG_RESULT($MANPAGE_FORMAT) 5028if test -n "$cf_unknown" ; then 5029 AC_MSG_WARN(Unexpected manpage-format $cf_unknown) 5030fi 5031])dnl 5032dnl --------------------------------------------------------------------------- 5033dnl CF_MANPAGE_RENAMES version: 10 updated: 2015/08/05 20:44:28 5034dnl ------------------ 5035dnl The Debian people have their own naming convention for manpages. This 5036dnl option lets us override the name of the file containing renaming, or 5037dnl disable it altogether. 5038AC_DEFUN([CF_MANPAGE_RENAMES], 5039[ 5040AC_MSG_CHECKING(for manpage renaming) 5041 5042AC_ARG_WITH(manpage-renames, 5043 [ --with-manpage-renames specify manpage-renaming], 5044 [MANPAGE_RENAMES=$withval], 5045 [MANPAGE_RENAMES=yes]) 5046 5047case ".$MANPAGE_RENAMES" in 5048(.no) 5049 ;; 5050(.|.yes) 5051 # Debian 'man' program? 5052 if test -f /etc/debian_version ; then 5053 MANPAGE_RENAMES=`cd $srcdir && pwd`/man/man_db.renames 5054 else 5055 MANPAGE_RENAMES=no 5056 fi 5057 ;; 5058esac 5059 5060if test "$MANPAGE_RENAMES" != no ; then 5061 if test -f $srcdir/man/$MANPAGE_RENAMES ; then 5062 MANPAGE_RENAMES=`cd $srcdir/man && pwd`/$MANPAGE_RENAMES 5063 elif test ! -f $MANPAGE_RENAMES ; then 5064 AC_MSG_ERROR(not a filename: $MANPAGE_RENAMES) 5065 fi 5066 5067 test ! -d man && mkdir man 5068 5069 # Construct a sed-script to perform renaming within man-pages 5070 if test -n "$MANPAGE_RENAMES" ; then 5071 test ! -d man && mkdir man 5072 $SHELL $srcdir/man/make_sed.sh $MANPAGE_RENAMES >./edit_man.sed 5073 fi 5074fi 5075 5076AC_MSG_RESULT($MANPAGE_RENAMES) 5077AC_SUBST(MANPAGE_RENAMES) 5078])dnl 5079dnl --------------------------------------------------------------------------- 5080dnl CF_MANPAGE_SYMLINKS version: 6 updated: 2015/04/17 21:13:04 5081dnl ------------------- 5082dnl Some people expect each tool to make all aliases for manpages in the 5083dnl man-directory. This accommodates the older, less-capable implementations 5084dnl of 'man', and is optional. 5085AC_DEFUN([CF_MANPAGE_SYMLINKS], 5086[ 5087AC_MSG_CHECKING(if manpage aliases will be installed) 5088 5089AC_ARG_WITH(manpage-aliases, 5090 [ --with-manpage-aliases specify manpage-aliases using .so], 5091 [MANPAGE_ALIASES=$withval], 5092 [MANPAGE_ALIASES=yes]) 5093 5094AC_MSG_RESULT($MANPAGE_ALIASES) 5095 5096case "x$LN_S" in 5097(xln*) 5098 cf_use_symlinks=yes 5099 ;; 5100(*) 5101 cf_use_symlinks=no 5102 ;; 5103esac 5104 5105MANPAGE_SYMLINKS=no 5106if test "$MANPAGE_ALIASES" = yes ; then 5107AC_MSG_CHECKING(if manpage symlinks should be used) 5108 5109AC_ARG_WITH(manpage-symlinks, 5110 [ --with-manpage-symlinks specify manpage-aliases using symlinks], 5111 [MANPAGE_SYMLINKS=$withval], 5112 [MANPAGE_SYMLINKS=$cf_use_symlinks]) 5113 5114if test "$$cf_use_symlinks" = no; then 5115if test "$MANPAGE_SYMLINKS" = yes ; then 5116 AC_MSG_WARN(cannot make symlinks, will use .so files) 5117 MANPAGE_SYMLINKS=no 5118fi 5119fi 5120 5121AC_MSG_RESULT($MANPAGE_SYMLINKS) 5122fi 5123 5124])dnl 5125dnl --------------------------------------------------------------------------- 5126dnl CF_MANPAGE_TBL version: 3 updated: 2002/01/19 22:51:32 5127dnl -------------- 5128dnl This option causes manpages to be run through tbl(1) to generate tables 5129dnl correctly. 5130AC_DEFUN([CF_MANPAGE_TBL], 5131[ 5132AC_MSG_CHECKING(for manpage tbl) 5133 5134AC_ARG_WITH(manpage-tbl, 5135 [ --with-manpage-tbl specify manpage processing with tbl], 5136 [MANPAGE_TBL=$withval], 5137 [MANPAGE_TBL=no]) 5138 5139AC_MSG_RESULT($MANPAGE_TBL) 5140])dnl 5141dnl --------------------------------------------------------------------------- 5142dnl CF_MAN_PAGES version: 47 updated: 2017/08/12 07:58:51 5143dnl ------------ 5144dnl Try to determine if the man-pages on the system are compressed, and if 5145dnl so, what format is used. Use this information to construct a script that 5146dnl will install man-pages. 5147AC_DEFUN([CF_MAN_PAGES], 5148[ 5149CF_HELP_MESSAGE(Options to Specify How Manpages are Installed:) 5150CF_MANPAGE_FORMAT 5151CF_MANPAGE_RENAMES 5152CF_MANPAGE_SYMLINKS 5153CF_MANPAGE_TBL 5154 5155if test "$prefix" = "NONE" ; then 5156 cf_prefix="$ac_default_prefix" 5157else 5158 cf_prefix="$prefix" 5159fi 5160 5161case "$MANPAGE_FORMAT" in 5162(*catonly*) 5163 cf_format=yes 5164 cf_inboth=no 5165 ;; 5166(*formatted*) 5167 cf_format=yes 5168 cf_inboth=yes 5169 ;; 5170(*) 5171 cf_format=no 5172 cf_inboth=no 5173 ;; 5174esac 5175 5176test ! -d man && mkdir man 5177 5178cf_so_strip= 5179cf_compress= 5180case "$MANPAGE_FORMAT" in 5181(*compress*) 5182 cf_so_strip="Z" 5183 cf_compress=compress 5184 ;; 5185(*gzip*) 5186 cf_so_strip="gz" 5187 cf_compress=gzip 5188 ;; 5189esac 5190 5191cf_edit_man=./edit_man.sh 5192cf_man_alias=`pwd`/man_alias.sed 5193 5194cat >$cf_edit_man <<CF_EOF 5195#! $SHELL 5196# this script is generated by the configure-script CF_MAN_PAGES macro. 5197 5198prefix="$cf_prefix" 5199datarootdir="$datarootdir" 5200datadir="$datadir" 5201 5202NCURSES_MAJOR="$NCURSES_MAJOR" 5203NCURSES_MINOR="$NCURSES_MINOR" 5204NCURSES_PATCH="$NCURSES_PATCH" 5205 5206NCURSES_OSPEED="$NCURSES_OSPEED" 5207TERMINFO="$TERMINFO" 5208 5209INSTALL="$INSTALL" 5210INSTALL_DATA="$INSTALL_DATA" 5211 5212transform="$program_transform_name" 5213 5214TMP=\${TMPDIR:=/tmp}/man\$\$ 5215trap "rm -f \$TMP" 0 1 2 3 15 5216 5217form=\[$]1 5218shift || exit 1 5219 5220verb=\[$]1 5221shift || exit 1 5222 5223mandir=\[$]1 5224shift || exit 1 5225 5226srcdir=\[$]1 5227top_srcdir=\[$]srcdir/.. 5228shift || exit 1 5229 5230if test "\$form" = normal ; then 5231 if test "$cf_format" = yes ; then 5232 if test "$cf_inboth" = no ; then 5233 $SHELL \[$]0 format \$verb \$mandir \$srcdir \[$]* 5234 exit $? 5235 fi 5236 fi 5237 cf_subdir=\$mandir/man 5238 cf_tables=$MANPAGE_TBL 5239else 5240 cf_subdir=\$mandir/cat 5241 cf_tables=yes 5242fi 5243 5244# process the list of source-files 5245for i in \[$]* ; do 5246case \$i in 5247(*.orig|*.rej) ;; 5248(*.[[0-9]]*) 5249 section=\`expr "\$i" : '.*\\.\\([[0-9]]\\)[[xm]]*'\`; 5250 if test \$verb = installing ; then 5251 if test ! -d \$cf_subdir\${section} ; then 5252 mkdir -p \$cf_subdir\$section 5253 fi 5254 fi 5255 5256 # replace variables in man page 5257 if test ! -f $cf_man_alias ; then 5258cat >>$cf_man_alias <<-CF_EOF2 5259 s,@DATADIR@,\$datadir,g 5260 s,@TERMINFO@,\${TERMINFO:="no default value"},g 5261 s,@TERMINFO_DIRS@,\${TERMINFO_DIRS:="no default value"},g 5262 s,@NCURSES_MAJOR@,\${NCURSES_MAJOR:="no default value"},g 5263 s,@NCURSES_MINOR@,\${NCURSES_MINOR:="no default value"},g 5264 s,@NCURSES_PATCH@,\${NCURSES_PATCH:="no default value"},g 5265 s,@NCURSES_OSPEED@,\${NCURSES_OSPEED:="no default value"},g 5266CF_EOF 5267 ifelse($1,,,[ 5268 for cf_name in $1 5269 do 5270 cf_NAME=`echo "$cf_name" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` 5271 cf_name=`echo $cf_name|sed "$program_transform_name"` 5272cat >>$cf_edit_man <<-CF_EOF 5273 s,@$cf_NAME@,$cf_name,g 5274CF_EOF 5275 done 5276 ]) 5277cat >>$cf_edit_man <<CF_EOF 5278CF_EOF2 5279 echo "...made $cf_man_alias" 5280 fi 5281 5282 aliases= 5283 cf_source=\`basename \$i\` 5284 inalias=\$cf_source 5285 test ! -f \$inalias && inalias="\$srcdir/\$inalias" 5286 if test ! -f \$inalias ; then 5287 echo .. skipped \$cf_source 5288 continue 5289 fi 5290CF_EOF 5291 5292if test "$MANPAGE_ALIASES" != no ; then 5293cat >>$cf_edit_man <<CF_EOF 5294 nCurses=ignore.3x 5295 test $with_curses_h = yes && nCurses=ncurses.3x 5296 aliases=\`sed -f \$top_srcdir/man/manlinks.sed \$inalias |sed -f $cf_man_alias | sort -u; test \$inalias = \$nCurses && echo curses\` 5297CF_EOF 5298fi 5299 5300if test "$MANPAGE_RENAMES" = no ; then 5301cat >>$cf_edit_man <<CF_EOF 5302 # perform program transformations for section 1 man pages 5303 if test \$section = 1 ; then 5304 cf_target=\$cf_subdir\${section}/\`echo \$cf_source|sed "\${transform}"\` 5305 else 5306 cf_target=\$cf_subdir\${section}/\$cf_source 5307 fi 5308CF_EOF 5309else 5310cat >>$cf_edit_man <<CF_EOF 5311 cf_target=\`grep "^\$cf_source" $MANPAGE_RENAMES | $AWK '{print \[$]2}'\` 5312 if test -z "\$cf_target" ; then 5313 echo '? missing rename for '\$cf_source 5314 cf_target="\$cf_source" 5315 fi 5316 cf_target="\$cf_subdir\${section}/\${cf_target}" 5317 5318CF_EOF 5319fi 5320 5321cat >>$cf_edit_man <<CF_EOF 5322 sed -f $cf_man_alias \\ 5323CF_EOF 5324 5325if test -f $MANPAGE_RENAMES ; then 5326cat >>$cf_edit_man <<CF_EOF 5327 < \$i | sed -f `pwd`/edit_man.sed >\$TMP 5328CF_EOF 5329else 5330cat >>$cf_edit_man <<CF_EOF 5331 < \$i >\$TMP 5332CF_EOF 5333fi 5334 5335cat >>$cf_edit_man <<CF_EOF 5336if test \$cf_tables = yes ; then 5337 tbl \$TMP >\$TMP.out 5338 mv \$TMP.out \$TMP 5339fi 5340CF_EOF 5341 5342if test $with_overwrite != yes ; then 5343cat >>$cf_edit_man <<CF_EOF 5344 sed -e "/\#[ ]*include/s,<curses.h,<ncurses$LIB_SUFFIX/curses.h," < \$TMP >\$TMP.out 5345 mv \$TMP.out \$TMP 5346CF_EOF 5347fi 5348 5349if test $with_curses_h != yes ; then 5350cat >>$cf_edit_man <<CF_EOF 5351 sed -e "/\#[ ]*include/s,curses.h,ncurses.h," < \$TMP >\$TMP.out 5352 mv \$TMP.out \$TMP 5353CF_EOF 5354fi 5355 5356cat >>$cf_edit_man <<CF_EOF 5357 if test \$form = format ; then 5358 nroff -man \$TMP >\$TMP.out 5359 mv \$TMP.out \$TMP 5360 fi 5361CF_EOF 5362 5363if test -n "$cf_compress" ; then 5364cat >>$cf_edit_man <<CF_EOF 5365 if test \$verb = installing ; then 5366 if ( $cf_compress -f \$TMP ) 5367 then 5368 mv \$TMP.$cf_so_strip \$TMP 5369 fi 5370 fi 5371 cf_target="\$cf_target.$cf_so_strip" 5372CF_EOF 5373fi 5374 5375case "$MANPAGE_FORMAT" in 5376(*BSDI*) 5377cat >>$cf_edit_man <<CF_EOF 5378 if test \$form = format ; then 5379 # BSDI installs only .0 suffixes in the cat directories 5380 cf_target="\`echo \$cf_target|sed -e 's/\.[[1-9]]\+[[a-z]]*/.0/'\`" 5381 fi 5382CF_EOF 5383 ;; 5384esac 5385 5386cat >>$cf_edit_man <<CF_EOF 5387 suffix=\`basename \$cf_target | sed -e 's%^[[^.]]*%%'\` 5388 if test \$verb = installing ; then 5389 echo \$verb \$cf_target 5390 \$INSTALL_DATA \$TMP \$cf_target 5391 test -d \$cf_subdir\${section} && 5392 test -n "\$aliases" && ( 5393 cd \$cf_subdir\${section} && ( 5394 cf_source=\`echo \$cf_target |sed -e 's%^.*/\([[^/]][[^/]]*/[[^/]][[^/]]*$\)%\1%'\` 5395 test -n "$cf_so_strip" && cf_source=\`echo \$cf_source |sed -e 's%\.$cf_so_strip\$%%'\` 5396 cf_target=\`basename \$cf_target\` 5397 for cf_alias in \$aliases 5398 do 5399 if test \$section = 1 ; then 5400 cf_alias=\`echo \$cf_alias|sed "\${transform}"\` 5401 fi 5402 5403 if test "$MANPAGE_SYMLINKS" = yes ; then 5404 if test -f \$cf_alias\${suffix} ; then 5405 if ( cmp -s \$cf_target \$cf_alias\${suffix} ) 5406 then 5407 continue 5408 fi 5409 fi 5410 echo .. \$verb alias \$cf_alias\${suffix} 5411CF_EOF 5412case "x$LN_S" in 5413(*-f) 5414cat >>$cf_edit_man <<CF_EOF 5415 $LN_S \$cf_target \$cf_alias\${suffix} 5416CF_EOF 5417 ;; 5418(*) 5419cat >>$cf_edit_man <<CF_EOF 5420 rm -f \$cf_alias\${suffix} 5421 $LN_S \$cf_target \$cf_alias\${suffix} 5422CF_EOF 5423 ;; 5424esac 5425cat >>$cf_edit_man <<CF_EOF 5426 elif test "\$cf_target" != "\$cf_alias\${suffix}" ; then 5427 echo ".so \$cf_source" >\$TMP 5428CF_EOF 5429if test -n "$cf_compress" ; then 5430cat >>$cf_edit_man <<CF_EOF 5431 if test -n "$cf_so_strip" ; then 5432 $cf_compress -f \$TMP 5433 mv \$TMP.$cf_so_strip \$TMP 5434 fi 5435CF_EOF 5436fi 5437cat >>$cf_edit_man <<CF_EOF 5438 echo .. \$verb alias \$cf_alias\${suffix} 5439 rm -f \$cf_alias\${suffix} 5440 \$INSTALL_DATA \$TMP \$cf_alias\${suffix} 5441 fi 5442 done 5443 ) 5444 ) 5445 elif test \$verb = removing ; then 5446 test -f \$cf_target && ( 5447 echo \$verb \$cf_target 5448 rm -f \$cf_target 5449 ) 5450 test -d \$cf_subdir\${section} && 5451 test -n "\$aliases" && ( 5452 cd \$cf_subdir\${section} && ( 5453 for cf_alias in \$aliases 5454 do 5455 if test \$section = 1 ; then 5456 cf_alias=\`echo \$cf_alias|sed "\${transform}"\` 5457 fi 5458 5459 echo .. \$verb alias \$cf_alias\${suffix} 5460 rm -f \$cf_alias\${suffix} 5461 done 5462 ) 5463 ) 5464 else 5465# echo ".hy 0" 5466 cat \$TMP 5467 fi 5468 ;; 5469esac 5470done 5471 5472if test $cf_inboth = yes ; then 5473if test \$form != format ; then 5474 $SHELL \[$]0 format \$verb \$mandir \$srcdir \[$]* 5475fi 5476fi 5477 5478exit 0 5479CF_EOF 5480chmod 755 $cf_edit_man 5481 5482])dnl 5483dnl --------------------------------------------------------------------------- 5484dnl CF_MATH_LIB version: 9 updated: 2017/01/21 11:06:25 5485dnl ----------- 5486dnl Checks for libraries. At least one UNIX system, Apple Macintosh 5487dnl Rhapsody 5.5, does not have -lm. We cannot use the simpler 5488dnl AC_CHECK_LIB(m,sin), because that fails for C++. 5489AC_DEFUN([CF_MATH_LIB], 5490[ 5491AC_CACHE_CHECK(if -lm needed for math functions, 5492 cf_cv_need_libm,[ 5493 AC_TRY_LINK([ 5494 #include <stdio.h> 5495 #include <stdlib.h> 5496 #include <math.h> 5497 ], 5498 [double x = rand(); printf("result = %g\n", ]ifelse([$2],,sin(x),$2)[)], 5499 [cf_cv_need_libm=no], 5500 [cf_cv_need_libm=yes])]) 5501if test "$cf_cv_need_libm" = yes 5502then 5503ifelse($1,,[ 5504 CF_ADD_LIB(m) 5505],[$1=-lm]) 5506fi 5507]) 5508dnl --------------------------------------------------------------------------- 5509dnl CF_MIXEDCASE_FILENAMES version: 7 updated: 2015/04/12 15:39:00 5510dnl ---------------------- 5511dnl Check if the file-system supports mixed-case filenames. If we're able to 5512dnl create a lowercase name and see it as uppercase, it doesn't support that. 5513AC_DEFUN([CF_MIXEDCASE_FILENAMES], 5514[ 5515AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[ 5516if test "$cross_compiling" = yes ; then 5517 case $target_alias in 5518 (*-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-msys*|*-mingw*|*-uwin*) 5519 cf_cv_mixedcase=no 5520 ;; 5521 (*) 5522 cf_cv_mixedcase=yes 5523 ;; 5524 esac 5525else 5526 rm -f conftest CONFTEST 5527 echo test >conftest 5528 if test -f CONFTEST ; then 5529 cf_cv_mixedcase=no 5530 else 5531 cf_cv_mixedcase=yes 5532 fi 5533 rm -f conftest CONFTEST 5534fi 5535]) 5536test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES,1,[Define to 1 if filesystem supports mixed-case filenames.]) 5537])dnl 5538dnl --------------------------------------------------------------------------- 5539dnl CF_MKSTEMP version: 10 updated: 2017/01/21 11:12:16 5540dnl ---------- 5541dnl Check for a working mkstemp. This creates two files, checks that they are 5542dnl successfully created and distinct (AmigaOS apparently fails on the last). 5543AC_DEFUN([CF_MKSTEMP],[ 5544AC_CHECK_HEADERS( \ 5545unistd.h \ 5546) 5547AC_CACHE_CHECK(for working mkstemp, cf_cv_func_mkstemp,[ 5548rm -rf conftest* 5549AC_TRY_RUN([ 5550#include <sys/types.h> 5551#ifdef HAVE_UNISTD_H 5552#include <unistd.h> 5553#endif 5554#include <stdlib.h> 5555#include <stdio.h> 5556#include <string.h> 5557#include <sys/stat.h> 5558int main(void) 5559{ 5560 char *tmpl = "conftestXXXXXX"; 5561 char name[2][80]; 5562 int n; 5563 int result = 0; 5564 int fd; 5565 struct stat sb; 5566 5567 umask(077); 5568 for (n = 0; n < 2; ++n) { 5569 strcpy(name[n], tmpl); 5570 if ((fd = mkstemp(name[n])) >= 0) { 5571 if (!strcmp(name[n], tmpl) 5572 || stat(name[n], &sb) != 0 5573 || (sb.st_mode & S_IFMT) != S_IFREG 5574 || (sb.st_mode & 077) != 0) { 5575 result = 1; 5576 } 5577 close(fd); 5578 } 5579 } 5580 if (result == 0 5581 && !strcmp(name[0], name[1])) 5582 result = 1; 5583 ${cf_cv_main_return:-return}(result); 5584} 5585],[cf_cv_func_mkstemp=yes 5586],[cf_cv_func_mkstemp=no 5587],[cf_cv_func_mkstemp=maybe]) 5588]) 5589if test "x$cf_cv_func_mkstemp" = xmaybe ; then 5590 AC_CHECK_FUNC(mkstemp) 5591fi 5592if test "x$cf_cv_func_mkstemp" = xyes || test "x$ac_cv_func_mkstemp" = xyes ; then 5593 AC_DEFINE(HAVE_MKSTEMP,1,[Define to 1 if mkstemp() is available and working.]) 5594fi 5595])dnl 5596dnl --------------------------------------------------------------------------- 5597dnl CF_MSG_LOG version: 5 updated: 2010/10/23 15:52:32 5598dnl ---------- 5599dnl Write a debug message to config.log, along with the line number in the 5600dnl configure script. 5601AC_DEFUN([CF_MSG_LOG],[ 5602echo "${as_me:-configure}:__oline__: testing $* ..." 1>&AC_FD_CC 5603])dnl 5604dnl --------------------------------------------------------------------------- 5605dnl CF_NCURSES_ABI_6 version: 3 updated: 2015/06/06 16:10:11 5606dnl ---------------- 5607dnl Set ncurses' ABI to 6 unless overridden by explicit configure option, and 5608dnl warn about this. 5609AC_DEFUN([CF_NCURSES_ABI_6],[ 5610if test "${with_abi_version+set}" != set; then 5611 case $cf_cv_rel_version in 5612 (5.*) 5613 cf_cv_rel_version=6.0 5614 cf_cv_abi_version=6 5615 AC_MSG_WARN(overriding ABI version to $cf_cv_abi_version) 5616 ;; 5617 esac 5618fi 5619])dnl 5620dnl --------------------------------------------------------------------------- 5621dnl CF_NCURSES_WITH_ABI_VERSION version: 2 updated: 2015/12/19 17:51:52 5622dnl --------------------------- 5623dnl Allow ncurses's ABI to be overridden. Generally this happens when a 5624dnl packager has incremented the ABI past that used in the original package, 5625dnl and wishes to keep doing this. 5626dnl 5627dnl $1 is the package name, if any, to derive a corresponding {package}_ABI 5628dnl symbol. 5629AC_DEFUN([CF_NCURSES_WITH_ABI_VERSION],[ 5630CF_WITH_ABI_VERSION($1) 5631if test "x$cf_cv_abi_version" != "x$with_abi_version" 5632then 5633 case $cf_cv_rel_version in 5634 (5.*) 5635 cf_cv_rel_version=$with_abi_version.0 5636 ;; 5637 esac 5638fi 5639])dnl 5640dnl --------------------------------------------------------------------------- 5641dnl CF_NO_LEAKS_OPTION version: 6 updated: 2015/04/12 15:39:00 5642dnl ------------------ 5643dnl see CF_WITH_NO_LEAKS 5644AC_DEFUN([CF_NO_LEAKS_OPTION],[ 5645AC_MSG_CHECKING(if you want to use $1 for testing) 5646AC_ARG_WITH($1, 5647 [$2], 5648 [AC_DEFINE_UNQUOTED($3,1,"Define to 1 if you want to use $1 for testing.")ifelse([$4],,[ 5649 $4 5650]) 5651 : ${with_cflags:=-g} 5652 : ${with_no_leaks:=yes} 5653 with_$1=yes], 5654 [with_$1=]) 5655AC_MSG_RESULT(${with_$1:-no}) 5656 5657case .$with_cflags in 5658(.*-g*) 5659 case .$CFLAGS in 5660 (.*-g*) 5661 ;; 5662 (*) 5663 CF_ADD_CFLAGS([-g]) 5664 ;; 5665 esac 5666 ;; 5667esac 5668])dnl 5669dnl --------------------------------------------------------------------------- 5670dnl CF_NUMBER_SYNTAX version: 2 updated: 2015/04/17 21:13:04 5671dnl ---------------- 5672dnl Check if the given variable is a number. If not, report an error. 5673dnl $1 is the variable 5674dnl $2 is the message 5675AC_DEFUN([CF_NUMBER_SYNTAX],[ 5676if test -n "$1" ; then 5677 case $1 in 5678 ([[0-9]]*) 5679 ;; 5680 (*) 5681 AC_MSG_ERROR($2 is not a number: $1) 5682 ;; 5683 esac 5684else 5685 AC_MSG_ERROR($2 value is empty) 5686fi 5687])dnl 5688dnl --------------------------------------------------------------------------- 5689dnl CF_OBJ_SUBDIR version: 7 updated: 2015/04/17 21:13:04 5690dnl ------------- 5691dnl Compute the object-directory name from the given model name 5692AC_DEFUN([CF_OBJ_SUBDIR], 5693[ 5694 case $1 in 5695 (libtool) $2='obj_lo' ;; 5696 (normal) $2='objects' ;; 5697 (debug) $2='obj_g' ;; 5698 (profile) $2='obj_p' ;; 5699 (shared) 5700 case $cf_cv_system_name in 5701 (cygwin|msys) 5702 $2='objects' ;; 5703 (*) 5704 $2='obj_s' ;; 5705 esac 5706 esac 5707])dnl 5708dnl --------------------------------------------------------------------------- 5709dnl CF_PATHSEP version: 7 updated: 2015/04/12 15:39:00 5710dnl ---------- 5711dnl Provide a value for the $PATH and similar separator (or amend the value 5712dnl as provided in autoconf 2.5x). 5713AC_DEFUN([CF_PATHSEP], 5714[ 5715 AC_MSG_CHECKING(for PATH separator) 5716 case $cf_cv_system_name in 5717 (os2*) PATH_SEPARATOR=';' ;; 5718 (*) ${PATH_SEPARATOR:=':'} ;; 5719 esac 5720ifelse([$1],,,[$1=$PATH_SEPARATOR]) 5721 AC_SUBST(PATH_SEPARATOR) 5722 AC_MSG_RESULT($PATH_SEPARATOR) 5723])dnl 5724dnl --------------------------------------------------------------------------- 5725dnl CF_PATH_PROG version: 10 updated: 2019/06/30 19:44:43 5726dnl ------------ 5727dnl Check for a given program, defining corresponding symbol. 5728dnl $1 = environment variable, which is suffixed by "_PATH" in the #define. 5729dnl $2 = program name to find. 5730dnl $3 = optional list of additional program names to test. 5731dnl $4 = $PATH 5732dnl 5733dnl If there is more than one token in the result, #define the remaining tokens 5734dnl to $1_ARGS. We need this for 'install' in particular. 5735dnl 5736dnl FIXME: we should allow this to be overridden by environment variables 5737dnl 5738AC_DEFUN([CF_PATH_PROG],[ 5739AC_REQUIRE([CF_PATHSEP]) 5740test -z "[$]$1" && $1=$2 5741AC_PATH_PROGS($1,[$]$1 $2 ifelse($3,,,$3),[$]$1, ifelse($4,,,$4)) 5742 5743cf_path_prog="" 5744cf_path_args="" 5745IFS="${IFS:- }"; cf_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR" 5746for cf_temp in $ac_cv_path_$1 5747do 5748 if test -z "$cf_path_prog" ; then 5749 if test "$with_full_paths" = yes ; then 5750 CF_PATH_SYNTAX(cf_temp,break) 5751 cf_path_prog="$cf_temp" 5752 else 5753 cf_path_prog="`basename $cf_temp`" 5754 fi 5755 elif test -z "$cf_path_args" ; then 5756 cf_path_args="$cf_temp" 5757 else 5758 cf_path_args="$cf_path_args $cf_temp" 5759 fi 5760done 5761IFS="$cf_save_ifs" 5762 5763if test -n "$cf_path_prog" ; then 5764 CF_MSG_LOG(defining path for ${cf_path_prog}) 5765 AC_DEFINE_UNQUOTED($1_PATH,"$cf_path_prog",Define to pathname $1) 5766 test -n "$cf_path_args" && AC_DEFINE_UNQUOTED($1_ARGS,"$cf_path_args",Define to provide args for $1) 5767fi 5768])dnl 5769dnl --------------------------------------------------------------------------- 5770dnl CF_PATH_SYNTAX version: 16 updated: 2015/04/18 08:56:57 5771dnl -------------- 5772dnl Check the argument to see that it looks like a pathname. Rewrite it if it 5773dnl begins with one of the prefix/exec_prefix variables, and then again if the 5774dnl result begins with 'NONE'. This is necessary to work around autoconf's 5775dnl delayed evaluation of those symbols. 5776AC_DEFUN([CF_PATH_SYNTAX],[ 5777if test "x$prefix" != xNONE; then 5778 cf_path_syntax="$prefix" 5779else 5780 cf_path_syntax="$ac_default_prefix" 5781fi 5782 5783case ".[$]$1" in 5784(.\[$]\(*\)*|.\'*\'*) 5785 ;; 5786(..|./*|.\\*) 5787 ;; 5788(.[[a-zA-Z]]:[[\\/]]*) # OS/2 EMX 5789 ;; 5790(.\[$]{*prefix}*|.\[$]{*dir}*) 5791 eval $1="[$]$1" 5792 case ".[$]$1" in 5793 (.NONE/*) 5794 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` 5795 ;; 5796 esac 5797 ;; 5798(.no|.NONE/*) 5799 $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` 5800 ;; 5801(*) 5802 ifelse([$2],,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2) 5803 ;; 5804esac 5805])dnl 5806dnl --------------------------------------------------------------------------- 5807dnl CF_PKG_CONFIG version: 10 updated: 2015/04/26 18:06:58 5808dnl ------------- 5809dnl Check for the package-config program, unless disabled by command-line. 5810AC_DEFUN([CF_PKG_CONFIG], 5811[ 5812AC_MSG_CHECKING(if you want to use pkg-config) 5813AC_ARG_WITH(pkg-config, 5814 [ --with-pkg-config{=path} enable/disable use of pkg-config], 5815 [cf_pkg_config=$withval], 5816 [cf_pkg_config=yes]) 5817AC_MSG_RESULT($cf_pkg_config) 5818 5819case $cf_pkg_config in 5820(no) 5821 PKG_CONFIG=none 5822 ;; 5823(yes) 5824 CF_ACVERSION_CHECK(2.52, 5825 [AC_PATH_TOOL(PKG_CONFIG, pkg-config, none)], 5826 [AC_PATH_PROG(PKG_CONFIG, pkg-config, none)]) 5827 ;; 5828(*) 5829 PKG_CONFIG=$withval 5830 ;; 5831esac 5832 5833test -z "$PKG_CONFIG" && PKG_CONFIG=none 5834if test "$PKG_CONFIG" != none ; then 5835 CF_PATH_SYNTAX(PKG_CONFIG) 5836elif test "x$cf_pkg_config" != xno ; then 5837 AC_MSG_WARN(pkg-config is not installed) 5838fi 5839 5840AC_SUBST(PKG_CONFIG) 5841])dnl 5842dnl --------------------------------------------------------------------------- 5843dnl CF_POSIX_C_SOURCE version: 11 updated: 2018/12/31 20:46:17 5844dnl ----------------- 5845dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed. 5846dnl 5847dnl POSIX.1-1990 _POSIX_SOURCE 5848dnl POSIX.1-1990 and _POSIX_SOURCE and 5849dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2 5850dnl Bindings Option 5851dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L 5852dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L 5853dnl X/Open 2000 _POSIX_C_SOURCE=200112L 5854dnl 5855dnl Parameters: 5856dnl $1 is the nominal value for _POSIX_C_SOURCE 5857AC_DEFUN([CF_POSIX_C_SOURCE], 5858[AC_REQUIRE([CF_POSIX_VISIBLE])dnl 5859 5860if test "$cf_cv_posix_visible" = no; then 5861 5862cf_POSIX_C_SOURCE=ifelse([$1],,199506L,[$1]) 5863 5864cf_save_CFLAGS="$CFLAGS" 5865cf_save_CPPFLAGS="$CPPFLAGS" 5866 5867CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE) 5868CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE) 5869 5870AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[ 5871 CF_MSG_LOG(if the symbol is already defined go no further) 5872 AC_TRY_COMPILE([#include <sys/types.h>],[ 5873#ifndef _POSIX_C_SOURCE 5874make an error 5875#endif], 5876 [cf_cv_posix_c_source=no], 5877 [cf_want_posix_source=no 5878 case .$cf_POSIX_C_SOURCE in 5879 (.[[12]]??*) 5880 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" 5881 ;; 5882 (.2) 5883 cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" 5884 cf_want_posix_source=yes 5885 ;; 5886 (.*) 5887 cf_want_posix_source=yes 5888 ;; 5889 esac 5890 if test "$cf_want_posix_source" = yes ; then 5891 AC_TRY_COMPILE([#include <sys/types.h>],[ 5892#ifdef _POSIX_SOURCE 5893make an error 5894#endif],[], 5895 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE") 5896 fi 5897 CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE) 5898 CFLAGS="$cf_trim_CFLAGS" 5899 CPPFLAGS="$cf_trim_CPPFLAGS" 5900 CF_APPEND_TEXT(CPPFLAGS,$cf_cv_posix_c_source) 5901 CF_MSG_LOG(if the second compile does not leave our definition intact error) 5902 AC_TRY_COMPILE([#include <sys/types.h>],[ 5903#ifndef _POSIX_C_SOURCE 5904make an error 5905#endif],, 5906 [cf_cv_posix_c_source=no]) 5907 CFLAGS="$cf_save_CFLAGS" 5908 CPPFLAGS="$cf_save_CPPFLAGS" 5909 ]) 5910]) 5911 5912if test "$cf_cv_posix_c_source" != no ; then 5913 CFLAGS="$cf_trim_CFLAGS" 5914 CPPFLAGS="$cf_trim_CPPFLAGS" 5915 CF_ADD_CFLAGS($cf_cv_posix_c_source) 5916fi 5917 5918fi # cf_cv_posix_visible 5919 5920])dnl 5921dnl --------------------------------------------------------------------------- 5922dnl CF_POSIX_VISIBLE version: 1 updated: 2018/12/31 20:46:17 5923dnl ---------------- 5924dnl POSIX documents test-macros which an application may set before any system 5925dnl headers are included to make features available. 5926dnl 5927dnl Some BSD platforms (originally FreeBSD, but copied by a few others) 5928dnl diverged from POSIX in 2002 by setting symbols which make all of the most 5929dnl recent features visible in the system header files unless the application 5930dnl overrides the corresponding test-macros. Doing that introduces portability 5931dnl problems. 5932dnl 5933dnl This macro makes a special check for the symbols used for this, to avoid a 5934dnl conflicting definition. 5935AC_DEFUN([CF_POSIX_VISIBLE], 5936[ 5937AC_CACHE_CHECK(if the POSIX test-macros are already defined,cf_cv_posix_visible,[ 5938AC_TRY_COMPILE([#include <stdio.h>],[ 5939#if defined(__POSIX_VISIBLE) && ((__POSIX_VISIBLE - 0L) > 0) \ 5940 && defined(__XSI_VISIBLE) && ((__XSI_VISIBLE - 0L) > 0) \ 5941 && defined(__BSD_VISIBLE) && ((__BSD_VISIBLE - 0L) > 0) \ 5942 && defined(__ISO_C_VISIBLE) && ((__ISO_C_VISIBLE - 0L) > 0) 5943#error conflicting symbols found 5944#endif 5945],[cf_cv_posix_visible=no],[cf_cv_posix_visible=yes]) 5946]) 5947])dnl 5948dnl --------------------------------------------------------------------------- 5949dnl CF_PREDEFINE version: 2 updated: 2010/05/26 16:44:57 5950dnl ------------ 5951dnl Add definitions to CPPFLAGS to ensure they're predefined for all compiles. 5952dnl 5953dnl $1 = symbol to test 5954dnl $2 = value (if any) to use for a predefinition 5955AC_DEFUN([CF_PREDEFINE], 5956[ 5957AC_MSG_CHECKING(if we must define $1) 5958AC_TRY_COMPILE([#include <sys/types.h> 5959],[ 5960#ifndef $1 5961make an error 5962#endif],[cf_result=no],[cf_result=yes]) 5963AC_MSG_RESULT($cf_result) 5964 5965if test "$cf_result" = yes ; then 5966 CPPFLAGS="$CPPFLAGS ifelse([$2],,-D$1,[-D$1=$2])" 5967elif test "x$2" != "x" ; then 5968 AC_MSG_CHECKING(checking for compatible value versus $2) 5969 AC_TRY_COMPILE([#include <sys/types.h> 5970],[ 5971#if $1-$2 < 0 5972make an error 5973#endif],[cf_result=yes],[cf_result=no]) 5974 AC_MSG_RESULT($cf_result) 5975 if test "$cf_result" = no ; then 5976 # perhaps we can override it - try... 5977 CPPFLAGS="$CPPFLAGS -D$1=$2" 5978 fi 5979fi 5980])dnl 5981dnl --------------------------------------------------------------------------- 5982dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08 5983dnl ------------ 5984dnl Append definitions and rules for the given programs to the subdirectory 5985dnl Makefiles, and the recursion rule for the top-level Makefile. 5986dnl 5987dnl parameters 5988dnl $1 = script to run 5989dnl $2 = list of subdirectories 5990dnl 5991dnl variables 5992dnl $AWK 5993AC_DEFUN([CF_PRG_RULES], 5994[ 5995for cf_dir in $2 5996do 5997 if test ! -d $srcdir/$cf_dir; then 5998 continue 5999 elif test -f $srcdir/$cf_dir/programs; then 6000 $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile 6001 fi 6002done 6003 6004])dnl 6005dnl --------------------------------------------------------------------------- 6006dnl CF_PROG_AR version: 1 updated: 2009/01/01 20:15:22 6007dnl ---------- 6008dnl Check for archiver "ar". 6009AC_DEFUN([CF_PROG_AR],[ 6010AC_CHECK_TOOL(AR, ar, ar) 6011]) 6012dnl --------------------------------------------------------------------------- 6013dnl CF_PROG_AWK version: 1 updated: 2006/09/16 11:40:59 6014dnl ----------- 6015dnl Check for awk, ensure that the check found something. 6016AC_DEFUN([CF_PROG_AWK], 6017[ 6018AC_PROG_AWK 6019test -z "$AWK" && AC_MSG_ERROR(No awk program found) 6020])dnl 6021dnl --------------------------------------------------------------------------- 6022dnl CF_PROG_CC version: 5 updated: 2019/12/31 08:53:54 6023dnl ---------- 6024dnl standard check for CC, plus followup sanity checks 6025dnl $1 = optional parameter to pass to AC_PROG_CC to specify compiler name 6026AC_DEFUN([CF_PROG_CC],[ 6027CF_ACVERSION_CHECK(2.53, 6028 [AC_MSG_WARN(this will incorrectly handle gnatgcc choice) 6029 AC_REQUIRE([AC_PROG_CC])], 6030 []) 6031ifelse($1,,[AC_PROG_CC],[AC_PROG_CC($1)]) 6032CF_GCC_VERSION 6033CF_ACVERSION_CHECK(2.52, 6034 [AC_PROG_CC_STDC], 6035 [CF_ANSI_CC_REQD]) 6036CF_CC_ENV_FLAGS 6037])dnl 6038dnl --------------------------------------------------------------------------- 6039dnl CF_PROG_CC_C_O version: 5 updated: 2017/01/21 11:06:25 6040dnl -------------- 6041dnl Analogous to AC_PROG_CC_C_O, but more useful: tests only $CC, ensures that 6042dnl the output file can be renamed, and allows for a shell variable that can 6043dnl be used later. The parameter is either CC or CXX. The result is the 6044dnl cache variable: 6045dnl $cf_cv_prog_CC_c_o 6046dnl $cf_cv_prog_CXX_c_o 6047dnl 6048dnl $1 = compiler 6049dnl $2 = compiler options, if any 6050AC_DEFUN([CF_PROG_CC_C_O], 6051[AC_REQUIRE([AC_PROG_CC])dnl 6052AC_MSG_CHECKING([whether [$]$1 understands -c and -o together]) 6053AC_CACHE_VAL(cf_cv_prog_$1_c_o, 6054[ 6055cat > conftest.$ac_ext <<CF_EOF 6056int main(void) 6057{ 6058 ${cf_cv_main_return:-return}(0); 6059} 6060CF_EOF 6061# We do the test twice because some compilers refuse to overwrite an 6062# existing .o file with -o, though they will create one. 6063ac_try='[$]$1 $2 -c conftest.$ac_ext -o conftest2.$ac_objext >&AC_FD_CC' 6064if AC_TRY_EVAL(ac_try) && 6065 test -f conftest2.$ac_objext && AC_TRY_EVAL(ac_try); 6066then 6067 eval cf_cv_prog_$1_c_o=yes 6068else 6069 eval cf_cv_prog_$1_c_o=no 6070fi 6071rm -rf conftest* 6072])dnl 6073if test $cf_cv_prog_$1_c_o = yes; then 6074 AC_MSG_RESULT([yes]) 6075else 6076 AC_MSG_RESULT([no]) 6077fi 6078])dnl 6079dnl --------------------------------------------------------------------------- 6080dnl CF_PROG_EGREP version: 2 updated: 2015/04/18 08:56:57 6081dnl ------------- 6082dnl AC_PROG_EGREP was introduced in autoconf 2.53. 6083dnl This macro adds a check to ensure the script found something. 6084AC_DEFUN([CF_PROG_EGREP], 6085[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep], 6086 [if echo a | (grep -E '(a|b)') >/dev/null 2>&1 6087 then ac_cv_prog_egrep='grep -E' 6088 else ac_cv_prog_egrep='egrep' 6089 fi]) 6090 EGREP=$ac_cv_prog_egrep 6091 AC_SUBST([EGREP]) 6092 test -z "$EGREP" && AC_MSG_ERROR(No egrep program found) 6093])dnl 6094dnl --------------------------------------------------------------------------- 6095dnl CF_PROG_GNAT version: 10 updated: 2019/12/31 08:53:54 6096dnl ------------ 6097dnl Check for gnat/gnatmake/etc, ensure that the toolset is complete. 6098AC_DEFUN([CF_PROG_GNAT],[ 6099for cf_prog_gnat in gnat gnatmake gprconfig gprbuild 6100do 6101 CF_UPPER(cf_upper_prog_gnat,${cf_prog_gnat}) 6102 6103 unset ac_cv_path_cf_TEMP_gnat 6104 unset cf_TEMP_gnat 6105 AC_PATH_PROG(cf_TEMP_gnat,$cf_prog_gnat,no) 6106 eval cf_cv_PATH_$cf_upper_prog_gnat=[$]ac_cv_path_cf_TEMP_gnat 6107 6108 if test "x$cf_TEMP_gnat" != xno; then 6109 unset cf_cv_gnat_version 6110 unset cf_TEMP_gnat 6111 CF_GNAT_VERSION(cf_TEMP_gnat,$cf_prog_gnat) 6112 fi 6113 eval cf_cv_VERSION_$cf_upper_prog_gnat=[$]cf_TEMP_gnat 6114 6115 unset cf_TEMP_gnat 6116 unset cf_cv_gnat_version 6117 unset ac_cv_path_cf_TEMP_gnat 6118done 6119 6120if test "x$cf_cv_VERSION_GNATMAKE" = "xno"; then 6121 cf_ada_make= 6122 cf_cv_prog_gnat_correct=no 6123else 6124 cf_ada_make=gnatmake 6125 if test "x$cf_cv_VERSION_GPRCONFIG" = "xno"; then 6126 # gprconfig is newer than gnatmake; we can continue... 6127 cf_ada_config="##" 6128 else 6129 rm -rf conftest* *~conftest* 6130 if mkdir conftest.src 6131 then 6132 cf_ada_config="" 6133 cd conftest.src 6134 for cf_gprconfig in Ada C 6135 do 6136 AC_MSG_CHECKING(for gprconfig name for $cf_gprconfig) 6137 if test $cf_gprconfig = C 6138 then 6139 for cf_gprconfig_param in \ 6140 $cf_gprconfig,,,,GNATGCC \ 6141 $cf_gprconfig,,,,GCC \ 6142 $cf_gprconfig 6143 do 6144 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1` 6145 test -n "$cf_gprconfig_value" && break 6146 done 6147 else 6148 cf_gprconfig_param=$cf_gprconfig 6149 cf_gprconfig_value=`echo s| gprconfig --config=$cf_gprconfig_param 2>&AC_FD_CC | ${AWK:-awk} '/^\*/{print [$]3;}' | head -n 1` 6150 fi 6151 if test -n "$cf_gprconfig_value" 6152 then 6153 eval cf_ada_config_[$]cf_gprconfig=[$]cf_gprconfig_value 6154 AC_MSG_RESULT($cf_gprconfig_value) 6155 else 6156 AC_MSG_RESULT(missing) 6157 cf_ada_config="#" 6158 break 6159 fi 6160 done 6161 cd .. 6162 rm -rf conftest* *~conftest* 6163 fi 6164 fi 6165 if test "x$cf_ada_config" != "x#" 6166 then 6167 CF_GNAT_VERSION 6168 CF_CHECK_GNAT_VERSION 6169 AC_CHECK_PROG(M4_exists, m4, yes, no) 6170 if test "$ac_cv_prog_M4_exists" = no; then 6171 cf_cv_prog_gnat_correct=no 6172 AC_MSG_WARN(Ada95 binding required program m4 not found. Ada95 binding disabled) 6173 fi 6174 if test "$cf_cv_prog_gnat_correct" = yes; then 6175 AC_MSG_CHECKING(if GNAT works) 6176 CF_GNAT_TRY_RUN([procedure conftest;], 6177[with Text_IO; 6178with GNAT.OS_Lib; 6179procedure conftest is 6180begin 6181 Text_IO.Put ("Hello World"); 6182 Text_IO.New_Line; 6183 GNAT.OS_Lib.OS_Exit (0); 6184end conftest;], 6185[cf_cv_prog_gnat_correct=yes], 6186[cf_cv_prog_gnat_correct=no]) 6187 AC_MSG_RESULT($cf_cv_prog_gnat_correct) 6188 fi 6189 else 6190 cf_cv_prog_gnat_correct=no 6191 fi 6192fi 6193 6194AC_SUBST(cf_ada_make) 6195AC_SUBST(cf_ada_config) 6196AC_SUBST(cf_ada_config_Ada) 6197AC_SUBST(cf_ada_config_C) 6198])dnl 6199dnl --------------------------------------------------------------------------- 6200dnl CF_PROG_INSTALL version: 7 updated: 2015/04/18 08:56:57 6201dnl --------------- 6202dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the 6203dnl misc/tabset install won't work properly. Usually this happens only when 6204dnl using the fallback mkinstalldirs script 6205AC_DEFUN([CF_PROG_INSTALL], 6206[AC_PROG_INSTALL 6207case $INSTALL in 6208(/*) 6209 ;; 6210(*) 6211 CF_DIRNAME(cf_dir,$INSTALL) 6212 test -z "$cf_dir" && cf_dir=. 6213 INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'` 6214 ;; 6215esac 6216])dnl 6217dnl --------------------------------------------------------------------------- 6218dnl CF_PROG_LDCONFIG version: 5 updated: 2015/04/18 08:56:57 6219dnl ---------------- 6220dnl Check for ldconfig, needed to fixup shared libraries that would be built 6221dnl and then used in the install. 6222AC_DEFUN([CF_PROG_LDCONFIG],[ 6223if test "$cross_compiling" = yes ; then 6224 LDCONFIG=: 6225else 6226 case "$cf_cv_system_name" in 6227 (dragonfly*|mirbsd*|freebsd*) 6228 test -z "$LDCONFIG" && LDCONFIG="/sbin/ldconfig -R" 6229 ;; 6230 (*) LDPATH=$PATH:/sbin:/usr/sbin 6231 AC_PATH_PROG(LDCONFIG,ldconfig,,$LDPATH) 6232 ;; 6233 esac 6234fi 6235AC_SUBST(LDCONFIG) 6236])dnl 6237dnl --------------------------------------------------------------------------- 6238dnl CF_PROG_LINT version: 4 updated: 2019/11/20 18:55:37 6239dnl ------------ 6240AC_DEFUN([CF_PROG_LINT], 6241[ 6242AC_CHECK_PROGS(LINT, lint cppcheck splint) 6243case "x$LINT" in 6244(xcppcheck|x*/cppcheck) 6245 test -z "$LINT_OPTS" && LINT_OPTS="--enable=all" 6246 ;; 6247esac 6248AC_SUBST(LINT_OPTS) 6249])dnl 6250dnl --------------------------------------------------------------------------- 6251dnl CF_PROG_LN_S version: 2 updated: 2010/08/14 18:25:37 6252dnl ------------ 6253dnl Combine checks for "ln -s" and "ln -sf", updating $LN_S to include "-f" 6254dnl option if it is supported. 6255AC_DEFUN([CF_PROG_LN_S],[ 6256AC_PROG_LN_S 6257AC_MSG_CHECKING(if $LN_S -f options work) 6258 6259rm -f conf$$.src conf$$dst 6260echo >conf$$.dst 6261echo first >conf$$.src 6262if $LN_S -f conf$$.src conf$$.dst 2>/dev/null; then 6263 cf_prog_ln_sf=yes 6264else 6265 cf_prog_ln_sf=no 6266fi 6267rm -f conf$$.dst conf$$src 6268AC_MSG_RESULT($cf_prog_ln_sf) 6269 6270test "$cf_prog_ln_sf" = yes && LN_S="$LN_S -f" 6271])dnl 6272dnl --------------------------------------------------------------------------- 6273dnl CF_REGEX version: 12 updated: 2015/04/18 08:56:57 6274dnl -------- 6275dnl Attempt to determine if we've got one of the flavors of regular-expression 6276dnl code that we can support. 6277AC_DEFUN([CF_REGEX], 6278[ 6279 6280cf_regex_func=no 6281 6282cf_regex_libs="regex re" 6283case $host_os in 6284(mingw*) 6285 cf_regex_libs="gnurx $cf_regex_libs" 6286 ;; 6287esac 6288 6289AC_CHECK_FUNC(regcomp,[cf_regex_func=regcomp],[ 6290 for cf_regex_lib in $cf_regex_libs 6291 do 6292 AC_CHECK_LIB($cf_regex_lib,regcomp,[ 6293 CF_ADD_LIB($cf_regex_lib) 6294 cf_regex_func=regcomp 6295 break]) 6296 done 6297]) 6298 6299if test "$cf_regex_func" = no ; then 6300 AC_CHECK_FUNC(compile,[cf_regex_func=compile],[ 6301 AC_CHECK_LIB(gen,compile,[ 6302 CF_ADD_LIB(gen) 6303 cf_regex_func=compile])]) 6304fi 6305 6306if test "$cf_regex_func" = no ; then 6307 AC_MSG_WARN(cannot find regular expression library) 6308fi 6309 6310AC_CACHE_CHECK(for regular-expression headers,cf_cv_regex_hdrs,[ 6311 6312cf_cv_regex_hdrs=no 6313case $cf_regex_func in 6314(compile) 6315 for cf_regex_hdr in regexp.h regexpr.h 6316 do 6317 AC_TRY_LINK([#include <$cf_regex_hdr>],[ 6318 char *p = compile("", "", "", 0); 6319 int x = step("", ""); 6320 ],[ 6321 cf_cv_regex_hdrs=$cf_regex_hdr 6322 break 6323 ]) 6324 done 6325 ;; 6326(*) 6327 for cf_regex_hdr in regex.h 6328 do 6329 AC_TRY_LINK([#include <sys/types.h> 6330#include <$cf_regex_hdr>],[ 6331 regex_t *p; 6332 int x = regcomp(p, "", 0); 6333 int y = regexec(p, "", 0, 0, 0); 6334 regfree(p); 6335 ],[ 6336 cf_cv_regex_hdrs=$cf_regex_hdr 6337 break 6338 ]) 6339 done 6340 ;; 6341esac 6342 6343]) 6344 6345case $cf_cv_regex_hdrs in 6346 (no) AC_MSG_WARN(no regular expression header found) ;; 6347 (regex.h) AC_DEFINE(HAVE_REGEX_H_FUNCS,1,[Define to 1 to include regex.h for regular expressions]) ;; 6348 (regexp.h) AC_DEFINE(HAVE_REGEXP_H_FUNCS,1,[Define to 1 to include regexp.h for regular expressions]) ;; 6349 (regexpr.h) AC_DEFINE(HAVE_REGEXPR_H_FUNCS,1,[Define to 1 to include regexpr.h for regular expressions]) ;; 6350esac 6351])dnl 6352dnl --------------------------------------------------------------------------- 6353dnl CF_REMOVE_DEFINE version: 3 updated: 2010/01/09 11:05:50 6354dnl ---------------- 6355dnl Remove all -U and -D options that refer to the given symbol from a list 6356dnl of C compiler options. This works around the problem that not all 6357dnl compilers process -U and -D options from left-to-right, so a -U option 6358dnl cannot be used to cancel the effect of a preceding -D option. 6359dnl 6360dnl $1 = target (which could be the same as the source variable) 6361dnl $2 = source (including '$') 6362dnl $3 = symbol to remove 6363define([CF_REMOVE_DEFINE], 6364[ 6365$1=`echo "$2" | \ 6366 sed -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[[ ]]/ /g' \ 6367 -e 's/-[[UD]]'"$3"'\(=[[^ ]]*\)\?[$]//g'` 6368])dnl 6369dnl --------------------------------------------------------------------------- 6370dnl CF_REMOVE_LIB version: 1 updated: 2007/02/17 14:11:52 6371dnl ------------- 6372dnl Remove the given library from the symbol 6373dnl 6374dnl $1 = target (which could be the same as the source variable) 6375dnl $2 = source (including '$') 6376dnl $3 = library to remove 6377define([CF_REMOVE_LIB], 6378[ 6379# remove $3 library from $2 6380$1=`echo "$2" | sed -e 's/-l$3[[ ]]//g' -e 's/-l$3[$]//'` 6381])dnl 6382dnl --------------------------------------------------------------------------- 6383dnl CF_RESTORE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:47:45 6384dnl --------------------- 6385dnl Restore flags saved in CF_SAVE_XTRA_FLAGS 6386dnl $1 = name of current macro 6387define([CF_RESTORE_XTRA_FLAGS], 6388[ 6389LIBS="$cf_save_LIBS_$1" 6390CFLAGS="$cf_save_CFLAGS_$1" 6391CPPFLAGS="$cf_save_CPPFLAGS_$1" 6392])dnl 6393dnl --------------------------------------------------------------------------- 6394dnl CF_RPATH_HACK version: 11 updated: 2013/09/01 13:02:00 6395dnl ------------- 6396AC_DEFUN([CF_RPATH_HACK], 6397[ 6398AC_REQUIRE([CF_LD_RPATH_OPT]) 6399AC_MSG_CHECKING(for updated LDFLAGS) 6400if test -n "$LD_RPATH_OPT" ; then 6401 AC_MSG_RESULT(maybe) 6402 6403 AC_CHECK_PROGS(cf_ldd_prog,ldd,no) 6404 cf_rpath_list="/usr/lib /lib" 6405 if test "$cf_ldd_prog" != no 6406 then 6407 cf_rpath_oops= 6408 6409AC_TRY_LINK([#include <stdio.h>], 6410 [printf("Hello");], 6411 [cf_rpath_oops=`$cf_ldd_prog conftest$ac_exeext | fgrep ' not found' | sed -e 's% =>.*$%%' |sort | uniq` 6412 cf_rpath_list=`$cf_ldd_prog conftest$ac_exeext | fgrep / | sed -e 's%^.*[[ ]]/%/%' -e 's%/[[^/]][[^/]]*$%%' |sort | uniq`]) 6413 6414 # If we passed the link-test, but get a "not found" on a given library, 6415 # this could be due to inept reconfiguration of gcc to make it only 6416 # partly honor /usr/local/lib (or whatever). Sometimes this behavior 6417 # is intentional, e.g., installing gcc in /usr/bin and suppressing the 6418 # /usr/local libraries. 6419 if test -n "$cf_rpath_oops" 6420 then 6421 for cf_rpath_src in $cf_rpath_oops 6422 do 6423 for cf_rpath_dir in \ 6424 /usr/local \ 6425 /usr/pkg \ 6426 /opt/sfw 6427 do 6428 if test -f $cf_rpath_dir/lib/$cf_rpath_src 6429 then 6430 CF_VERBOSE(...adding -L$cf_rpath_dir/lib to LDFLAGS for $cf_rpath_src) 6431 LDFLAGS="$LDFLAGS -L$cf_rpath_dir/lib" 6432 break 6433 fi 6434 done 6435 done 6436 fi 6437 fi 6438 6439 CF_VERBOSE(...checking EXTRA_LDFLAGS $EXTRA_LDFLAGS) 6440 6441 CF_RPATH_HACK_2(LDFLAGS) 6442 CF_RPATH_HACK_2(LIBS) 6443 6444 CF_VERBOSE(...checked EXTRA_LDFLAGS $EXTRA_LDFLAGS) 6445else 6446 AC_MSG_RESULT(no) 6447fi 6448AC_SUBST(EXTRA_LDFLAGS) 6449])dnl 6450dnl --------------------------------------------------------------------------- 6451dnl CF_RPATH_HACK_2 version: 7 updated: 2015/04/12 15:39:00 6452dnl --------------- 6453dnl Do one set of substitutions for CF_RPATH_HACK, adding an rpath option to 6454dnl EXTRA_LDFLAGS for each -L option found. 6455dnl 6456dnl $cf_rpath_list contains a list of directories to ignore. 6457dnl 6458dnl $1 = variable name to update. The LDFLAGS variable should be the only one, 6459dnl but LIBS often has misplaced -L options. 6460AC_DEFUN([CF_RPATH_HACK_2], 6461[ 6462CF_VERBOSE(...checking $1 [$]$1) 6463 6464cf_rpath_dst= 6465for cf_rpath_src in [$]$1 6466do 6467 case $cf_rpath_src in 6468 (-L*) 6469 6470 # check if this refers to a directory which we will ignore 6471 cf_rpath_skip=no 6472 if test -n "$cf_rpath_list" 6473 then 6474 for cf_rpath_item in $cf_rpath_list 6475 do 6476 if test "x$cf_rpath_src" = "x-L$cf_rpath_item" 6477 then 6478 cf_rpath_skip=yes 6479 break 6480 fi 6481 done 6482 fi 6483 6484 if test "$cf_rpath_skip" = no 6485 then 6486 # transform the option 6487 if test "$LD_RPATH_OPT" = "-R " ; then 6488 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%-R %"` 6489 else 6490 cf_rpath_tmp=`echo "$cf_rpath_src" |sed -e "s%-L%$LD_RPATH_OPT%"` 6491 fi 6492 6493 # if we have not already added this, add it now 6494 cf_rpath_tst=`echo "$EXTRA_LDFLAGS" | sed -e "s%$cf_rpath_tmp %%"` 6495 if test "x$cf_rpath_tst" = "x$EXTRA_LDFLAGS" 6496 then 6497 CF_VERBOSE(...Filter $cf_rpath_src ->$cf_rpath_tmp) 6498 EXTRA_LDFLAGS="$cf_rpath_tmp $EXTRA_LDFLAGS" 6499 fi 6500 fi 6501 ;; 6502 esac 6503 cf_rpath_dst="$cf_rpath_dst $cf_rpath_src" 6504done 6505$1=$cf_rpath_dst 6506 6507CF_VERBOSE(...checked $1 [$]$1) 6508AC_SUBST(EXTRA_LDFLAGS) 6509])dnl 6510dnl --------------------------------------------------------------------------- 6511dnl CF_SAVE_XTRA_FLAGS version: 1 updated: 2020/01/11 16:46:44 6512dnl ------------------ 6513dnl Use this macro to save CFLAGS/CPPFLAGS/LIBS before checks against X headers 6514dnl and libraries which do not update those variables. 6515dnl 6516dnl $1 = name of current macro 6517define([CF_SAVE_XTRA_FLAGS], 6518[ 6519cf_save_LIBS_$1="$LIBS" 6520cf_save_CFLAGS_$1="$CFLAGS" 6521cf_save_CPPFLAGS_$1="$CPPFLAGS" 6522LIBS="$LIBS ${X_PRE_LIBS} ${X_LIBS} ${X_EXTRA_LIBS}" 6523for cf_X_CFLAGS in $X_CFLAGS 6524do 6525 case "x$cf_X_CFLAGS" in 6526 x-[[IUD]]*) 6527 CPPFLAGS="$CPPFLAGS $cf_X_CFLAGS" 6528 ;; 6529 *) 6530 CFLAGS="$CFLAGS $cf_X_CFLAGS" 6531 ;; 6532 esac 6533done 6534])dnl 6535dnl --------------------------------------------------------------------------- 6536dnl CF_SHARED_OPTS version: 93 updated: 2018/08/18 16:36:35 6537dnl -------------- 6538dnl -------------- 6539dnl Attempt to determine the appropriate CC/LD options for creating a shared 6540dnl library. 6541dnl 6542dnl Notes: 6543dnl a) ${LOCAL_LDFLAGS} is used to link executables that will run within 6544dnl the build-tree, i.e., by making use of the libraries that are compiled in 6545dnl $rel_builddir/lib We avoid compiling-in a $rel_builddir/lib path for the 6546dnl shared library since that can lead to unexpected results at runtime. 6547dnl b) ${LOCAL_LDFLAGS2} has the same intention but assumes that the shared 6548dnl libraries are compiled in ../../lib 6549dnl 6550dnl The variable 'cf_cv_do_symlinks' is used to control whether we configure 6551dnl to install symbolic links to the rel/abi versions of shared libraries. 6552dnl 6553dnl The variable 'cf_cv_shlib_version' controls whether we use the rel or abi 6554dnl version when making symbolic links. 6555dnl 6556dnl The variable 'cf_cv_shlib_version_infix' controls whether shared library 6557dnl version numbers are infix (ex: libncurses.<ver>.dylib) or postfix 6558dnl (ex: libncurses.so.<ver>). 6559dnl 6560dnl Some loaders leave 'so_locations' lying around. It's nice to clean up. 6561AC_DEFUN([CF_SHARED_OPTS], 6562[ 6563 AC_REQUIRE([CF_LD_RPATH_OPT]) 6564 6565 RM_SHARED_OPTS= 6566 LOCAL_LDFLAGS= 6567 LOCAL_LDFLAGS2= 6568 LD_SHARED_OPTS= 6569 INSTALL_LIB="-m 644" 6570 : ${rel_builddir:=.} 6571 6572 shlibdir=$libdir 6573 AC_SUBST(shlibdir) 6574 6575 MAKE_DLLS="#" 6576 AC_SUBST(MAKE_DLLS) 6577 6578 cf_cv_do_symlinks=no 6579 cf_ld_rpath_opt= 6580 test "$cf_cv_enable_rpath" = yes && cf_ld_rpath_opt="$LD_RPATH_OPT" 6581 6582 AC_MSG_CHECKING(if release/abi version should be used for shared libs) 6583 AC_ARG_WITH(shlib-version, 6584 [ --with-shlib-version=X Specify rel or abi version for shared libs], 6585 [test -z "$withval" && withval=auto 6586 case $withval in 6587 (yes) 6588 cf_cv_shlib_version=auto 6589 ;; 6590 (rel|abi|auto) 6591 cf_cv_shlib_version=$withval 6592 ;; 6593 (*) 6594 AC_MSG_RESULT($withval) 6595 AC_MSG_ERROR([option value must be one of: rel, abi, or auto]) 6596 ;; 6597 esac 6598 ],[cf_cv_shlib_version=auto]) 6599 AC_MSG_RESULT($cf_cv_shlib_version) 6600 6601 cf_cv_rm_so_locs=no 6602 cf_try_cflags= 6603 6604 # Some less-capable ports of gcc support only -fpic 6605 CC_SHARED_OPTS= 6606 6607 cf_try_fPIC=no 6608 if test "$GCC" = yes 6609 then 6610 cf_try_fPIC=yes 6611 else 6612 case $cf_cv_system_name in 6613 (*linux*) # e.g., PGI compiler 6614 cf_try_fPIC=yes 6615 ;; 6616 esac 6617 fi 6618 6619 if test "$cf_try_fPIC" = yes 6620 then 6621 AC_MSG_CHECKING(which $CC option to use) 6622 cf_save_CFLAGS="$CFLAGS" 6623 for CC_SHARED_OPTS in -fPIC -fpic '' 6624 do 6625 CFLAGS="$cf_save_CFLAGS $CC_SHARED_OPTS" 6626 AC_TRY_COMPILE([#include <stdio.h>],[int x = 1],[break],[]) 6627 done 6628 AC_MSG_RESULT($CC_SHARED_OPTS) 6629 CFLAGS="$cf_save_CFLAGS" 6630 fi 6631 6632 cf_cv_shlib_version_infix=no 6633 6634 case $cf_cv_system_name in 6635 (aix4.[3-9]*|aix[[5-7]]*) 6636 if test "$GCC" = yes; then 6637 CC_SHARED_OPTS='-Wl,-brtl' 6638 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@' 6639 else 6640 CC_SHARED_OPTS='-brtl' 6641 # as well as '-qpic=large -G' or perhaps "-bM:SRE -bnoentry -bexpall" 6642 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -G -Wl,-brtl -Wl,-blibpath:${RPATH_LIST}:/usr/lib -o [$]@' 6643 fi 6644 ;; 6645 (beos*) 6646 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -o $[@] -Xlinker -soname=`basename $[@]` -nostart -e 0' 6647 ;; 6648 (cygwin*) 6649 CC_SHARED_OPTS= 6650 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 6651 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 6652 cf_cv_shlib_version=cygdll 6653 cf_cv_shlib_version_infix=cygdll 6654 shlibdir=$bindir 6655 MAKE_DLLS= 6656 cat >mk_shared_lib.sh <<-CF_EOF 6657 #!$SHELL 6658 SHARED_LIB=\[$]1 6659 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/cyg/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 6660 shift 6661 cat <<-EOF 6662 Linking shared library 6663 ** SHARED_LIB \[$]SHARED_LIB 6664 ** IMPORT_LIB \[$]IMPORT_LIB 6665EOF 6666 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 6667CF_EOF 6668 chmod +x mk_shared_lib.sh 6669 ;; 6670 (msys*) 6671 CC_SHARED_OPTS= 6672 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 6673 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 6674 cf_cv_shlib_version=msysdll 6675 cf_cv_shlib_version_infix=msysdll 6676 shlibdir=$bindir 6677 MAKE_DLLS= 6678 cat >mk_shared_lib.sh <<-CF_EOF 6679 #!$SHELL 6680 SHARED_LIB=\[$]1 6681 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/msys-/lib/' -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 6682 shift 6683 cat <<-EOF 6684 Linking shared library 6685 ** SHARED_LIB \[$]SHARED_LIB 6686 ** IMPORT_LIB \[$]IMPORT_LIB 6687EOF 6688 exec \[$]* ${LDFLAGS} -shared -Wl,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 6689CF_EOF 6690 chmod +x mk_shared_lib.sh 6691 ;; 6692 (darwin*) 6693 cf_try_cflags="no-cpp-precomp" 6694 CC_SHARED_OPTS="-dynamic" 6695 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dynamiclib -install_name ${libdir}/`basename $[@]` -compatibility_version ${ABI_VERSION} -current_version ${ABI_VERSION} -o $[@]' 6696 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=abi 6697 cf_cv_shlib_version_infix=yes 6698 AC_CACHE_CHECK([if ld -search_paths_first works], cf_cv_ldflags_search_paths_first, [ 6699 cf_save_LDFLAGS=$LDFLAGS 6700 LDFLAGS="$LDFLAGS -Wl,-search_paths_first" 6701 AC_TRY_LINK(, [int i;], cf_cv_ldflags_search_paths_first=yes, cf_cv_ldflags_search_paths_first=no) 6702 LDFLAGS=$cf_save_LDFLAGS]) 6703 if test $cf_cv_ldflags_search_paths_first = yes; then 6704 LDFLAGS="$LDFLAGS -Wl,-search_paths_first" 6705 fi 6706 ;; 6707 (hpux[[7-8]]*) 6708 # HP-UX 8.07 ld lacks "+b" option used for libdir search-list 6709 if test "$GCC" != yes; then 6710 CC_SHARED_OPTS='+Z' 6711 fi 6712 MK_SHARED_LIB='${LD} ${LDFLAGS} -b -o $[@]' 6713 INSTALL_LIB="-m 555" 6714 ;; 6715 (hpux*) 6716 # (tested with gcc 2.7.2 -- I don't have c89) 6717 if test "$GCC" = yes; then 6718 LD_SHARED_OPTS='-Xlinker +b -Xlinker ${libdir}' 6719 else 6720 CC_SHARED_OPTS='+Z' 6721 LD_SHARED_OPTS='-Wl,+b,${libdir}' 6722 fi 6723 MK_SHARED_LIB='${LD} ${LDFLAGS} +b ${libdir} -b -o $[@]' 6724 # HP-UX shared libraries must be executable, and should be 6725 # readonly to exploit a quirk in the memory manager. 6726 INSTALL_LIB="-m 555" 6727 ;; 6728 (interix*) 6729 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 6730 if test "$cf_cv_shlib_version" = rel; then 6731 cf_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}' 6732 else 6733 cf_shared_soname='`basename $[@]`' 6734 fi 6735 CC_SHARED_OPTS= 6736 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-rpath,${RPATH_LIST} -Wl,-h,'$cf_shared_soname' -o $[@]' 6737 ;; 6738 (irix*) 6739 if test "$cf_cv_enable_rpath" = yes ; then 6740 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 6741 fi 6742 # tested with IRIX 5.2 and 'cc'. 6743 if test "$GCC" != yes; then 6744 CC_SHARED_OPTS='-KPIC' 6745 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -rdata_shared -soname `basename $[@]` -o $[@]' 6746 else 6747 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,`basename $[@]` -o $[@]' 6748 fi 6749 cf_cv_rm_so_locs=yes 6750 ;; 6751 (linux*|gnu*|k*bsd*-gnu) 6752 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 6753 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 6754 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6755 fi 6756 if test "$cf_cv_enable_rpath" = yes ; then 6757 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 6758 fi 6759 CF_SHARED_SONAME 6760 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 6761 ;; 6762 (mingw*) 6763 cf_cv_shlib_version=mingw 6764 cf_cv_shlib_version_infix=mingw 6765 shlibdir=$bindir 6766 MAKE_DLLS= 6767 if test "$DFT_LWR_MODEL" = "shared" ; then 6768 LOCAL_LDFLAGS="-Wl,--enable-auto-import" 6769 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6770 EXTRA_LDFLAGS="-Wl,--enable-auto-import $EXTRA_LDFLAGS" 6771 fi 6772 CC_SHARED_OPTS= 6773 MK_SHARED_LIB=$SHELL' '$rel_builddir'/mk_shared_lib.sh [$]@ [$]{CC} [$]{CFLAGS}' 6774 RM_SHARED_OPTS="$RM_SHARED_OPTS $rel_builddir/mk_shared_lib.sh *.dll.a" 6775 cat >mk_shared_lib.sh <<-CF_EOF 6776 #!$SHELL 6777 SHARED_LIB=\[$]1 6778 IMPORT_LIB=\`echo "\[$]1" | sed -e 's/[[0-9]]*\.dll[$]/.dll.a/'\` 6779 shift 6780 cat <<-EOF 6781 Linking shared library 6782 ** SHARED_LIB \[$]SHARED_LIB 6783 ** IMPORT_LIB \[$]IMPORT_LIB 6784EOF 6785 exec \[$]* ${LDFLAGS} -shared -Wl,--enable-auto-import,--out-implib=\[$]{IMPORT_LIB} -Wl,--export-all-symbols -o \[$]{SHARED_LIB} 6786CF_EOF 6787 chmod +x mk_shared_lib.sh 6788 ;; 6789 (openbsd[[2-9]].*|mirbsd*) 6790 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 6791 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 6792 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6793 fi 6794 if test "$cf_cv_enable_rpath" = yes ; then 6795 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 6796 fi 6797 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 6798 CF_SHARED_SONAME 6799 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-Bshareable,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 6800 ;; 6801 (nto-qnx*|openbsd*|freebsd[[12]].*) 6802 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 6803 MK_SHARED_LIB='${LD} ${LDFLAGS} -Bshareable -o $[@]' 6804 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 6805 ;; 6806 (dragonfly*|freebsd*) 6807 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 6808 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then 6809 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)" 6810 LOCAL_LDFLAGS2="${cf_ld_rpath_opt}\${RPATH_LIST} $LOCAL_LDFLAGS" 6811 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 6812 fi 6813 CF_SHARED_SONAME 6814 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname',-stats,-lc -o $[@]' 6815 ;; 6816 (netbsd*) 6817 CC_SHARED_OPTS="$CC_SHARED_OPTS -DPIC" 6818 if test "$DFT_LWR_MODEL" = "shared" && test "$cf_cv_enable_rpath" = yes ; then 6819 LOCAL_LDFLAGS="${cf_ld_rpath_opt}\$(LOCAL_LIBDIR)" 6820 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6821 EXTRA_LDFLAGS="${cf_ld_rpath_opt}\${RPATH_LIST} $EXTRA_LDFLAGS" 6822 if test "$cf_cv_shlib_version" = auto; then 6823 if test -f /usr/libexec/ld.elf_so; then 6824 cf_cv_shlib_version=abi 6825 else 6826 cf_cv_shlib_version=rel 6827 fi 6828 fi 6829 CF_SHARED_SONAME 6830 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -Wl,-soname,'$cf_cv_shared_soname' -o $[@]' 6831 else 6832 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -Wl,-shared -Wl,-Bshareable -o $[@]' 6833 fi 6834 ;; 6835 (osf*|mls+*) 6836 # tested with OSF/1 V3.2 and 'cc' 6837 # tested with OSF/1 V3.2 and gcc 2.6.3 (but the c++ demo didn't 6838 # link with shared libs). 6839 MK_SHARED_LIB='${LD} ${LDFLAGS} -set_version ${REL_VERSION}:${ABI_VERSION} -expect_unresolved "*" -shared -soname `basename $[@]`' 6840 case $host_os in 6841 (osf4*) 6842 MK_SHARED_LIB="${MK_SHARED_LIB} -msym" 6843 ;; 6844 esac 6845 MK_SHARED_LIB="${MK_SHARED_LIB}"' -o $[@]' 6846 if test "$DFT_LWR_MODEL" = "shared" && test -n "$LD_RPATH_OPT" ; then 6847 LOCAL_LDFLAGS="${LD_RPATH_OPT}\$(LOCAL_LIBDIR)" 6848 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6849 fi 6850 cf_cv_rm_so_locs=yes 6851 ;; 6852 (sco3.2v5*) # also uw2* and UW7: hops 13-Apr-98 6853 # tested with osr5.0.5 6854 if test "$GCC" != yes; then 6855 CC_SHARED_OPTS='-belf -KPIC' 6856 fi 6857 MK_SHARED_LIB='${LD} ${LDFLAGS} -dy -G -h `basename $[@] .${REL_VERSION}`.${ABI_VERSION} -o [$]@' 6858 if test "$cf_cv_enable_rpath" = yes ; then 6859 # only way is to set LD_RUN_PATH but no switch for it 6860 RUN_PATH=$libdir 6861 fi 6862 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 6863 LINK_PROGS='LD_RUN_PATH=${libdir}' 6864 LINK_TESTS='Pwd=`pwd`;LD_RUN_PATH=`dirname $${Pwd}`/lib' 6865 ;; 6866 (sunos4*) 6867 # tested with SunOS 4.1.1 and gcc 2.7.0 6868 if test "$GCC" != yes; then 6869 CC_SHARED_OPTS='-KPIC' 6870 fi 6871 MK_SHARED_LIB='${LD} ${LDFLAGS} -assert pure-text -o $[@]' 6872 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=rel 6873 ;; 6874 (solaris2*) 6875 # tested with SunOS 5.5.1 (solaris 2.5.1) and gcc 2.7.2 6876 # tested with SunOS 5.10 (solaris 10) and gcc 3.4.3 6877 if test "$DFT_LWR_MODEL" = "shared" ; then 6878 LOCAL_LDFLAGS="-R \$(LOCAL_LIBDIR):\${libdir}" 6879 LOCAL_LDFLAGS2="$LOCAL_LDFLAGS" 6880 fi 6881 if test "$cf_cv_enable_rpath" = yes ; then 6882 EXTRA_LDFLAGS="-R \${libdir} $EXTRA_LDFLAGS" 6883 fi 6884 CF_SHARED_SONAME 6885 if test "$GCC" != yes; then 6886 cf_save_CFLAGS="$CFLAGS" 6887 for cf_shared_opts in -xcode=pic32 -xcode=pic13 -KPIC -Kpic -O 6888 do 6889 CFLAGS="$cf_shared_opts $cf_save_CFLAGS" 6890 AC_TRY_COMPILE([#include <stdio.h>],[printf("Hello\n");],[break]) 6891 done 6892 CFLAGS="$cf_save_CFLAGS" 6893 CC_SHARED_OPTS=$cf_shared_opts 6894 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -dy -G -h '$cf_cv_shared_soname' -o $[@]' 6895 else 6896 MK_SHARED_LIB='${CC} ${LDFLAGS} ${CFLAGS} -shared -dy -G -h '$cf_cv_shared_soname' -o $[@]' 6897 fi 6898 ;; 6899 (sysv5uw7*|unix_sv*) 6900 # tested with UnixWare 7.1.0 (gcc 2.95.2 and cc) 6901 if test "$GCC" != yes; then 6902 CC_SHARED_OPTS='-KPIC' 6903 fi 6904 MK_SHARED_LIB='${LD} ${LDFLAGS} -d y -G -o [$]@' 6905 ;; 6906 (*) 6907 CC_SHARED_OPTS='unknown' 6908 MK_SHARED_LIB='echo unknown' 6909 ;; 6910 esac 6911 6912 # This works if the last tokens in $MK_SHARED_LIB are the -o target. 6913 case "$cf_cv_shlib_version" in 6914 (rel|abi) 6915 case "$MK_SHARED_LIB" in 6916 (*'-o $[@]') 6917 test "$cf_cv_do_symlinks" = no && cf_cv_do_symlinks=yes 6918 ;; 6919 (*) 6920 AC_MSG_WARN(ignored --with-shlib-version) 6921 ;; 6922 esac 6923 ;; 6924 esac 6925 6926 if test -n "$cf_try_cflags" 6927 then 6928cat > conftest.$ac_ext <<EOF 6929#line __oline__ "${as_me:-configure}" 6930#include <stdio.h> 6931int main(int argc, char *argv[[]]) 6932{ 6933 printf("hello\n"); 6934 return (argv[[argc-1]] == 0) ; 6935} 6936EOF 6937 cf_save_CFLAGS="$CFLAGS" 6938 for cf_opt in $cf_try_cflags 6939 do 6940 CFLAGS="$cf_save_CFLAGS -$cf_opt" 6941 AC_MSG_CHECKING(if CFLAGS option -$cf_opt works) 6942 if AC_TRY_EVAL(ac_compile); then 6943 AC_MSG_RESULT(yes) 6944 cf_save_CFLAGS="$CFLAGS" 6945 else 6946 AC_MSG_RESULT(no) 6947 fi 6948 done 6949 CFLAGS="$cf_save_CFLAGS" 6950 fi 6951 6952 6953 # RPATH_LIST is a colon-separated list of directories 6954 test -n "$cf_ld_rpath_opt" && MK_SHARED_LIB="$MK_SHARED_LIB $cf_ld_rpath_opt\${RPATH_LIST}" 6955 test -z "$RPATH_LIST" && RPATH_LIST="\${libdir}" 6956 6957 test $cf_cv_rm_so_locs = yes && RM_SHARED_OPTS="$RM_SHARED_OPTS so_locations" 6958 6959 CF_VERBOSE(CC_SHARED_OPTS: $CC_SHARED_OPTS) 6960 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 6961 6962 AC_SUBST(CC_SHARED_OPTS) 6963 AC_SUBST(LD_RPATH_OPT) 6964 AC_SUBST(LD_SHARED_OPTS) 6965 AC_SUBST(MK_SHARED_LIB) 6966 AC_SUBST(RM_SHARED_OPTS) 6967 6968 AC_SUBST(LINK_PROGS) 6969 AC_SUBST(LINK_TESTS) 6970 6971 AC_SUBST(EXTRA_LDFLAGS) 6972 AC_SUBST(LOCAL_LDFLAGS) 6973 AC_SUBST(LOCAL_LDFLAGS2) 6974 6975 AC_SUBST(INSTALL_LIB) 6976 AC_SUBST(RPATH_LIST) 6977])dnl 6978dnl --------------------------------------------------------------------------- 6979dnl CF_SHARED_SONAME version: 3 updated: 2008/09/08 18:34:43 6980dnl ---------------- 6981dnl utility macro for CF_SHARED_OPTS, constructs "$cf_cv_shared_soname" for 6982dnl substitution into MK_SHARED_LIB string for the "-soname" (or similar) 6983dnl option. 6984dnl 6985dnl $1 is the default that should be used for "$cf_cv_shlib_version". 6986dnl If missing, use "rel". 6987define([CF_SHARED_SONAME], 6988[ 6989 test "$cf_cv_shlib_version" = auto && cf_cv_shlib_version=ifelse($1,,rel,$1) 6990 if test "$cf_cv_shlib_version" = rel; then 6991 cf_cv_shared_soname='`basename $[@] .${REL_VERSION}`.${ABI_VERSION}' 6992 else 6993 cf_cv_shared_soname='`basename $[@]`' 6994 fi 6995]) 6996dnl --------------------------------------------------------------------------- 6997dnl CF_SIGWINCH version: 2 updated: 2019/03/23 19:54:44 6998dnl ----------- 6999dnl Use this macro after CF_XOPEN_SOURCE, but do not require it (not all 7000dnl programs need this test). 7001dnl 7002dnl This is really a Mac OS X 10.4.3 workaround. Defining _POSIX_C_SOURCE 7003dnl forces SIGWINCH to be undefined (breaks xterm, ncurses). Oddly, the struct 7004dnl winsize declaration is left alone - we may revisit this if Apple choose to 7005dnl break that part of the interface as well. 7006AC_DEFUN([CF_SIGWINCH], 7007[ 7008AC_CACHE_CHECK(if SIGWINCH is defined,cf_cv_define_sigwinch,[ 7009 AC_TRY_COMPILE([ 7010#include <sys/types.h> 7011#include <sys/signal.h> 7012],[int x = SIGWINCH], 7013 [cf_cv_define_sigwinch=yes], 7014 [AC_TRY_COMPILE([ 7015#undef _XOPEN_SOURCE 7016#undef _POSIX_SOURCE 7017#undef _POSIX_C_SOURCE 7018#include <sys/types.h> 7019#include <sys/signal.h> 7020],[int x = SIGWINCH], 7021 [cf_cv_define_sigwinch=maybe], 7022 [cf_cv_define_sigwinch=no]) 7023]) 7024]) 7025 7026if test "$cf_cv_define_sigwinch" = maybe ; then 7027AC_CACHE_CHECK(for actual SIGWINCH definition,cf_cv_fixup_sigwinch,[ 7028cf_cv_fixup_sigwinch=unknown 7029cf_sigwinch=32 7030while test $cf_sigwinch != 1 7031do 7032 AC_TRY_COMPILE([ 7033#undef _XOPEN_SOURCE 7034#undef _POSIX_SOURCE 7035#undef _POSIX_C_SOURCE 7036#include <sys/types.h> 7037#include <sys/signal.h> 7038],[ 7039#if SIGWINCH != $cf_sigwinch 7040make an error 7041#endif 7042int x = SIGWINCH], 7043 [cf_cv_fixup_sigwinch=$cf_sigwinch 7044 break]) 7045 7046cf_sigwinch=`expr $cf_sigwinch - 1` 7047done 7048]) 7049 7050 if test "$cf_cv_fixup_sigwinch" != unknown ; then 7051 CPPFLAGS="$CPPFLAGS -DSIGWINCH=$cf_cv_fixup_sigwinch" 7052 fi 7053fi 7054])dnl 7055dnl --------------------------------------------------------------------------- 7056dnl CF_SIG_ATOMIC_T version: 4 updated: 2020/01/18 12:30:44 7057dnl --------------- 7058dnl signal handler, but there are some gcc dependencies in that recommendation. 7059dnl Try anyway. 7060AC_DEFUN([CF_SIG_ATOMIC_T], 7061[ 7062AC_MSG_CHECKING(for signal global datatype) 7063AC_CACHE_VAL(cf_cv_sig_atomic_t,[ 7064 for cf_type in \ 7065 "volatile sig_atomic_t" \ 7066 "sig_atomic_t" \ 7067 "int" 7068 do 7069 AC_TRY_COMPILE([ 7070#include <sys/types.h> 7071#include <signal.h> 7072#include <stdio.h> 7073 7074extern $cf_type x; 7075$cf_type x; 7076static void handler(int sig) 7077{ 7078 x = 5; 7079}], 7080 [signal(SIGINT, handler); 7081 x = 1], 7082 [cf_cv_sig_atomic_t=$cf_type], 7083 [cf_cv_sig_atomic_t=no]) 7084 test "$cf_cv_sig_atomic_t" != no && break 7085 done 7086 ]) 7087AC_MSG_RESULT($cf_cv_sig_atomic_t) 7088test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t,[Define to signal global datatype]) 7089])dnl 7090dnl --------------------------------------------------------------------------- 7091dnl CF_SIZECHANGE version: 14 updated: 2018/06/20 20:23:13 7092dnl ------------- 7093dnl Check for definitions & structures needed for window size-changing 7094dnl 7095dnl https://stackoverflow.com/questions/18878141/difference-between-structures-ttysize-and-winsize/50769952#50769952 7096AC_DEFUN([CF_SIZECHANGE], 7097[ 7098AC_REQUIRE([CF_STRUCT_TERMIOS]) 7099AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[ 7100 cf_cv_sizechange=unknown 7101 cf_save_CPPFLAGS="$CPPFLAGS" 7102 7103for cf_opts in "" "NEED_PTEM_H" 7104do 7105 7106 CPPFLAGS="$cf_save_CPPFLAGS" 7107 if test -n "$cf_opts" 7108 then 7109 CF_APPEND_TEXT(CPPFLAGS,-D$cf_opts) 7110 fi 7111 AC_TRY_COMPILE([#include <sys/types.h> 7112#ifdef HAVE_TERMIOS_H 7113#include <termios.h> 7114#else 7115#ifdef HAVE_TERMIO_H 7116#include <termio.h> 7117#endif 7118#endif 7119 7120#ifdef NEED_PTEM_H 7121/* This is a workaround for SCO: they neglected to define struct winsize in 7122 * termios.h -- it's only in termio.h and ptem.h 7123 */ 7124#include <sys/stream.h> 7125#include <sys/ptem.h> 7126#endif 7127 7128#ifdef HAVE_SYS_IOCTL_H 7129#include <sys/ioctl.h> 7130#endif 7131],[ 7132#ifdef TIOCGSIZE 7133 struct ttysize win; /* SunOS 3.0... */ 7134 int y = win.ts_lines; 7135 int x = win.ts_cols; 7136#else 7137#ifdef TIOCGWINSZ 7138 struct winsize win; /* everything else */ 7139 int y = win.ws_row; 7140 int x = win.ws_col; 7141#else 7142 no TIOCGSIZE or TIOCGWINSZ 7143#endif /* TIOCGWINSZ */ 7144#endif /* TIOCGSIZE */ 7145 ], 7146 [cf_cv_sizechange=yes], 7147 [cf_cv_sizechange=no]) 7148 7149 CPPFLAGS="$cf_save_CPPFLAGS" 7150 if test "$cf_cv_sizechange" = yes ; then 7151 echo "size-change succeeded ($cf_opts)" >&AC_FD_CC 7152 test -n "$cf_opts" && cf_cv_sizechange="$cf_opts" 7153 break 7154 fi 7155done 7156]) 7157if test "$cf_cv_sizechange" != no ; then 7158 AC_DEFINE(HAVE_SIZECHANGE,1,[Define to 1 if sizechange declarations are provided]) 7159 case $cf_cv_sizechange in 7160 (NEED*) 7161 AC_DEFINE_UNQUOTED($cf_cv_sizechange ) 7162 ;; 7163 esac 7164fi 7165])dnl 7166dnl --------------------------------------------------------------------------- 7167dnl CF_SRC_MODULES version: 31 updated: 2019/09/21 18:08:42 7168dnl -------------- 7169dnl For each parameter, test if the source-directory exists, and if it contains 7170dnl a 'modules' file. If so, add to the list $cf_cv_src_modules which we'll 7171dnl use in CF_LIB_RULES. 7172dnl 7173dnl This uses the configured value to make the lists SRC_SUBDIRS and 7174dnl SUB_MAKEFILES which are used in the makefile-generation scheme. 7175AC_DEFUN([CF_SRC_MODULES], 7176[ 7177AC_REQUIRE([CF_CHECK_GNAT_VERSION]) 7178AC_MSG_CHECKING(for src modules) 7179 7180# dependencies and linker-arguments for test-programs 7181TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEPS" 7182TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${LIB_NAME}${DFT_DEP_SUFFIX} $TEST_DEP2" 7183if test "$DFT_LWR_MODEL" = "libtool"; then 7184 TEST_ARGS="${TEST_DEPS}" 7185 TEST_ARG2="${TEST_DEP2}" 7186else 7187 TEST_ARGS="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARGS" 7188 TEST_ARG2="-l${LIB_NAME}${USE_ARG_SUFFIX} $TEST_ARG2" 7189fi 7190 7191PC_MODULES_TO_MAKE="ncurses${USE_ARG_SUFFIX}" 7192cf_cv_src_modules= 7193for cf_dir in $1 7194do 7195 if test -f $srcdir/$cf_dir/modules; then 7196 7197 # We may/may not have tack in the distribution, though the 7198 # makefile is. 7199 if test $cf_dir = tack ; then 7200 if test "x$cf_with_tack" != "xyes"; then 7201 continue 7202 fi 7203 fi 7204 7205 if test -z "$cf_cv_src_modules"; then 7206 cf_cv_src_modules=$cf_dir 7207 else 7208 cf_cv_src_modules="$cf_cv_src_modules $cf_dir" 7209 fi 7210 7211 # Make the ncurses_cfg.h file record the library interface files as 7212 # well. These are header files that are the same name as their 7213 # directory. Ncurses is the only library that does not follow 7214 # that pattern. 7215 if test $cf_dir = tack ; then 7216 continue 7217 elif test -f $srcdir/${cf_dir}/${cf_dir}.h; then 7218 CF_UPPER(cf_have_include,$cf_dir) 7219 AC_DEFINE_UNQUOTED(HAVE_${cf_have_include}_H) 7220 AC_DEFINE_UNQUOTED(HAVE_LIB${cf_have_include}) 7221 TEST_DEPS="${LIB_DIR}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEPS" 7222 TEST_DEP2="${LIB_2ND}/${LIB_PREFIX}${cf_dir}${DFT_DEP_SUFFIX} $TEST_DEP2" 7223 if test "$DFT_LWR_MODEL" = "libtool"; then 7224 TEST_ARGS="${TEST_DEPS}" 7225 TEST_ARG2="${TEST_DEP2}" 7226 else 7227 TEST_ARGS="-l${cf_dir}${USE_ARG_SUFFIX} $TEST_ARGS" 7228 TEST_ARG2="-l${cf_dir}${USE_ARG_SUFFIX} $TEST_ARG2" 7229 fi 7230 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ${cf_dir}${USE_ARG_SUFFIX}" 7231 fi 7232 fi 7233done 7234AC_MSG_RESULT($cf_cv_src_modules) 7235 7236TEST_ARGS="-L${LIB_DIR} $TEST_ARGS" 7237TEST_ARG2="-L${LIB_2ND} $TEST_ARG2" 7238 7239AC_SUBST(TEST_ARGS) 7240AC_SUBST(TEST_DEPS) 7241 7242AC_SUBST(TEST_ARG2) 7243AC_SUBST(TEST_DEP2) 7244 7245SRC_SUBDIRS= 7246if test "x$cf_with_manpages" != xno ; then 7247 SRC_SUBDIRS="$SRC_SUBDIRS man" 7248fi 7249SRC_SUBDIRS="$SRC_SUBDIRS include" 7250for cf_dir in $cf_cv_src_modules 7251do 7252 SRC_SUBDIRS="$SRC_SUBDIRS $cf_dir" 7253done 7254if test "x$cf_with_tests" != "xno" ; then 7255 SRC_SUBDIRS="$SRC_SUBDIRS test" 7256fi 7257# always make this, to install the ncurses-config script 7258SRC_SUBDIRS="$SRC_SUBDIRS misc" 7259if test "$cf_with_cxx_binding" != no; then 7260 PC_MODULES_TO_MAKE="${PC_MODULES_TO_MAKE} ncurses++${USE_ARG_SUFFIX}" 7261 SRC_SUBDIRS="$SRC_SUBDIRS c++" 7262fi 7263 7264test "x$with_termlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TINFO_ARG_SUFFIX" 7265test "x$with_ticlib" != xno && PC_MODULES_TO_MAKE="$PC_MODULES_TO_MAKE $TICS_ARG_SUFFIX" 7266 7267AC_SUBST(PC_MODULES_TO_MAKE) 7268 7269ADA_SUBDIRS= 7270if test "x$cf_with_ada" = "xyes" && test "x$cf_cv_prog_gnat_correct" = xyes && test -f $srcdir/Ada95/Makefile.in; then 7271 SRC_SUBDIRS="$SRC_SUBDIRS Ada95" 7272 ADA_SUBDIRS="gen src" 7273 if test "x$cf_with_tests" != "xno" ; then 7274 ADA_SUBDIRS="$ADA_SUBDIRS samples" 7275 fi 7276fi 7277 7278SUB_MAKEFILES= 7279for cf_dir in $SRC_SUBDIRS 7280do 7281 SUB_MAKEFILES="$SUB_MAKEFILES $cf_dir/Makefile" 7282done 7283 7284if test -n "$ADA_SUBDIRS"; then 7285 for cf_dir in $ADA_SUBDIRS 7286 do 7287 SUB_MAKEFILES="$SUB_MAKEFILES Ada95/$cf_dir/Makefile" 7288 done 7289 AC_SUBST(ADA_SUBDIRS) 7290fi 7291])dnl 7292dnl --------------------------------------------------------------------------- 7293dnl CF_STDCPP_LIBRARY version: 11 updated: 2015/10/17 19:03:33 7294dnl ----------------- 7295dnl Check for -lstdc++, which is GNU's standard C++ library. 7296dnl If $CXXLIBS is set, add that to the libraries used for test-linking. 7297dnl If -lstdc++ was not already added to $LIBS or $CXXLIBS, and is needed, 7298dnl add it to $CXXLIBS. 7299AC_DEFUN([CF_STDCPP_LIBRARY], 7300[ 7301if test -n "$GXX" ; then 7302 7303 cf_save="$LIBS" 7304 LIBS="$LIBS $CXXLIBS" 7305 AC_MSG_CHECKING(if we already have C++ library) 7306 AC_TRY_LINK([ 7307 #include <iostream>],[ 7308 std::cout << "Hello World!" << std::endl;], 7309 [cf_have_libstdcpp=yes], 7310 [cf_have_libstdcpp=no]) 7311 AC_MSG_RESULT($cf_have_libstdcpp) 7312 LIBS="$cf_save" 7313 7314 if test $cf_have_libstdcpp != yes 7315 then 7316 case $cf_cv_system_name in 7317 (os2*) 7318 if test -z "`g++ -dM -E - < /dev/null | grep __KLIBC__`"; then 7319 cf_stdcpp_libname=stdcpp 7320 else 7321 cf_stdcpp_libname=stdc++ 7322 fi 7323 ;; 7324 (*) 7325 cf_stdcpp_libname=stdc++ 7326 ;; 7327 esac 7328 7329 AC_CACHE_CHECK(for library $cf_stdcpp_libname,cf_cv_libstdcpp,[ 7330 cf_save="$LIBS" 7331 LIBS="$LIBS $CXXLIBS" 7332 CF_ADD_LIB($cf_stdcpp_libname) 7333 AC_TRY_LINK([ 7334 #include <iostream>],[ 7335 std::cout << "Hello World!" << std::endl;], 7336 [cf_cv_libstdcpp=yes], 7337 [cf_cv_libstdcpp=no]) 7338 LIBS="$cf_save" 7339 ]) 7340 test "$cf_cv_libstdcpp" = yes && { CF_ADD_LIB($cf_stdcpp_libname,CXXLIBS) } 7341 fi 7342fi 7343])dnl 7344dnl --------------------------------------------------------------------------- 7345dnl CF_STRIP_G_OPT version: 3 updated: 2002/12/21 19:25:52 7346dnl -------------- 7347dnl Remove "-g" option from the compiler options 7348AC_DEFUN([CF_STRIP_G_OPT], 7349[$1=`echo ${$1} | sed -e 's%-g %%' -e 's%-g$%%'`])dnl 7350dnl --------------------------------------------------------------------------- 7351dnl CF_STRUCT_SIGACTION version: 5 updated: 2012/10/06 17:56:13 7352dnl ------------------- 7353dnl Check if we need _POSIX_SOURCE defined to use struct sigaction. We'll only 7354dnl do this if we've found the sigaction function. 7355AC_DEFUN([CF_STRUCT_SIGACTION],[ 7356AC_REQUIRE([CF_XOPEN_SOURCE]) 7357 7358if test "$ac_cv_func_sigaction" = yes; then 7359AC_MSG_CHECKING(whether sigaction needs _POSIX_SOURCE) 7360AC_TRY_COMPILE([ 7361#include <sys/types.h> 7362#include <signal.h>], 7363 [struct sigaction act], 7364 [sigact_bad=no], 7365 [ 7366AC_TRY_COMPILE([ 7367#define _POSIX_SOURCE 7368#include <sys/types.h> 7369#include <signal.h>], 7370 [struct sigaction act], 7371 [sigact_bad=yes 7372 AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])], 7373 [sigact_bad=unknown])]) 7374AC_MSG_RESULT($sigact_bad) 7375fi 7376])dnl 7377dnl --------------------------------------------------------------------------- 7378dnl CF_STRUCT_TERMIOS version: 9 updated: 2018/06/08 21:57:23 7379dnl ----------------- 7380dnl Some machines require _POSIX_SOURCE to completely define struct termios. 7381AC_DEFUN([CF_STRUCT_TERMIOS],[ 7382AC_REQUIRE([CF_XOPEN_SOURCE]) 7383 7384AC_CHECK_HEADERS( \ 7385termio.h \ 7386termios.h \ 7387unistd.h \ 7388sys/ioctl.h \ 7389sys/termio.h \ 7390) 7391 7392if test "$ac_cv_header_termios_h" = yes ; then 7393 case "$CFLAGS $CPPFLAGS" in 7394 (*-D_POSIX_SOURCE*) 7395 termios_bad=dunno ;; 7396 (*) termios_bad=maybe ;; 7397 esac 7398 if test "$termios_bad" = maybe ; then 7399 AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE) 7400 AC_TRY_COMPILE([#include <termios.h>], 7401 [struct termios foo; int x = foo.c_iflag], 7402 termios_bad=no, [ 7403 AC_TRY_COMPILE([ 7404#define _POSIX_SOURCE 7405#include <termios.h>], 7406 [struct termios foo; int x = foo.c_iflag], 7407 termios_bad=unknown, 7408 termios_bad=yes AC_DEFINE(_POSIX_SOURCE,1,[Define to 1 if we must define _POSIX_SOURCE])) 7409 ]) 7410 AC_MSG_RESULT($termios_bad) 7411 fi 7412fi 7413])dnl 7414dnl --------------------------------------------------------------------------- 7415dnl CF_SUBDIR_PATH version: 7 updated: 2014/12/04 04:33:06 7416dnl -------------- 7417dnl Construct a search-list for a nonstandard header/lib-file 7418dnl $1 = the variable to return as result 7419dnl $2 = the package name 7420dnl $3 = the subdirectory, e.g., bin, include or lib 7421AC_DEFUN([CF_SUBDIR_PATH], 7422[ 7423$1= 7424 7425CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE) 7426 7427for cf_subdir_prefix in \ 7428 /usr \ 7429 /usr/local \ 7430 /usr/pkg \ 7431 /opt \ 7432 /opt/local \ 7433 [$]HOME 7434do 7435 CF_ADD_SUBDIR_PATH($1,$2,$3,$cf_subdir_prefix,$prefix) 7436done 7437])dnl 7438dnl --------------------------------------------------------------------------- 7439dnl CF_SUBST_IF version: 2 updated: 2006/06/17 12:33:03 7440dnl ----------- 7441dnl Shorthand macro for substituting things that the user may override 7442dnl with an environment variable. 7443dnl 7444dnl $1 = condition to pass to "test" 7445dnl $2 = environment variable 7446dnl $3 = value if the test succeeds 7447dnl $4 = value if the test fails 7448AC_DEFUN([CF_SUBST_IF], 7449[ 7450if test $1 ; then 7451 $2=$3 7452ifelse($4,,,[else 7453 $2=$4]) 7454fi 7455AC_SUBST($2) 7456])dnl 7457dnl --------------------------------------------------------------------------- 7458dnl CF_SUBST_NCURSES_VERSION version: 8 updated: 2006/09/16 11:40:59 7459dnl ------------------------ 7460dnl Get the version-number for use in shared-library naming, etc. 7461AC_DEFUN([CF_SUBST_NCURSES_VERSION], 7462[ 7463AC_REQUIRE([CF_PROG_EGREP]) 7464NCURSES_MAJOR="`$ac_cv_prog_egrep '^NCURSES_MAJOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`" 7465NCURSES_MINOR="`$ac_cv_prog_egrep '^NCURSES_MINOR[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`" 7466NCURSES_PATCH="`$ac_cv_prog_egrep '^NCURSES_PATCH[[ ]]*=' $srcdir/dist.mk | sed -e 's/^[[^0-9]]*//'`" 7467cf_cv_abi_version=${NCURSES_MAJOR} 7468cf_cv_rel_version=${NCURSES_MAJOR}.${NCURSES_MINOR} 7469dnl Show the computed version, for logging 7470cf_cv_timestamp=`date` 7471AC_MSG_RESULT(Configuring NCURSES $cf_cv_rel_version ABI $cf_cv_abi_version ($cf_cv_timestamp)) 7472dnl We need these values in the generated headers 7473AC_SUBST(NCURSES_MAJOR) 7474AC_SUBST(NCURSES_MINOR) 7475AC_SUBST(NCURSES_PATCH) 7476dnl We need these values in the generated makefiles 7477AC_SUBST(cf_cv_rel_version) 7478AC_SUBST(cf_cv_abi_version) 7479AC_SUBST(cf_cv_builtin_bool) 7480AC_SUBST(cf_cv_header_stdbool_h) 7481AC_SUBST(cf_cv_type_of_bool)dnl 7482])dnl 7483dnl --------------------------------------------------------------------------- 7484dnl CF_SYS_TIME_SELECT version: 6 updated: 2015/04/18 08:56:57 7485dnl ------------------ 7486dnl Check if we can include <sys/time.h> with <sys/select.h>; this breaks on 7487dnl older SCO configurations. 7488AC_DEFUN([CF_SYS_TIME_SELECT], 7489[ 7490AC_MSG_CHECKING(if sys/time.h works with sys/select.h) 7491AC_CACHE_VAL(cf_cv_sys_time_select,[ 7492AC_TRY_COMPILE([ 7493#include <sys/types.h> 7494#ifdef HAVE_SYS_TIME_H 7495#include <sys/time.h> 7496#endif 7497#ifdef HAVE_SYS_SELECT_H 7498#include <sys/select.h> 7499#endif 7500],[],[cf_cv_sys_time_select=yes], 7501 [cf_cv_sys_time_select=no]) 7502 ]) 7503AC_MSG_RESULT($cf_cv_sys_time_select) 7504test "$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>]) 7505])dnl 7506dnl --------------------------------------------------------------------------- 7507dnl CF_TOP_BUILDDIR version: 2 updated: 2013/07/27 17:38:32 7508dnl --------------- 7509dnl Define a top_builddir symbol, for applications that need an absolute path. 7510AC_DEFUN([CF_TOP_BUILDDIR], 7511[ 7512top_builddir=ifelse($1,,`pwd`,$1) 7513AC_SUBST(top_builddir) 7514])dnl 7515dnl --------------------------------------------------------------------------- 7516dnl CF_TRY_PKG_CONFIG version: 5 updated: 2013/07/06 21:27:06 7517dnl ----------------- 7518dnl This is a simple wrapper to use for pkg-config, for libraries which may be 7519dnl available in that form. 7520dnl 7521dnl $1 = package name 7522dnl $2 = extra logic to use, if any, after updating CFLAGS and LIBS 7523dnl $3 = logic to use if pkg-config does not have the package 7524AC_DEFUN([CF_TRY_PKG_CONFIG],[ 7525AC_REQUIRE([CF_PKG_CONFIG]) 7526 7527if test "$PKG_CONFIG" != none && "$PKG_CONFIG" --exists $1; then 7528 CF_VERBOSE(found package $1) 7529 cf_pkgconfig_incs="`$PKG_CONFIG --cflags $1 2>/dev/null`" 7530 cf_pkgconfig_libs="`$PKG_CONFIG --libs $1 2>/dev/null`" 7531 CF_VERBOSE(package $1 CFLAGS: $cf_pkgconfig_incs) 7532 CF_VERBOSE(package $1 LIBS: $cf_pkgconfig_libs) 7533 CF_ADD_CFLAGS($cf_pkgconfig_incs) 7534 CF_ADD_LIBS($cf_pkgconfig_libs) 7535 ifelse([$2],,:,[$2]) 7536else 7537 cf_pkgconfig_incs= 7538 cf_pkgconfig_libs= 7539 ifelse([$3],,:,[$3]) 7540fi 7541]) 7542dnl --------------------------------------------------------------------------- 7543dnl CF_TRY_XOPEN_SOURCE version: 2 updated: 2018/06/20 20:23:13 7544dnl ------------------- 7545dnl If _XOPEN_SOURCE is not defined in the compile environment, check if we 7546dnl can define it successfully. 7547AC_DEFUN([CF_TRY_XOPEN_SOURCE],[ 7548AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[ 7549 AC_TRY_COMPILE([ 7550#include <stdlib.h> 7551#include <string.h> 7552#include <sys/types.h> 7553],[ 7554#ifndef _XOPEN_SOURCE 7555make an error 7556#endif], 7557 [cf_cv_xopen_source=no], 7558 [cf_save="$CPPFLAGS" 7559 CF_APPEND_TEXT(CPPFLAGS,-D_XOPEN_SOURCE=$cf_XOPEN_SOURCE) 7560 AC_TRY_COMPILE([ 7561#include <stdlib.h> 7562#include <string.h> 7563#include <sys/types.h> 7564],[ 7565#ifdef _XOPEN_SOURCE 7566make an error 7567#endif], 7568 [cf_cv_xopen_source=no], 7569 [cf_cv_xopen_source=$cf_XOPEN_SOURCE]) 7570 CPPFLAGS="$cf_save" 7571 ]) 7572]) 7573 7574if test "$cf_cv_xopen_source" != no ; then 7575 CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE) 7576 CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE) 7577 cf_temp_xopen_source="-D_XOPEN_SOURCE=$cf_cv_xopen_source" 7578 CF_ADD_CFLAGS($cf_temp_xopen_source) 7579fi 7580]) 7581dnl --------------------------------------------------------------------------- 7582dnl CF_TYPEOF_CHTYPE version: 10 updated: 2017/01/21 11:06:25 7583dnl ---------------- 7584dnl Determine the type we should use for chtype (and attr_t, which is treated 7585dnl as the same thing). We want around 32 bits, so on most machines want a 7586dnl long, but on newer 64-bit machines, probably want an int. If we're using 7587dnl wide characters, we have to have a type compatible with that, as well. 7588AC_DEFUN([CF_TYPEOF_CHTYPE], 7589[ 7590AC_MSG_CHECKING([for type of chtype]) 7591AC_CACHE_VAL(cf_cv_typeof_chtype,[ 7592 AC_TRY_RUN([ 7593#define WANT_BITS 31 7594#include <stdio.h> 7595int main(void) 7596{ 7597 FILE *fp = fopen("cf_test.out", "w"); 7598 if (fp != 0) { 7599 char *result = "long"; 7600 if (sizeof(unsigned long) > sizeof(unsigned int)) { 7601 int n; 7602 unsigned int x, y; 7603 for (n = 0; n < WANT_BITS; n++) { 7604 x = (1 << n); 7605 y = (x >> n); 7606 if (y != 1 || x == 0) { 7607 x = 0; 7608 break; 7609 } 7610 } 7611 /* 7612 * If x is nonzero, an int is big enough for the bits 7613 * that we want. 7614 */ 7615 result = (x != 0) ? "int" : "long"; 7616 } 7617 fputs(result, fp); 7618 fclose(fp); 7619 } 7620 ${cf_cv_main_return:-return}(0); 7621} 7622 ], 7623 [cf_cv_typeof_chtype=`cat cf_test.out`], 7624 [cf_cv_typeof_chtype=long], 7625 [cf_cv_typeof_chtype=long]) 7626 rm -f cf_test.out 7627 ]) 7628AC_MSG_RESULT($cf_cv_typeof_chtype) 7629 7630AC_SUBST(cf_cv_typeof_chtype) 7631AC_DEFINE_UNQUOTED(TYPEOF_CHTYPE,$cf_cv_typeof_chtype,[Define to actual type if needed for chtype]) 7632])dnl 7633dnl --------------------------------------------------------------------------- 7634dnl CF_TYPE_SIGACTION version: 4 updated: 2012/10/06 17:56:13 7635dnl ----------------- 7636dnl 7637AC_DEFUN([CF_TYPE_SIGACTION], 7638[ 7639AC_MSG_CHECKING([for type sigaction_t]) 7640AC_CACHE_VAL(cf_cv_type_sigaction,[ 7641 AC_TRY_COMPILE([ 7642#include <signal.h>], 7643 [sigaction_t x], 7644 [cf_cv_type_sigaction=yes], 7645 [cf_cv_type_sigaction=no])]) 7646AC_MSG_RESULT($cf_cv_type_sigaction) 7647test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION,1,[Define to 1 if we have the sigaction_t type]) 7648])dnl 7649dnl --------------------------------------------------------------------------- 7650dnl CF_UNSIGNED_LITERALS version: 2 updated: 1998/02/07 22:10:16 7651dnl -------------------- 7652dnl Test if the compiler supports 'U' and 'L' suffixes. Only old compilers 7653dnl won't, but they're still there. 7654AC_DEFUN([CF_UNSIGNED_LITERALS], 7655[ 7656AC_MSG_CHECKING([if unsigned literals are legal]) 7657AC_CACHE_VAL(cf_cv_unsigned_literals,[ 7658 AC_TRY_COMPILE([],[long x = 1L + 1UL + 1U + 1], 7659 [cf_cv_unsigned_literals=yes], 7660 [cf_cv_unsigned_literals=no]) 7661 ]) 7662AC_MSG_RESULT($cf_cv_unsigned_literals) 7663])dnl 7664dnl --------------------------------------------------------------------------- 7665dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 7666dnl -------- 7667dnl Make an uppercase version of a variable 7668dnl $1=uppercase($2) 7669AC_DEFUN([CF_UPPER], 7670[ 7671$1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` 7672])dnl 7673dnl --------------------------------------------------------------------------- 7674dnl CF_UTF8_LIB version: 8 updated: 2012/10/06 08:57:51 7675dnl ----------- 7676dnl Check for multibyte support, and if not found, utf8 compatibility library 7677AC_DEFUN([CF_UTF8_LIB], 7678[ 7679AC_CACHE_CHECK(for multibyte character support,cf_cv_utf8_lib,[ 7680 cf_save_LIBS="$LIBS" 7681 AC_TRY_LINK([ 7682#include <stdlib.h>],[putwc(0,0);], 7683 [cf_cv_utf8_lib=yes], 7684 [CF_FIND_LINKAGE([ 7685#include <libutf8.h>],[putwc(0,0);],utf8, 7686 [cf_cv_utf8_lib=add-on], 7687 [cf_cv_utf8_lib=no]) 7688])]) 7689 7690# HAVE_LIBUTF8_H is used by ncurses if curses.h is shared between 7691# ncurses/ncursesw: 7692if test "$cf_cv_utf8_lib" = "add-on" ; then 7693 AC_DEFINE(HAVE_LIBUTF8_H,1,[Define to 1 if we should include libutf8.h]) 7694 CF_ADD_INCDIR($cf_cv_header_path_utf8) 7695 CF_ADD_LIBDIR($cf_cv_library_path_utf8) 7696 CF_ADD_LIBS($cf_cv_library_file_utf8) 7697fi 7698])dnl 7699dnl --------------------------------------------------------------------------- 7700dnl CF_VA_COPY version: 6 updated: 2018/12/04 18:14:25 7701dnl ---------- 7702dnl check for va_copy, part of stdarg.h starting with ISO C 1999. 7703dnl Also, workaround for glibc's __va_copy, by checking for both. 7704dnl Finally, try to accommodate pre-ISO C 1999 headers. 7705AC_DEFUN([CF_VA_COPY],[ 7706AC_CACHE_CHECK(for va_copy, cf_cv_have_va_copy,[ 7707AC_TRY_LINK([ 7708#include <stdarg.h> 7709],[ 7710 static va_list dst; 7711 static va_list src; 7712 va_copy(dst, src)], 7713 cf_cv_have_va_copy=yes, 7714 cf_cv_have_va_copy=no)]) 7715 7716if test "$cf_cv_have_va_copy" = yes; 7717then 7718 AC_DEFINE(HAVE_VA_COPY,1,[Define to 1 if we have va_copy]) 7719else # !cf_cv_have_va_copy 7720 7721AC_CACHE_CHECK(for __va_copy, cf_cv_have___va_copy,[ 7722AC_TRY_LINK([ 7723#include <stdarg.h> 7724],[ 7725 static va_list dst; 7726 static va_list src; 7727 __va_copy(dst, src)], 7728 cf_cv_have___va_copy=yes, 7729 cf_cv_have___va_copy=no)]) 7730 7731if test "$cf_cv_have___va_copy" = yes 7732then 7733 AC_DEFINE(HAVE___VA_COPY,1,[Define to 1 if we have __va_copy]) 7734else # !cf_cv_have___va_copy 7735 7736AC_CACHE_CHECK(for __builtin_va_copy, cf_cv_have___builtin_va_copy,[ 7737AC_TRY_LINK([ 7738#include <stdarg.h> 7739],[ 7740 static va_list dst; 7741 static va_list src; 7742 __builtin_va_copy(dst, src)], 7743 cf_cv_have___builtin_va_copy=yes, 7744 cf_cv_have___builtin_va_copy=no)]) 7745 7746test "$cf_cv_have___builtin_va_copy" = yes && 7747 AC_DEFINE(HAVE___BUILTIN_VA_COPY,1,[Define to 1 if we have __builtin_va_copy]) 7748 7749fi # cf_cv_have___va_copy 7750 7751fi # cf_cv_have_va_copy 7752 7753case "${cf_cv_have_va_copy}${cf_cv_have___va_copy}${cf_cv_have___builtin_va_copy}" in 7754(*yes*) 7755 ;; 7756 7757(*) 7758 AC_CACHE_CHECK(if we can simply copy va_list, cf_cv_pointer_va_list,[ 7759AC_TRY_LINK([ 7760#include <stdarg.h> 7761],[ 7762 va_list dst; 7763 va_list src; 7764 dst = src], 7765 cf_cv_pointer_va_list=yes, 7766 cf_cv_pointer_va_list=no)]) 7767 7768 if test "$cf_cv_pointer_va_list" = no 7769 then 7770 AC_CACHE_CHECK(if we can copy va_list indirectly, cf_cv_array_va_list,[ 7771AC_TRY_LINK([ 7772#include <stdarg.h> 7773],[ 7774 va_list dst; 7775 va_list src; 7776 *dst = *src], 7777 cf_cv_array_va_list=yes, 7778 cf_cv_array_va_list=no)]) 7779 test "$cf_cv_array_va_list" = yes && AC_DEFINE(ARRAY_VA_LIST,1,[Define to 1 if we can copy va_list indirectly]) 7780 fi 7781 ;; 7782esac 7783]) 7784dnl --------------------------------------------------------------------------- 7785dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12 7786dnl ---------- 7787dnl Use AC_VERBOSE w/o the warnings 7788AC_DEFUN([CF_VERBOSE], 7789[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG 7790CF_MSG_LOG([$1]) 7791])dnl 7792dnl --------------------------------------------------------------------------- 7793dnl CF_VERSION_INFO version: 7 updated: 2015/04/17 21:13:04 7794dnl --------------- 7795dnl Define several useful symbols derived from the VERSION file. A separate 7796dnl file is preferred to embedding the version numbers in various scripts. 7797dnl (automake is a textbook-example of why the latter is a bad idea, but there 7798dnl are others). 7799dnl 7800dnl The file contents are: 7801dnl libtool-version release-version patch-version 7802dnl or 7803dnl release-version 7804dnl where 7805dnl libtool-version (see ?) consists of 3 integers separated by '.' 7806dnl release-version consists of a major version and minor version 7807dnl separated by '.', optionally followed by a patch-version 7808dnl separated by '-'. The minor version need not be an 7809dnl integer (but it is preferred). 7810dnl patch-version is an integer in the form yyyymmdd, so ifdef's and 7811dnl scripts can easily compare versions. 7812dnl 7813dnl If libtool is used, the first form is required, since CF_WITH_LIBTOOL 7814dnl simply extracts the first field using 'cut -f1'. 7815dnl 7816dnl Optional parameters: 7817dnl $1 = internal name for package 7818dnl $2 = external name for package 7819AC_DEFUN([CF_VERSION_INFO], 7820[ 7821if test -f $srcdir/VERSION ; then 7822 AC_MSG_CHECKING(for package version) 7823 7824 # if there are not enough fields, cut returns the last one... 7825 cf_field1=`sed -e '2,$d' $srcdir/VERSION|cut -f1` 7826 cf_field2=`sed -e '2,$d' $srcdir/VERSION|cut -f2` 7827 cf_field3=`sed -e '2,$d' $srcdir/VERSION|cut -f3` 7828 7829 # this is how CF_BUNDLED_INTL uses $VERSION: 7830 VERSION="$cf_field1" 7831 7832 VERSION_MAJOR=`echo "$cf_field2" | sed -e 's/\..*//'` 7833 test -z "$VERSION_MAJOR" && AC_MSG_ERROR(missing major-version) 7834 7835 VERSION_MINOR=`echo "$cf_field2" | sed -e 's/^[[^.]]*\.//' -e 's/-.*//'` 7836 test -z "$VERSION_MINOR" && AC_MSG_ERROR(missing minor-version) 7837 7838 AC_MSG_RESULT(${VERSION_MAJOR}.${VERSION_MINOR}) 7839 7840 AC_MSG_CHECKING(for package patch date) 7841 VERSION_PATCH=`echo "$cf_field3" | sed -e 's/^[[^-]]*-//'` 7842 case .$VERSION_PATCH in 7843 (.) 7844 AC_MSG_ERROR(missing patch-date $VERSION_PATCH) 7845 ;; 7846 (.[[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]][[0-9]]) 7847 ;; 7848 (*) 7849 AC_MSG_ERROR(illegal patch-date $VERSION_PATCH) 7850 ;; 7851 esac 7852 AC_MSG_RESULT($VERSION_PATCH) 7853else 7854 AC_MSG_ERROR(did not find $srcdir/VERSION) 7855fi 7856 7857# show the actual data that we have for versions: 7858CF_VERBOSE(ABI VERSION $VERSION) 7859CF_VERBOSE(VERSION_MAJOR $VERSION_MAJOR) 7860CF_VERBOSE(VERSION_MINOR $VERSION_MINOR) 7861CF_VERBOSE(VERSION_PATCH $VERSION_PATCH) 7862 7863AC_SUBST(VERSION) 7864AC_SUBST(VERSION_MAJOR) 7865AC_SUBST(VERSION_MINOR) 7866AC_SUBST(VERSION_PATCH) 7867 7868dnl if a package name is given, define its corresponding version info. We 7869dnl need the package name to ensure that the defined symbols are unique. 7870ifelse($1,,,[ 7871 cf_PACKAGE=$1 7872 PACKAGE=ifelse($2,,$1,$2) 7873 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",[Define to the package-name]) 7874 AC_SUBST(PACKAGE) 7875 CF_UPPER(cf_PACKAGE,$cf_PACKAGE) 7876 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_VERSION,"${VERSION_MAJOR}.${VERSION_MINOR}") 7877 AC_DEFINE_UNQUOTED(${cf_PACKAGE}_PATCHDATE,${VERSION_PATCH}) 7878]) 7879])dnl 7880dnl --------------------------------------------------------------------------- 7881dnl CF_WCHAR_TYPE version: 4 updated: 2012/10/06 16:39:58 7882dnl ------------- 7883dnl Check if type wide-character type $1 is declared, and if so, which header 7884dnl file is needed. The second parameter is used to set a shell variable when 7885dnl the type is not found. The first parameter sets a shell variable for the 7886dnl opposite sense. 7887AC_DEFUN([CF_WCHAR_TYPE], 7888[ 7889# This is needed on Tru64 5.0 to declare $1 7890AC_CACHE_CHECK(if we must include wchar.h to declare $1,cf_cv_$1,[ 7891AC_TRY_COMPILE([ 7892#include <stdlib.h> 7893#include <stdarg.h> 7894#include <stdio.h> 7895#ifdef HAVE_LIBUTF8_H 7896#include <libutf8.h> 7897#endif], 7898 [$1 state], 7899 [cf_cv_$1=no], 7900 [AC_TRY_COMPILE([ 7901#include <stdlib.h> 7902#include <stdarg.h> 7903#include <stdio.h> 7904#include <wchar.h> 7905#ifdef HAVE_LIBUTF8_H 7906#include <libutf8.h> 7907#endif], 7908 [$1 value], 7909 [cf_cv_$1=yes], 7910 [cf_cv_$1=unknown])])]) 7911 7912if test "$cf_cv_$1" = yes ; then 7913 AC_DEFINE(NEED_WCHAR_H,1,[Define to 1 if we must include wchar.h]) 7914 NEED_WCHAR_H=1 7915fi 7916 7917ifelse([$2],,,[ 7918# if we do not find $1 in either place, use substitution to provide a fallback. 7919if test "$cf_cv_$1" = unknown ; then 7920 $2=1 7921fi 7922]) 7923ifelse($3,,,[ 7924# if we find $1 in either place, use substitution to provide a fallback. 7925if test "$cf_cv_$1" != unknown ; then 7926 $3=1 7927fi 7928]) 7929])dnl 7930dnl --------------------------------------------------------------------------- 7931dnl CF_WEAK_SYMBOLS version: 1 updated: 2008/08/16 19:18:06 7932dnl --------------- 7933dnl Check for compiler-support for weak symbols. 7934dnl This works with "recent" gcc. 7935AC_DEFUN([CF_WEAK_SYMBOLS],[ 7936AC_CACHE_CHECK(if $CC supports weak symbols,cf_cv_weak_symbols,[ 7937 7938AC_TRY_COMPILE([ 7939#include <stdio.h>], 7940[ 7941#if defined(__GNUC__) 7942# if defined __USE_ISOC99 7943# define _cat_pragma(exp) _Pragma(#exp) 7944# define _weak_pragma(exp) _cat_pragma(weak name) 7945# else 7946# define _weak_pragma(exp) 7947# endif 7948# define _declare(name) __extension__ extern __typeof__(name) name 7949# define weak_symbol(name) _weak_pragma(name) _declare(name) __attribute__((weak)) 7950#endif 7951 7952weak_symbol(fopen); 7953],[cf_cv_weak_symbols=yes],[cf_cv_weak_symbols=no]) 7954]) 7955])dnl 7956dnl --------------------------------------------------------------------------- 7957dnl CF_WITH_ABI_VERSION version: 3 updated: 2015/06/06 16:10:11 7958dnl ------------------- 7959dnl Allow library's ABI to be overridden. Generally this happens when a 7960dnl packager has incremented the ABI past that used in the original package, 7961dnl and wishes to keep doing this. 7962dnl 7963dnl $1 is the package name, if any, to derive a corresponding {package}_ABI 7964dnl symbol. 7965AC_DEFUN([CF_WITH_ABI_VERSION],[ 7966test -z "$cf_cv_abi_version" && cf_cv_abi_version=0 7967AC_ARG_WITH(abi-version, 7968[ --with-abi-version=XXX override derived ABI version],[ 7969 if test "x$cf_cv_abi_version" != "x$withval" 7970 then 7971 AC_MSG_WARN(overriding ABI version $cf_cv_abi_version to $withval) 7972 case $cf_cv_rel_version in 7973 (5.*) 7974 cf_cv_rel_version=$withval.0 7975 ;; 7976 (6.*) 7977 cf_cv_rel_version=$withval.9 # FIXME: should be 10 as of 6.0 release 7978 ;; 7979 esac 7980 fi 7981 cf_cv_abi_version=$withval]) 7982 CF_NUMBER_SYNTAX($cf_cv_abi_version,ABI version) 7983ifelse($1,,,[ 7984$1_ABI=$cf_cv_abi_version 7985]) 7986])dnl 7987dnl --------------------------------------------------------------------------- 7988dnl CF_WITH_ADA_COMPILER version: 2 updated: 2010/06/26 17:35:58 7989dnl -------------------- 7990dnl Command-line option to specify the Ada95 compiler. 7991AC_DEFUN([CF_WITH_ADA_COMPILER],[ 7992AC_MSG_CHECKING(for ada-compiler) 7993AC_ARG_WITH(ada-compiler, 7994 [ --with-ada-compiler=CMD specify Ada95 compiler command (default gnatmake)], 7995 [cf_ada_compiler=$withval], 7996 [cf_ada_compiler=gnatmake]) 7997AC_SUBST(cf_ada_compiler) 7998AC_MSG_RESULT($cf_ada_compiler) 7999])dnl 8000dnl --------------------------------------------------------------------------- 8001dnl CF_WITH_ADA_INCLUDE version: 2 updated: 2010/06/26 17:35:58 8002dnl ------------------- 8003dnl Command-line option to specify where Ada includes will install. 8004AC_DEFUN([CF_WITH_ADA_INCLUDE],[ 8005AC_MSG_CHECKING(for ada-include) 8006CF_WITH_PATH(ada-include, 8007 [ --with-ada-include=DIR Ada includes are in DIR], 8008 ADA_INCLUDE, 8009 PREFIX/share/ada/adainclude, 8010 [$]prefix/share/ada/adainclude) 8011AC_SUBST(ADA_INCLUDE) 8012AC_MSG_RESULT($ADA_INCLUDE) 8013])dnl 8014dnl --------------------------------------------------------------------------- 8015dnl CF_WITH_ADA_LIBNAME version: 1 updated: 2019/09/07 18:59:41 8016dnl ------------------- 8017dnl CF_WITH_ADA_LIBNAME 8018dnl ------------------- 8019dnl Command-line option to specify how to name the resulting Ada library. 8020dnl $1 = default value 8021AC_DEFUN([CF_WITH_ADA_LIBNAME],[ 8022AC_MSG_CHECKING(for ada-libname) 8023AC_ARG_WITH(ada-libname, 8024 [ --with-ada-libname=XXX override default Ada library-name], 8025 ADA_LIBNAME=[$]withval, 8026 ADA_LIBNAME=$1) 8027case "x$ADA_LIBNAME" in 8028(x|xyes|xno) 8029 ADA_LIBNAME=$1 8030 ;; 8031esac 8032AC_SUBST(ADA_LIBNAME) 8033AC_MSG_RESULT($ADA_LIBNAME) 8034])dnl 8035dnl --------------------------------------------------------------------------- 8036dnl CF_WITH_ADA_OBJECTS version: 2 updated: 2010/06/26 17:35:58 8037dnl ------------------- 8038dnl Command-line option to specify where Ada objects will install. 8039AC_DEFUN([CF_WITH_ADA_OBJECTS],[ 8040AC_MSG_CHECKING(for ada-objects) 8041CF_WITH_PATH(ada-objects, 8042 [ --with-ada-objects=DIR Ada objects are in DIR], 8043 ADA_OBJECTS, 8044 PREFIX/lib/ada/adalib, 8045 [$]prefix/lib/ada/adalib) 8046AC_SUBST(ADA_OBJECTS) 8047AC_MSG_RESULT($ADA_OBJECTS) 8048])dnl 8049dnl --------------------------------------------------------------------------- 8050dnl CF_WITH_ADA_SHAREDLIB version: 5 updated: 2018/07/21 19:10:35 8051dnl --------------------- 8052dnl Command-line option to specify if an Ada95 shared-library should be built, 8053dnl and optionally what its soname should be. 8054AC_DEFUN([CF_WITH_ADA_SHAREDLIB],[ 8055AC_REQUIRE([CF_GNAT_PROJECTS]) 8056AC_MSG_CHECKING(if an Ada95 shared-library should be built) 8057AC_ARG_WITH(ada-sharedlib, 8058 [ --with-ada-sharedlib=soname build shared-library (requires GNAT projects)], 8059 [with_ada_sharedlib=$withval], 8060 [with_ada_sharedlib=no]) 8061AC_MSG_RESULT($with_ada_sharedlib) 8062 8063if test "x$with_ada_sharedlib" != xno 8064then 8065 if test "x$cf_gnat_projects" != xyes 8066 then 8067 AC_MSG_WARN(disabling shared-library since GNAT projects are not supported) 8068 with_ada_sharedlib=no 8069 fi 8070fi 8071 8072ADA_SHAREDLIB='lib$(LIB_NAME).so.1' 8073MAKE_ADA_SHAREDLIB="#" 8074 8075if test "x$with_ada_sharedlib" != xno 8076then 8077 MAKE_ADA_SHAREDLIB= 8078 if test "x$with_ada_sharedlib" != xyes 8079 then 8080 ADA_SHAREDLIB="$with_ada_sharedlib" 8081 fi 8082fi 8083 8084AC_SUBST(ADA_SHAREDLIB) 8085AC_SUBST(MAKE_ADA_SHAREDLIB) 8086])dnl 8087dnl --------------------------------------------------------------------------- 8088dnl CF_WITH_DBMALLOC version: 7 updated: 2010/06/21 17:26:47 8089dnl ---------------- 8090dnl Configure-option for dbmalloc. The optional parameter is used to override 8091dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. 8092AC_DEFUN([CF_WITH_DBMALLOC],[ 8093CF_NO_LEAKS_OPTION(dbmalloc, 8094 [ --with-dbmalloc test: use Conor Cahill's dbmalloc library], 8095 [USE_DBMALLOC]) 8096 8097if test "$with_dbmalloc" = yes ; then 8098 AC_CHECK_HEADER(dbmalloc.h, 8099 [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse([$1],,[],[,$1]))]) 8100fi 8101])dnl 8102dnl --------------------------------------------------------------------------- 8103dnl CF_WITH_DMALLOC version: 7 updated: 2010/06/21 17:26:47 8104dnl --------------- 8105dnl Configure-option for dmalloc. The optional parameter is used to override 8106dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. 8107AC_DEFUN([CF_WITH_DMALLOC],[ 8108CF_NO_LEAKS_OPTION(dmalloc, 8109 [ --with-dmalloc test: use Gray Watson's dmalloc library], 8110 [USE_DMALLOC]) 8111 8112if test "$with_dmalloc" = yes ; then 8113 AC_CHECK_HEADER(dmalloc.h, 8114 [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse([$1],,[],[,$1]))]) 8115fi 8116])dnl 8117dnl --------------------------------------------------------------------------- 8118dnl CF_WITH_EXPORT_SYMS version: 3 updated: 2014/12/20 19:16:08 8119dnl ------------------- 8120dnl Use this with libtool to specify the list of symbols that may be exported. 8121dnl The input file contains one symbol per line; comments work with "#". 8122dnl 8123dnl $1 = basename of the ".sym" file (default $PACKAGE) 8124AC_DEFUN([CF_WITH_EXPORT_SYMS], 8125[ 8126AC_MSG_CHECKING(if exported-symbols file should be used) 8127AC_ARG_WITH(export-syms, 8128 [ --with-export-syms=XXX limit exported symbols using libtool], 8129 [with_export_syms=$withval], 8130 [with_export_syms=no]) 8131if test "x$with_export_syms" = xyes 8132then 8133 with_export_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).sym' 8134 AC_SUBST(PACKAGE) 8135fi 8136AC_MSG_RESULT($with_export_syms) 8137if test "x$with_export_syms" != xno 8138then 8139 EXPORT_SYMS="-export-symbols $with_export_syms" 8140 AC_SUBST(EXPORT_SYMS) 8141fi 8142])dnl 8143dnl --------------------------------------------------------------------------- 8144dnl CF_WITH_GPM version: 10 updated: 2017/04/29 18:32:18 8145dnl ----------- 8146dnl 8147dnl The option parameter (if neither yes/no) is assumed to be the name of 8148dnl the gpm library, e.g., for dynamic loading. 8149AC_DEFUN([CF_WITH_GPM], 8150[ 8151AC_MSG_CHECKING(if you want to link with the GPM mouse library) 8152AC_ARG_WITH(gpm, 8153 [ --with-gpm use Alessandro Rubini's GPM library], 8154 [with_gpm=$withval], 8155 [with_gpm=maybe]) 8156AC_MSG_RESULT($with_gpm) 8157 8158if test "$with_gpm" != no ; then 8159 AC_CHECK_HEADER(gpm.h,[ 8160 AC_DEFINE(HAVE_GPM_H,1,[Define to 1 if we have gpm.h header]) 8161 if test "$with_gpm" != yes && test "$with_gpm" != maybe ; then 8162 CF_VERBOSE(assuming we really have GPM library) 8163 AC_DEFINE(HAVE_LIBGPM,1,[Define to 1 if we have the gpm library]) 8164 with_gpm=yes 8165 else 8166 AC_CHECK_LIB(gpm,Gpm_Open,[with_gpm=yes],[ 8167 if test "$with_gpm" = maybe; then 8168 AC_MSG_WARN(Cannot link with GPM library) 8169 with_gpm=no 8170 else 8171 AC_MSG_ERROR(Cannot link with GPM library) 8172 fi 8173 ]) 8174 fi 8175 ],[ 8176 test "$with_gpm" != maybe && AC_MSG_WARN(Cannot find GPM header) 8177 with_gpm=no 8178 ]) 8179fi 8180]) 8181dnl --------------------------------------------------------------------------- 8182dnl CF_WITH_LIBTOOL version: 35 updated: 2017/08/12 07:58:51 8183dnl --------------- 8184dnl Provide a configure option to incorporate libtool. Define several useful 8185dnl symbols for the makefile rules. 8186dnl 8187dnl The reference to AC_PROG_LIBTOOL does not normally work, since it uses 8188dnl macros from libtool.m4 which is in the aclocal directory of automake. 8189dnl Following is a simple script which turns on the AC_PROG_LIBTOOL macro. 8190dnl But that still does not work properly since the macro is expanded outside 8191dnl the CF_WITH_LIBTOOL macro: 8192dnl 8193dnl #!/bin/sh 8194dnl ACLOCAL=`aclocal --print-ac-dir` 8195dnl if test -z "$ACLOCAL" ; then 8196dnl echo cannot find aclocal directory 8197dnl exit 1 8198dnl elif test ! -f $ACLOCAL/libtool.m4 ; then 8199dnl echo cannot find libtool.m4 file 8200dnl exit 1 8201dnl fi 8202dnl 8203dnl LOCAL=aclocal.m4 8204dnl ORIG=aclocal.m4.orig 8205dnl 8206dnl trap "mv $ORIG $LOCAL" 0 1 2 3 15 8207dnl rm -f $ORIG 8208dnl mv $LOCAL $ORIG 8209dnl 8210dnl # sed the LIBTOOL= assignment to omit the current directory? 8211dnl sed -e 's/^LIBTOOL=.*/LIBTOOL=${LIBTOOL:-libtool}/' $ACLOCAL/libtool.m4 >>$LOCAL 8212dnl cat $ORIG >>$LOCAL 8213dnl 8214dnl autoconf-257 $* 8215dnl 8216AC_DEFUN([CF_WITH_LIBTOOL], 8217[ 8218AC_REQUIRE([CF_DISABLE_LIBTOOL_VERSION]) 8219ifdef([AC_PROG_LIBTOOL],,[ 8220LIBTOOL= 8221]) 8222# common library maintenance symbols that are convenient for libtool scripts: 8223LIB_CREATE='${AR} -cr' 8224LIB_OBJECT='${OBJECTS}' 8225LIB_SUFFIX=.a 8226LIB_PREP="$RANLIB" 8227 8228# symbols used to prop libtool up to enable it to determine what it should be 8229# doing: 8230LIB_CLEAN= 8231LIB_COMPILE= 8232LIB_LINK='${CC}' 8233LIB_INSTALL= 8234LIB_UNINSTALL= 8235 8236AC_MSG_CHECKING(if you want to build libraries with libtool) 8237AC_ARG_WITH(libtool, 8238 [ --with-libtool generate libraries with libtool], 8239 [with_libtool=$withval], 8240 [with_libtool=no]) 8241AC_MSG_RESULT($with_libtool) 8242if test "$with_libtool" != "no"; then 8243ifdef([AC_PROG_LIBTOOL],[ 8244 # missing_content_AC_PROG_LIBTOOL{{ 8245 AC_PROG_LIBTOOL 8246 # missing_content_AC_PROG_LIBTOOL}} 8247],[ 8248 if test "$with_libtool" != "yes" ; then 8249 CF_PATH_SYNTAX(with_libtool) 8250 LIBTOOL=$with_libtool 8251 else 8252 AC_CHECK_TOOLS(LIBTOOL,[libtool glibtool],none) 8253 CF_LIBTOOL_VERSION 8254 if test -z "$cf_cv_libtool_version" && test "$LIBTOOL" = libtool 8255 then 8256 CF_FORGET_TOOL(LIBTOOL) 8257 AC_CHECK_TOOLS(LIBTOOL,[glibtool],none) 8258 CF_LIBTOOL_VERSION 8259 fi 8260 fi 8261 if test -z "$LIBTOOL" ; then 8262 AC_MSG_ERROR(Cannot find libtool) 8263 fi 8264])dnl 8265 LIB_CREATE='${LIBTOOL} --mode=link ${CC} -rpath ${libdir} ${LIBTOOL_VERSION} `cut -f1 ${top_srcdir}/VERSION` ${LIBTOOL_OPTS} ${LT_UNDEF} $(LIBS) -o' 8266 LIB_OBJECT='${OBJECTS:.o=.lo}' 8267 LIB_SUFFIX=.la 8268 LIB_CLEAN='${LIBTOOL} --mode=clean' 8269 LIB_COMPILE='${LIBTOOL} --mode=compile' 8270 LIB_LINK='${LIBTOOL} --mode=link ${CC} ${LIBTOOL_OPTS}' 8271 LIB_INSTALL='${LIBTOOL} --mode=install' 8272 LIB_UNINSTALL='${LIBTOOL} --mode=uninstall' 8273 LIB_PREP=: 8274 8275 CF_CHECK_LIBTOOL_VERSION 8276 8277 # special hack to add -no-undefined (which libtool should do for itself) 8278 LT_UNDEF= 8279 case "$cf_cv_system_name" in 8280 (cygwin*|msys*|mingw32*|os2*|uwin*|aix[[4-7]]) 8281 LT_UNDEF=-no-undefined 8282 ;; 8283 esac 8284 AC_SUBST([LT_UNDEF]) 8285 8286 # special hack to add --tag option for C++ compiler 8287 case $cf_cv_libtool_version in 8288 (1.[[5-9]]*|[[2-9]].[[0-9.a-z]]*) 8289 LIBTOOL_CXX="$LIBTOOL --tag=CXX" 8290 LIBTOOL="$LIBTOOL --tag=CC" 8291 ;; 8292 (*) 8293 LIBTOOL_CXX="$LIBTOOL" 8294 ;; 8295 esac 8296else 8297 LIBTOOL="" 8298 LIBTOOL_CXX="" 8299fi 8300 8301test -z "$LIBTOOL" && ECHO_LT= 8302 8303AC_SUBST(LIBTOOL) 8304AC_SUBST(LIBTOOL_CXX) 8305AC_SUBST(LIBTOOL_OPTS) 8306 8307AC_SUBST(LIB_CREATE) 8308AC_SUBST(LIB_OBJECT) 8309AC_SUBST(LIB_SUFFIX) 8310AC_SUBST(LIB_PREP) 8311 8312AC_SUBST(LIB_CLEAN) 8313AC_SUBST(LIB_COMPILE) 8314AC_SUBST(LIB_LINK) 8315AC_SUBST(LIB_INSTALL) 8316AC_SUBST(LIB_UNINSTALL) 8317 8318])dnl 8319dnl --------------------------------------------------------------------------- 8320dnl CF_WITH_LIBTOOL_OPTS version: 4 updated: 2015/04/17 21:13:04 8321dnl -------------------- 8322dnl Allow user to pass additional libtool options into the library creation 8323dnl and link steps. The main use for this is to do something like 8324dnl ./configure --with-libtool-opts=-static 8325dnl to get the same behavior as automake-flavored 8326dnl ./configure --enable-static 8327AC_DEFUN([CF_WITH_LIBTOOL_OPTS],[ 8328AC_MSG_CHECKING(for additional libtool options) 8329AC_ARG_WITH(libtool-opts, 8330 [ --with-libtool-opts=XXX specify additional libtool options], 8331 [with_libtool_opts=$withval], 8332 [with_libtool_opts=no]) 8333AC_MSG_RESULT($with_libtool_opts) 8334 8335case .$with_libtool_opts in 8336(.yes|.no|.) 8337 ;; 8338(*) 8339 LIBTOOL_OPTS="$LIBTOOL_OPTS $with_libtool_opts" 8340 ;; 8341esac 8342 8343AC_SUBST(LIBTOOL_OPTS) 8344])dnl 8345dnl --------------------------------------------------------------------------- 8346dnl CF_WITH_LIB_PREFIX version: 1 updated: 2012/01/21 19:28:10 8347dnl ------------------ 8348dnl Allow the library-prefix to be overridden. OS/2 EMX originally had no 8349dnl "lib" prefix, e.g., because it used the dll naming convention. 8350dnl 8351dnl $1 = variable to set 8352AC_DEFUN([CF_WITH_LIB_PREFIX], 8353[ 8354AC_MSG_CHECKING(if you want to have a library-prefix) 8355AC_ARG_WITH(lib-prefix, 8356 [ --with-lib-prefix override library-prefix], 8357 [with_lib_prefix=$withval], 8358 [with_lib_prefix=auto]) 8359AC_MSG_RESULT($with_lib_prefix) 8360 8361if test $with_lib_prefix = auto 8362then 8363 CF_LIB_PREFIX($1) 8364elif test $with_lib_prefix = no 8365then 8366 LIB_PREFIX= 8367else 8368 LIB_PREFIX=$with_lib_prefix 8369fi 8370])dnl 8371dnl --------------------------------------------------------------------------- 8372dnl CF_WITH_PATH version: 11 updated: 2012/09/29 15:04:19 8373dnl ------------ 8374dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just 8375dnl defaulting to yes/no. 8376dnl 8377dnl $1 = option name 8378dnl $2 = help-text 8379dnl $3 = environment variable to set 8380dnl $4 = default value, shown in the help-message, must be a constant 8381dnl $5 = default value, if it's an expression & cannot be in the help-message 8382dnl 8383AC_DEFUN([CF_WITH_PATH], 8384[AC_ARG_WITH($1,[$2 ](default: ifelse([$4],,empty,[$4])),, 8385ifelse([$4],,[withval="${$3}"],[withval="${$3:-ifelse([$5],,[$4],[$5])}"]))dnl 8386if ifelse([$5],,true,[test -n "$5"]) ; then 8387CF_PATH_SYNTAX(withval) 8388fi 8389eval $3="$withval" 8390AC_SUBST($3)dnl 8391])dnl 8392dnl --------------------------------------------------------------------------- 8393dnl CF_WITH_PATHLIST version: 10 updated: 2015/04/17 21:13:04 8394dnl ---------------- 8395dnl Process an option specifying a list of colon-separated paths. 8396dnl 8397dnl $1 = option name 8398dnl $2 = help-text 8399dnl $3 = environment variable to set 8400dnl $4 = default value, shown in the help-message, must be a constant 8401dnl $5 = default value, if it's an expression & cannot be in the help-message 8402dnl $6 = flag to tell if we want to define or substitute 8403dnl 8404AC_DEFUN([CF_WITH_PATHLIST],[ 8405AC_REQUIRE([CF_PATHSEP]) 8406AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, 8407ifelse($4,,[withval=${$3}],[withval=${$3:-ifelse($5,,$4,$5)}]))dnl 8408 8409IFS="${IFS:- }"; ac_save_ifs="$IFS"; IFS="${PATH_SEPARATOR}" 8410cf_dst_path= 8411for cf_src_path in $withval 8412do 8413 CF_PATH_SYNTAX(cf_src_path) 8414 test -n "$cf_dst_path" && cf_dst_path="${cf_dst_path}$PATH_SEPARATOR" 8415 cf_dst_path="${cf_dst_path}${cf_src_path}" 8416done 8417IFS="$ac_save_ifs" 8418 8419ifelse($6,define,[ 8420# Strip single quotes from the value, e.g., when it was supplied as a literal 8421# for $4 or $5. 8422case $cf_dst_path in 8423(\'*) 8424 cf_dst_path=`echo $cf_dst_path |sed -e s/\'// -e s/\'\$//` 8425 ;; 8426esac 8427cf_dst_path=`echo "$cf_dst_path" | sed -e 's/\\\\/\\\\\\\\/g'` 8428]) 8429 8430# This may use the prefix/exec_prefix symbols which will only yield "NONE" 8431# so we have to check/work around. We do prefer the result of "eval"... 8432eval cf_dst_eval="$cf_dst_path" 8433case "x$cf_dst_eval" in 8434(xNONE*) 8435 $3=$cf_dst_path 8436 ;; 8437(*) 8438 $3="$cf_dst_eval" 8439 ;; 8440esac 8441AC_SUBST($3)dnl 8442 8443])dnl 8444dnl --------------------------------------------------------------------------- 8445dnl CF_WITH_PATH_PROG version: 1 updated: 2019/06/30 19:44:43 8446dnl ----------------- 8447dnl Check for a given program, like CF_PATH_PROG, but allow override using a 8448dnl "--with-xxx" option. 8449dnl 8450dnl Parameters: 8451dnl $1 = environment variable to set/update 8452dnl $2 = program name 8453dnl $3 = help-text 8454dnl $4 = $PATH 8455AC_DEFUN([CF_WITH_PATH_PROG],[ 8456AC_ARG_WITH($2-path, 8457 [ --with-$2-path=XXX specify path of $2 ifelse($3,,,$3)], 8458 [AC_MSG_CHECKING(for $2 program ifelse($3,,,$3)) 8459 $1=$withval 8460 AC_MSG_RESULT([$]$1) 8461 CF_PATH_SYNTAX($1) 8462 ], 8463 [CF_PATH_PROG($1,$2,,ifelse($4,,,$4)) 8464 if test -z "[$]$1" 8465 then 8466 AC_MSG_WARN(no $2 program found ifelse($3,,,$3)) 8467 fi 8468 ]) 8469]) 8470dnl --------------------------------------------------------------------------- 8471dnl CF_WITH_PCRE2 version: 2 updated: 2018/07/14 16:47:56 8472dnl ------------- 8473dnl Add PCRE2 (Perl-compatible regular expressions v2) to the build if it is 8474dnl available and the user requests it. Assume the application will otherwise 8475dnl use the POSIX interface. 8476dnl 8477dnl TODO allow $withval to specify package location 8478AC_DEFUN([CF_WITH_PCRE2], 8479[ 8480AC_REQUIRE([CF_PKG_CONFIG]) 8481 8482AC_MSG_CHECKING(if you want to use PCRE2 for regular-expressions) 8483AC_ARG_WITH(pcre2, 8484 [ --with-pcre2 use PCRE2 for regular-expressions]) 8485test -z "$with_pcre2" && with_pcre2=no 8486AC_MSG_RESULT($with_pcre2) 8487 8488if test "x$with_pcre2" != xno ; then 8489 CF_TRY_PKG_CONFIG(libpcre2,,[ 8490 CF_TRY_PKG_CONFIG(libpcre,,[ 8491 AC_MSG_ERROR(Cannot find PCRE2 library)])]) 8492 8493 AC_DEFINE(HAVE_LIB_PCRE2,1,[Define to 1 if we can/should compile with the PCRE2 library]) 8494 8495 # if pkgconfig gave no results, look for the libraries directly 8496 case $LIBS in 8497 (*pcre2-posix*|*pcreposix*) 8498 ;; 8499 (*) 8500 AC_CHECK_LIB(pcre2-posix,regcomp,[ 8501 CF_ADD_LIB(pcre2-posix)], 8502 [AC_CHECK_LIB(pcreposix,regcomp,[ 8503 CF_ADD_LIB(pcreposix) 8504 ],[AC_MSG_ERROR(Cannot find PCRE2 POSIX library)])]) 8505 ;; 8506 esac 8507 8508 # either way, check for the library header files 8509 AC_CHECK_HEADERS(pcre2-posix.h pcreposix.h) 8510fi 8511])dnl 8512dnl --------------------------------------------------------------------------- 8513dnl CF_WITH_PKG_CONFIG_LIBDIR version: 10 updated: 2015/08/22 17:10:56 8514dnl ------------------------- 8515dnl Allow the choice of the pkg-config library directory to be overridden. 8516AC_DEFUN([CF_WITH_PKG_CONFIG_LIBDIR],[ 8517 8518case $PKG_CONFIG in 8519(no|none|yes) 8520 AC_MSG_CHECKING(for pkg-config library directory) 8521 ;; 8522(*) 8523 AC_MSG_CHECKING(for $PKG_CONFIG library directory) 8524 ;; 8525esac 8526 8527PKG_CONFIG_LIBDIR=no 8528AC_ARG_WITH(pkg-config-libdir, 8529 [ --with-pkg-config-libdir=XXX use given directory for installing pc-files], 8530 [PKG_CONFIG_LIBDIR=$withval], 8531 [test "x$PKG_CONFIG" != xnone && PKG_CONFIG_LIBDIR=yes]) 8532 8533case x$PKG_CONFIG_LIBDIR in 8534(x/*) 8535 ;; 8536(xyes) 8537 # Look for the library directory using the same prefix as the executable 8538 if test "x$PKG_CONFIG" = xnone 8539 then 8540 cf_path=$prefix 8541 else 8542 cf_path=`echo "$PKG_CONFIG" | sed -e 's,/[[^/]]*/[[^/]]*$,,'` 8543 fi 8544 8545 # If you don't like using the default architecture, you have to specify the 8546 # intended library directory and corresponding compiler/linker options. 8547 # 8548 # This case allows for Debian's 2014-flavor of multiarch, along with the 8549 # most common variations before that point. Some other variants spell the 8550 # directory differently, e.g., "pkg-config", and put it in unusual places. 8551 # pkg-config has always been poorly standardized, which is ironic... 8552 case x`(arch) 2>/dev/null` in 8553 (*64) 8554 cf_search_path="\ 8555 $cf_path/lib/*64-linux-gnu \ 8556 $cf_path/share \ 8557 $cf_path/lib64 \ 8558 $cf_path/lib32 \ 8559 $cf_path/lib" 8560 ;; 8561 (*) 8562 cf_search_path="\ 8563 $cf_path/lib/*-linux-gnu \ 8564 $cf_path/share \ 8565 $cf_path/lib32 \ 8566 $cf_path/lib \ 8567 $cf_path/libdata" 8568 ;; 8569 esac 8570 8571 CF_VERBOSE(list...) 8572 for cf_config in $cf_search_path 8573 do 8574 CF_VERBOSE(checking $cf_config/pkgconfig) 8575 if test -d $cf_config/pkgconfig 8576 then 8577 PKG_CONFIG_LIBDIR=$cf_config/pkgconfig 8578 AC_MSG_CHECKING(done) 8579 break 8580 fi 8581 done 8582 ;; 8583(*) 8584 ;; 8585esac 8586 8587if test "x$PKG_CONFIG_LIBDIR" != xno ; then 8588 AC_MSG_RESULT($PKG_CONFIG_LIBDIR) 8589fi 8590 8591AC_SUBST(PKG_CONFIG_LIBDIR) 8592])dnl 8593dnl --------------------------------------------------------------------------- 8594dnl CF_WITH_PTHREAD version: 7 updated: 2015/04/18 08:56:57 8595dnl --------------- 8596dnl Check for POSIX thread library. 8597AC_DEFUN([CF_WITH_PTHREAD], 8598[ 8599AC_MSG_CHECKING(if you want to link with the pthread library) 8600AC_ARG_WITH(pthread, 8601 [ --with-pthread use POSIX thread library], 8602 [with_pthread=$withval], 8603 [with_pthread=no]) 8604AC_MSG_RESULT($with_pthread) 8605 8606if test "$with_pthread" != no ; then 8607 AC_CHECK_HEADER(pthread.h,[ 8608 AC_DEFINE(HAVE_PTHREADS_H,1,[Define to 1 if we have pthreads.h header]) 8609 8610 for cf_lib_pthread in pthread c_r 8611 do 8612 AC_MSG_CHECKING(if we can link with the $cf_lib_pthread library) 8613 cf_save_LIBS="$LIBS" 8614 CF_ADD_LIB($cf_lib_pthread) 8615 AC_TRY_LINK([ 8616#include <pthread.h> 8617],[ 8618 int rc = pthread_create(0,0,0,0); 8619 int r2 = pthread_mutexattr_settype(0, 0); 8620],[with_pthread=yes],[with_pthread=no]) 8621 LIBS="$cf_save_LIBS" 8622 AC_MSG_RESULT($with_pthread) 8623 test "$with_pthread" = yes && break 8624 done 8625 8626 if test "$with_pthread" = yes ; then 8627 CF_ADD_LIB($cf_lib_pthread) 8628 AC_DEFINE(HAVE_LIBPTHREADS,1,[Define to 1 if we have pthreads library]) 8629 else 8630 AC_MSG_ERROR(Cannot link with pthread library) 8631 fi 8632 ]) 8633fi 8634]) 8635dnl --------------------------------------------------------------------------- 8636dnl CF_WITH_REL_VERSION version: 1 updated: 2003/09/20 18:12:49 8637dnl ------------------- 8638dnl Allow library's release-version to be overridden. Generally this happens when a 8639dnl packager has incremented the release-version past that used in the original package, 8640dnl and wishes to keep doing this. 8641dnl 8642dnl $1 is the package name, if any, to derive corresponding {package}_MAJOR 8643dnl and {package}_MINOR symbols 8644dnl symbol. 8645AC_DEFUN([CF_WITH_REL_VERSION],[ 8646test -z "$cf_cv_rel_version" && cf_cv_rel_version=0.0 8647AC_ARG_WITH(rel-version, 8648[ --with-rel-version=XXX override derived release version], 8649[AC_MSG_WARN(overriding release version $cf_cv_rel_version to $withval) 8650 cf_cv_rel_version=$withval]) 8651ifelse($1,,[ 8652 CF_NUMBER_SYNTAX($cf_cv_rel_version,Release version) 8653],[ 8654 $1_MAJOR=`echo "$cf_cv_rel_version" | sed -e 's/\..*//'` 8655 $1_MINOR=`echo "$cf_cv_rel_version" | sed -e 's/^[[^.]]*//' -e 's/^\.//' -e 's/\..*//'` 8656 CF_NUMBER_SYNTAX([$]$1_MAJOR,Release major-version) 8657 CF_NUMBER_SYNTAX([$]$1_MINOR,Release minor-version) 8658]) 8659])dnl 8660dnl --------------------------------------------------------------------------- 8661dnl CF_WITH_SYSMOUSE version: 3 updated: 2012/10/06 17:56:13 8662dnl ---------------- 8663dnl If we can compile with sysmouse, make it available unless it is not wanted. 8664AC_DEFUN([CF_WITH_SYSMOUSE],[ 8665# not everyone has "test -c" 8666if test -c /dev/sysmouse 2>/dev/null ; then 8667AC_MSG_CHECKING(if you want to use sysmouse) 8668AC_ARG_WITH(sysmouse, 8669 [ --with-sysmouse use sysmouse (FreeBSD console)], 8670 [cf_with_sysmouse=$withval], 8671 [cf_with_sysmouse=maybe]) 8672 if test "$cf_with_sysmouse" != no ; then 8673 AC_TRY_COMPILE([ 8674#include <osreldate.h> 8675#if (__FreeBSD_version >= 400017) 8676#include <sys/consio.h> 8677#include <sys/fbio.h> 8678#else 8679#include <machine/console.h> 8680#endif 8681],[ 8682 struct mouse_info the_mouse; 8683 ioctl(0, CONS_MOUSECTL, &the_mouse); 8684],[cf_with_sysmouse=yes],[cf_with_sysmouse=no]) 8685 fi 8686AC_MSG_RESULT($cf_with_sysmouse) 8687test "$cf_with_sysmouse" = yes && AC_DEFINE(USE_SYSMOUSE,1,[Define to 1 if we can/should use the sysmouse interface]) 8688fi 8689])dnl 8690dnl --------------------------------------------------------------------------- 8691dnl CF_WITH_SYSTYPE version: 1 updated: 2013/01/26 16:26:12 8692dnl --------------- 8693dnl For testing, override the derived host system-type which is used to decide 8694dnl things such as the linker commands used to build shared libraries. This is 8695dnl normally chosen automatically based on the type of system which you are 8696dnl building on. We use it for testing the configure script. 8697dnl 8698dnl This is different from the --host option: it is used only for testing parts 8699dnl of the configure script which would not be reachable with --host since that 8700dnl relies on the build environment being real, rather than mocked up. 8701AC_DEFUN([CF_WITH_SYSTYPE],[ 8702CF_CHECK_CACHE([AC_CANONICAL_SYSTEM]) 8703AC_ARG_WITH(system-type, 8704 [ --with-system-type=XXX test: override derived host system-type], 8705[AC_MSG_WARN(overriding system type to $withval) 8706 cf_cv_system_name=$withval 8707 host_os=$withval 8708]) 8709])dnl 8710dnl --------------------------------------------------------------------------- 8711dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21 8712dnl ---------------- 8713AC_DEFUN([CF_WITH_VALGRIND],[ 8714CF_NO_LEAKS_OPTION(valgrind, 8715 [ --with-valgrind test: use valgrind], 8716 [USE_VALGRIND]) 8717])dnl 8718dnl --------------------------------------------------------------------------- 8719dnl CF_WITH_VERSIONED_SYMS version: 8 updated: 2018/10/20 20:24:34 8720dnl ---------------------- 8721dnl Use this when building shared library with ELF, to markup symbols with the 8722dnl version identifier from the given input file. Generally that identifier is 8723dnl the same as the SONAME at which the symbol was first introduced. 8724dnl 8725dnl $1 = basename of the ".map" file (default $PACKAGE) 8726AC_DEFUN([CF_WITH_VERSIONED_SYMS], 8727[ 8728AC_MSG_CHECKING(if versioned-symbols file should be used) 8729AC_ARG_WITH(versioned-syms, 8730 [ --with-versioned-syms=X markup versioned symbols using ld], 8731 [with_versioned_syms=$withval], 8732 [with_versioned_syms=no]) 8733case "x$with_versioned_syms" in 8734(xyes) 8735 with_versioned_syms='${top_srcdir}/package/ifelse($1,,${PACKAGE},[$1]).map' 8736 AC_SUBST(PACKAGE) 8737 ;; 8738(xno) 8739 ;; 8740(x/*) 8741 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms) 8742 ;; 8743(*) 8744 test -f "$with_versioned_syms" || AC_MSG_ERROR(expected a filename: $with_versioned_syms) 8745 with_versioned_syms=`pwd`/"$with_versioned_syms" 8746 ;; 8747esac 8748AC_MSG_RESULT($with_versioned_syms) 8749 8750RESULTING_SYMS= 8751VERSIONED_SYMS= 8752WILDCARD_SYMS= 8753 8754if test "x$with_versioned_syms" != xno 8755then 8756 RESULTING_SYMS=$with_versioned_syms 8757 case "x$MK_SHARED_LIB" in 8758 (*-Wl,*) 8759 VERSIONED_SYMS="-Wl,--version-script,\${RESULTING_SYMS}" 8760 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-Wl,%\\[$]{VERSIONED_SYMS} -Wl,%"` 8761 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 8762 ;; 8763 (*-dy\ *) 8764 VERSIONED_SYMS="-Wl,-M,\${RESULTING_SYMS}" 8765 MK_SHARED_LIB=`echo "$MK_SHARED_LIB" | sed -e "s%-dy%\\[$]{VERSIONED_SYMS} -dy%"` 8766 CF_VERBOSE(MK_SHARED_LIB: $MK_SHARED_LIB) 8767 ;; 8768 (*) 8769 AC_MSG_WARN(this system does not support versioned-symbols) 8770 ;; 8771 esac 8772 8773 # Linux ld can selectively override scope, e.g., of symbols beginning with 8774 # "_" by first declaring some as global, and then using a wildcard to 8775 # declare the others as local. Some other loaders cannot do this. Check 8776 # by constructing a (very) simple shared library and inspecting its 8777 # symbols. 8778 if test "x$VERSIONED_SYMS" != "x" 8779 then 8780 AC_MSG_CHECKING(if wildcards can be used to selectively omit symbols) 8781 WILDCARD_SYMS=no 8782 8783 # make sources 8784 rm -f conftest.* 8785 8786 cat >conftest.ver <<EOF 8787module_1.0 { 8788global: 8789 globalf1; 8790local: 8791 localf1; 8792}; 8793module_2.0 { 8794global: 8795 globalf2; 8796local: 8797 localf2; 8798 _*; 8799} module_1.0; 8800submodule_1.0 { 8801global: 8802 subglobalf1; 8803 _ismissing; 8804local: 8805 sublocalf1; 8806}; 8807submodule_2.0 { 8808global: 8809 subglobalf2; 8810local: 8811 sublocalf2; 8812 _*; 8813} submodule_1.0; 8814EOF 8815 cat >conftest.$ac_ext <<EOF 8816#line __oline__ "configure" 8817int _ismissing(void) { return 1; } 8818int _localf1(void) { return 1; } 8819int _localf2(void) { return 2; } 8820int globalf1(void) { return 1; } 8821int globalf2(void) { return 2; } 8822int _sublocalf1(void) { return 1; } 8823int _sublocalf2(void) { return 2; } 8824int subglobalf1(void) { return 1; } 8825int subglobalf2(void) { return 2; } 8826EOF 8827 cat >conftest.mk <<EOF 8828CC=${CC} 8829CFLAGS=${CFLAGS} 8830CPPFLAGS=${CPPFLAGS} 8831LDFLAGS=${LDFLAGS} 8832LIBS=${LIBS} 8833VERSIONED_SYMS=${VERSIONED_SYMS} 8834RESULTING_SYMS=conftest.ver 8835MK_SHARED_LIB=${MK_SHARED_LIB} 8836conftest.so: conftest.$ac_cv_objext 8837 \$(MK_SHARED_LIB) conftest.$ac_cv_objext 8838EOF 8839 8840 # compile source, make library 8841 if make -f conftest.mk 2>&AC_FD_CC >/dev/null 8842 then 8843 # test for missing symbol in either Data or Text section 8844 cf_missing=`nm -P conftest.so 2>&AC_FD_CC |fgrep _ismissing | egrep '[[ ]][[DT]][[ ]]'` 8845 test -n "$cf_missing" && WILDCARD_SYMS=yes 8846 fi 8847 AC_MSG_RESULT($WILDCARD_SYMS) 8848 rm -f conftest.* 8849 fi 8850fi 8851AC_SUBST(RESULTING_SYMS) 8852AC_SUBST(VERSIONED_SYMS) 8853AC_SUBST(WILDCARD_SYMS) 8854])dnl 8855dnl --------------------------------------------------------------------------- 8856dnl CF_WITH_X11_RGB version: 2 updated: 2019/12/31 08:53:54 8857dnl --------------- 8858dnl Handle configure option "--with-x11-rgb", setting these shell 8859dnl variables: 8860dnl 8861dnl $RGB_PATH is the option value, used for finding the X11 rgb file. 8862dnl $no_x11_rgb is a "#" (comment) if "--without-x11-rgb" is given. 8863dnl 8864dnl Most Linux's use this: 8865dnl /usr/share/X11/rgb.txt 8866dnl Debian uses this: 8867dnl /etc/X11/rgb.txt 8868dnl DragonFlyBSD ports uses this: 8869dnl /usr/pkg/lib/X11/rgb.txt 8870dnl FreeBSD ports use these: 8871dnl /usr/local/lib/X11/rgb.txt 8872dnl /usr/local/share/X11/rgb.txt 8873dnl Mandriva has these: 8874dnl /usr/lib/X11/rgb.txt 8875dnl /usr/lib64/X11/rgb.txt 8876dnl NetBSD has these 8877dnl /usr/X11R7/lib/X11/rgb.txt 8878dnl OpenSolaris uses 8879dnl 32-bit: 8880dnl /usr/X11/etc/X11/rgb.txt 8881dnl /usr/X11/share/X11/rgb.txt 8882dnl /usr/X11/lib/X11/rgb.txt 8883dnl OSX uses 8884dnl /opt/local/share/X11/rgb.txt (MacPorts) 8885dnl /opt/X11/share/X11/rgb.txt (non-ports) 8886dnl 64-bit: 8887dnl /usr/X11/etc/X11/rgb.txt 8888dnl /usr/X11/share/X11/rgb.txt (perhaps) 8889dnl /usr/X11/lib/amd64/X11/rgb.txt 8890dnl Solaris10 uses (in this order): 8891dnl /usr/openwin/lib/X11/rgb.txt 8892dnl /usr/X11/lib/X11/rgb.txt 8893AC_DEFUN([CF_WITH_X11_RGB],[ 8894AC_MSG_CHECKING(for X11 rgb file) 8895AC_ARG_WITH(x11-rgb, 8896 [ --with-x11-rgb=FILE file containing X11 rgb information (EPREFIX/lib/X11/rgb.txt)], 8897 [RGB_PATH=$withval], 8898 [RGB_PATH=auto]) 8899 8900if test "x[$]RGB_PATH" = xauto 8901then 8902 RGB_PATH='${exec_prefix}/lib/X11/rgb.txt' 8903 for cf_path in \ 8904 /opt/local/share/X11/rgb.txt \ 8905 /opt/X11/share/X11/rgb.txt \ 8906 /usr/share/X11/rgb.txt \ 8907 /usr/X11/share/X11/rgb.txt \ 8908 /usr/X11/lib/X11/rgb.txt \ 8909 /usr/lib/X11/rgb.txt \ 8910 /etc/X11/rgb.txt \ 8911 /usr/pkg/lib/X11/rgb.txt \ 8912 /usr/X11R7/lib/X11/rgb.txt \ 8913 /usr/X11R6/lib/X11/rgb.txt \ 8914 /usr/X11R5/lib/X11/rgb.txt \ 8915 /usr/X11R4/lib/X11/rgb.txt \ 8916 /usr/local/lib/X11/rgb.txt \ 8917 /usr/local/share/X11/rgb.txt \ 8918 /usr/lib64/X11/rgb.txt 8919 do 8920 if test -f "$cf_path" ; then 8921 RGB_PATH="$cf_path" 8922 break 8923 fi 8924 done 8925else 8926 cf_path=$RGB_PATH 8927 CF_PATH_SYNTAX(cf_path) 8928fi 8929 8930AC_MSG_RESULT($RGB_PATH) 8931AC_SUBST(RGB_PATH) 8932AC_DEFINE_UNQUOTED(RGB_PATH,"$cf_path",[Define to the full pathname of rgb.txt]) 8933 8934no_x11_rgb= 8935if test "$RGB_PATH" = no 8936then 8937 no_x11_rgb="#" 8938fi 8939AC_SUBST(no_x11_rgb) 8940])dnl 8941dnl --------------------------------------------------------------------------- 8942dnl CF_XOPEN_SOURCE version: 55 updated: 2018/12/31 20:46:17 8943dnl --------------- 8944dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, 8945dnl or adapt to the vendor's definitions to get equivalent functionality, 8946dnl without losing the common non-POSIX features. 8947dnl 8948dnl Parameters: 8949dnl $1 is the nominal value for _XOPEN_SOURCE 8950dnl $2 is the nominal value for _POSIX_C_SOURCE 8951AC_DEFUN([CF_XOPEN_SOURCE],[ 8952AC_REQUIRE([AC_CANONICAL_HOST]) 8953AC_REQUIRE([CF_POSIX_VISIBLE]) 8954 8955if test "$cf_cv_posix_visible" = no; then 8956 8957cf_XOPEN_SOURCE=ifelse([$1],,500,[$1]) 8958cf_POSIX_C_SOURCE=ifelse([$2],,199506L,[$2]) 8959cf_xopen_source= 8960 8961case $host_os in 8962(aix[[4-7]]*) 8963 cf_xopen_source="-D_ALL_SOURCE" 8964 ;; 8965(msys) 8966 cf_XOPEN_SOURCE=600 8967 ;; 8968(darwin[[0-8]].*) 8969 cf_xopen_source="-D_APPLE_C_SOURCE" 8970 ;; 8971(darwin*) 8972 cf_xopen_source="-D_DARWIN_C_SOURCE" 8973 cf_XOPEN_SOURCE= 8974 ;; 8975(freebsd*|dragonfly*|midnightbsd*) 8976 # 5.x headers associate 8977 # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L 8978 # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L 8979 cf_POSIX_C_SOURCE=200112L 8980 cf_XOPEN_SOURCE=600 8981 cf_xopen_source="-D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" 8982 ;; 8983(hpux11*) 8984 cf_xopen_source="-D_HPUX_SOURCE -D_XOPEN_SOURCE=500" 8985 ;; 8986(hpux*) 8987 cf_xopen_source="-D_HPUX_SOURCE" 8988 ;; 8989(irix[[56]].*) 8990 cf_xopen_source="-D_SGI_SOURCE" 8991 cf_XOPEN_SOURCE= 8992 ;; 8993(linux*|uclinux*|gnu*|mint*|k*bsd*-gnu|cygwin) 8994 CF_GNU_SOURCE($cf_XOPEN_SOURCE) 8995 ;; 8996(minix*) 8997 cf_xopen_source="-D_NETBSD_SOURCE" # POSIX.1-2001 features are ifdef'd with this... 8998 ;; 8999(mirbsd*) 9000 # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks <sys/select.h> and other headers which use u_int / u_short types 9001 cf_XOPEN_SOURCE= 9002 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) 9003 ;; 9004(netbsd*) 9005 cf_xopen_source="-D_NETBSD_SOURCE" # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw 9006 ;; 9007(openbsd[[4-9]]*) 9008 # setting _XOPEN_SOURCE lower than 500 breaks g++ compile with wchar.h, needed for ncursesw 9009 cf_xopen_source="-D_BSD_SOURCE" 9010 cf_XOPEN_SOURCE=600 9011 ;; 9012(openbsd*) 9013 # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw 9014 ;; 9015(osf[[45]]*) 9016 cf_xopen_source="-D_OSF_SOURCE" 9017 ;; 9018(nto-qnx*) 9019 cf_xopen_source="-D_QNX_SOURCE" 9020 ;; 9021(sco*) 9022 # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer 9023 ;; 9024(solaris2.*) 9025 cf_xopen_source="-D__EXTENSIONS__" 9026 cf_cv_xopen_source=broken 9027 ;; 9028(sysv4.2uw2.*) # Novell/SCO UnixWare 2.x (tested on 2.1.2) 9029 cf_XOPEN_SOURCE= 9030 cf_POSIX_C_SOURCE= 9031 ;; 9032(*) 9033 CF_TRY_XOPEN_SOURCE 9034 CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) 9035 ;; 9036esac 9037 9038if test -n "$cf_xopen_source" ; then 9039 CF_ADD_CFLAGS($cf_xopen_source,true) 9040fi 9041 9042dnl In anything but the default case, we may have system-specific setting 9043dnl which is still not guaranteed to provide all of the entrypoints that 9044dnl _XOPEN_SOURCE would yield. 9045if test -n "$cf_XOPEN_SOURCE" && test -z "$cf_cv_xopen_source" ; then 9046 AC_MSG_CHECKING(if _XOPEN_SOURCE really is set) 9047 AC_TRY_COMPILE([#include <stdlib.h>],[ 9048#ifndef _XOPEN_SOURCE 9049make an error 9050#endif], 9051 [cf_XOPEN_SOURCE_set=yes], 9052 [cf_XOPEN_SOURCE_set=no]) 9053 AC_MSG_RESULT($cf_XOPEN_SOURCE_set) 9054 if test $cf_XOPEN_SOURCE_set = yes 9055 then 9056 AC_TRY_COMPILE([#include <stdlib.h>],[ 9057#if (_XOPEN_SOURCE - 0) < $cf_XOPEN_SOURCE 9058make an error 9059#endif], 9060 [cf_XOPEN_SOURCE_set_ok=yes], 9061 [cf_XOPEN_SOURCE_set_ok=no]) 9062 if test $cf_XOPEN_SOURCE_set_ok = no 9063 then 9064 AC_MSG_WARN(_XOPEN_SOURCE is lower than requested) 9065 fi 9066 else 9067 CF_TRY_XOPEN_SOURCE 9068 fi 9069fi 9070fi # cf_cv_posix_visible 9071]) 9072