1dnl Copyright (c) 1995, 1996, 1997, 1998 2dnl The Regents of the University of California. All rights reserved. 3dnl 4dnl Redistribution and use in source and binary forms, with or without 5dnl modification, are permitted provided that: (1) source code distributions 6dnl retain the above copyright notice and this paragraph in its entirety, (2) 7dnl distributions including binary code include the above copyright notice and 8dnl this paragraph in its entirety in the documentation or other materials 9dnl provided with the distribution, and (3) all advertising materials mentioning 10dnl features or use of this software display the following acknowledgement: 11dnl ``This product includes software developed by the University of California, 12dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of 13dnl the University nor the names of its contributors may be used to endorse 14dnl or promote products derived from this software without specific prior 15dnl written permission. 16dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 17dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 18dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 19dnl 20dnl LBL autoconf macros 21dnl 22 23dnl 24dnl Do whatever AC_LBL_C_INIT work is necessary before using AC_PROG_CC. 25dnl 26dnl It appears that newer versions of autoconf (2.64 and later) will, 27dnl if you use AC_TRY_COMPILE in a macro, stick AC_PROG_CC at the 28dnl beginning of the macro, even if the macro itself calls AC_PROG_CC. 29dnl See the "Prerequisite Macros" and "Expanded Before Required" sections 30dnl in the Autoconf documentation. 31dnl 32dnl This causes a steaming heap of fail in our case, as we were, in 33dnl AC_LBL_C_INIT, doing the tests we now do in AC_LBL_C_INIT_BEFORE_CC, 34dnl calling AC_PROG_CC, and then doing the tests we now do in 35dnl AC_LBL_C_INIT. Now, we run AC_LBL_C_INIT_BEFORE_CC, AC_PROG_CC, 36dnl and AC_LBL_C_INIT at the top level. 37dnl 38AC_DEFUN(AC_LBL_C_INIT_BEFORE_CC, 39[ 40 AC_BEFORE([$0], [AC_LBL_C_INIT]) 41 AC_BEFORE([$0], [AC_PROG_CC]) 42 AC_BEFORE([$0], [AC_LBL_FIXINCLUDES]) 43 AC_BEFORE([$0], [AC_LBL_DEVEL]) 44 AC_ARG_WITH(gcc, [ --without-gcc don't use gcc]) 45 $1="" 46 if test "${srcdir}" != "." ; then 47 $1="-I\$(srcdir)" 48 fi 49 if test "${CFLAGS+set}" = set; then 50 LBL_CFLAGS="$CFLAGS" 51 fi 52 if test -z "$CC" ; then 53 case "$host_os" in 54 55 bsdi*) 56 AC_CHECK_PROG(SHLICC2, shlicc2, yes, no) 57 if test $SHLICC2 = yes ; then 58 CC=shlicc2 59 export CC 60 fi 61 ;; 62 esac 63 fi 64 if test -z "$CC" -a "$with_gcc" = no ; then 65 CC=cc 66 export CC 67 fi 68]) 69 70dnl 71dnl Determine which compiler we're using (cc or gcc) 72dnl If using gcc, determine the version number 73dnl If using cc: 74dnl require that it support ansi prototypes 75dnl use -O (AC_PROG_CC will use -g -O2 on gcc, so we don't need to 76dnl do that ourselves for gcc) 77dnl add -g flags, as appropriate 78dnl explicitly specify /usr/local/include 79dnl 80dnl NOTE WELL: with newer versions of autoconf, "gcc" means any compiler 81dnl that defines __GNUC__, which means clang, for example, counts as "gcc". 82dnl 83dnl usage: 84dnl 85dnl AC_LBL_C_INIT(copt, incls) 86dnl 87dnl results: 88dnl 89dnl $1 (copt set) 90dnl $2 (incls set) 91dnl CC 92dnl LDFLAGS 93dnl LBL_CFLAGS 94dnl 95AC_DEFUN(AC_LBL_C_INIT, 96[ 97 AC_BEFORE([$0], [AC_LBL_FIXINCLUDES]) 98 AC_BEFORE([$0], [AC_LBL_DEVEL]) 99 AC_BEFORE([$0], [AC_LBL_SHLIBS_INIT]) 100 if test "$GCC" = yes ; then 101 # 102 # -Werror forces warnings to be errors. 103 # 104 ac_lbl_cc_force_warning_errors=-Werror 105 106 # 107 # Try to have the compiler default to hiding symbols, 108 # so that only symbols explicitly exported with 109 # PCAP_API will be visible outside (shared) libraries. 110 # 111 AC_LBL_CHECK_COMPILER_OPT($1, -fvisibility=hidden) 112 else 113 $2="$$2 -I/usr/local/include" 114 LDFLAGS="$LDFLAGS -L/usr/local/lib" 115 116 case "$host_os" in 117 118 darwin*) 119 # 120 # This is assumed either to be GCC or clang, both 121 # of which use -Werror to force warnings to be errors. 122 # 123 ac_lbl_cc_force_warning_errors=-Werror 124 125 # 126 # Try to have the compiler default to hiding symbols, 127 # so that only symbols explicitly exported with 128 # PCAP_API will be visible outside (shared) libraries. 129 # 130 AC_LBL_CHECK_COMPILER_OPT($1, -fvisibility=hidden) 131 ;; 132 133 hpux*) 134 # 135 # HP C, which is what we presume we're using, doesn't 136 # exit with a non-zero exit status if we hand it an 137 # invalid -W flag, can't be forced to do so even with 138 # +We, and doesn't handle GCC-style -W flags, so we 139 # don't want to try using GCC-style -W flags. 140 # 141 ac_lbl_cc_dont_try_gcc_dashW=yes 142 ;; 143 144 irix*) 145 # 146 # MIPS C, which is what we presume we're using, doesn't 147 # necessarily exit with a non-zero exit status if we 148 # hand it an invalid -W flag, can't be forced to do 149 # so, and doesn't handle GCC-style -W flags, so we 150 # don't want to try using GCC-style -W flags. 151 # 152 ac_lbl_cc_dont_try_gcc_dashW=yes 153 # 154 # It also, apparently, defaults to "char" being 155 # unsigned, unlike most other C implementations; 156 # I suppose we could say "signed char" whenever 157 # we want to guarantee a signed "char", but let's 158 # just force signed chars. 159 # 160 # -xansi is normally the default, but the 161 # configure script was setting it; perhaps -cckr 162 # was the default in the Old Days. (Then again, 163 # that would probably be for backwards compatibility 164 # in the days when ANSI C was Shiny and New, i.e. 165 # 1989 and the early '90's, so maybe we can just 166 # drop support for those compilers.) 167 # 168 # -g is equivalent to -g2, which turns off 169 # optimization; we choose -g3, which generates 170 # debugging information but doesn't turn off 171 # optimization (even if the optimization would 172 # cause inaccuracies in debugging). 173 # 174 $1="$$1 -xansi -signed -g3" 175 ;; 176 177 osf*) 178 # 179 # Presumed to be DEC OSF/1, Digital UNIX, or 180 # Tru64 UNIX. 181 # 182 # The DEC C compiler, which is what we presume we're 183 # using, doesn't exit with a non-zero exit status if we 184 # hand it an invalid -W flag, can't be forced to do 185 # so, and doesn't handle GCC-style -W flags, so we 186 # don't want to try using GCC-style -W flags. 187 # 188 ac_lbl_cc_dont_try_gcc_dashW=yes 189 # 190 # -g is equivalent to -g2, which turns off 191 # optimization; we choose -g3, which generates 192 # debugging information but doesn't turn off 193 # optimization (even if the optimization would 194 # cause inaccuracies in debugging). 195 # 196 $1="$$1 -g3" 197 ;; 198 199 solaris*) 200 # 201 # Assumed to be Sun C, which requires -errwarn to force 202 # warnings to be treated as errors. 203 # 204 ac_lbl_cc_force_warning_errors=-errwarn 205 206 # 207 # Try to have the compiler default to hiding symbols, 208 # so that only symbols explicitly exported with 209 # PCAP_API will be visible outside (shared) libraries. 210 # 211 AC_LBL_CHECK_COMPILER_OPT($1, -xldscope=hidden) 212 ;; 213 214 ultrix*) 215 AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes) 216 AC_CACHE_VAL(ac_cv_lbl_cc_const_proto, 217 AC_TRY_COMPILE( 218 [#include <sys/types.h>], 219 [struct a { int b; }; 220 void c(const struct a *)], 221 ac_cv_lbl_cc_const_proto=yes, 222 ac_cv_lbl_cc_const_proto=no)) 223 AC_MSG_RESULT($ac_cv_lbl_cc_const_proto) 224 if test $ac_cv_lbl_cc_const_proto = no ; then 225 AC_DEFINE(const,[], 226 [to handle Ultrix compilers that don't support const in prototypes]) 227 fi 228 ;; 229 esac 230 $1="$$1 -O" 231 fi 232]) 233 234dnl 235dnl Save the values of various variables that affect compilation and 236dnl linking, and that we don't ourselves modify persistently; done 237dnl before a test involving compiling or linking is done, so that we 238dnl can restore those variables after the test is done. 239dnl 240AC_DEFUN(AC_LBL_SAVE_CHECK_STATE, 241[ 242 save_CFLAGS="$CFLAGS" 243 save_LIBS="$LIBS" 244 save_LDFLAGS="$LDFLAGS" 245]) 246 247dnl 248dnl Restore the values of variables saved by AC_LBL_SAVE_CHECK_STATE. 249dnl 250AC_DEFUN(AC_LBL_RESTORE_CHECK_STATE, 251[ 252 CFLAGS="$save_CFLAGS" 253 LIBS="$save_LIBS" 254 LDFLAGS="$save_LDFLAGS" 255]) 256 257dnl 258dnl Check whether the compiler option specified as the second argument 259dnl is supported by the compiler and, if so, add it to the macro 260dnl specified as the first argument 261dnl 262dnl If a third argument is supplied, treat it as C code to be compiled 263dnl with the flag in question, and the "treat warnings as errors" flag 264dnl set, and don't add the flag to the first argument if the compile 265dnl fails; this is for warning options cause problems that can't be 266dnl worked around. If a third argument is supplied, a fourth argument 267dnl should also be supplied; it's a message describing what the test 268dnl program is checking. 269dnl 270AC_DEFUN(AC_LBL_CHECK_COMPILER_OPT, 271 [ 272 AC_MSG_CHECKING([whether the compiler supports the $2 option]) 273 save_CFLAGS="$CFLAGS" 274 CFLAGS="$CFLAGS $2" 275 # 276 # XXX - yes, this depends on the way AC_LANG_WERROR works, 277 # but no mechanism is provided to turn AC_LANG_WERROR on 278 # *and then turn it back off*, so that we *only* do it when 279 # testing compiler options - 15 years after somebody asked 280 # for it: 281 # 282 # https://autoconf.gnu.narkive.com/gTAVmfKD/how-to-cancel-flags-set-by-ac-lang-werror 283 # 284 save_ac_c_werror_flag="$ac_c_werror_flag" 285 ac_c_werror_flag=yes 286 # 287 # We use AC_LANG_SOURCE() so that we can control the complete 288 # content of the program being compiled. We do not, for example, 289 # want the default "int main()" that AC_LANG_PROGRAM() generates, 290 # as it will generate a warning with -Wold-style-definition, meaning 291 # that we would treat it as not working, as the test will fail if 292 # *any* error output, including a warning due to the flag we're 293 # testing, is generated; see 294 # 295 # https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us 296 # https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us 297 # 298 # This may, as per those two messages, be fixed in autoconf 2.70, 299 # but we only require 2.64 or newer for now. 300 # 301 AC_COMPILE_IFELSE( 302 [AC_LANG_SOURCE([[int main(void) { return 0; }]])], 303 [ 304 AC_MSG_RESULT([yes]) 305 can_add_to_cflags=yes 306 # 307 # The compile supports this; do we have some C code for 308 # which the warning should *not* appear? 309 # We test the fourth argument because the third argument 310 # could contain quotes, breaking the test. 311 # 312 if test "x$4" != "x" 313 then 314 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors" 315 AC_MSG_CHECKING(whether $2 $4) 316 AC_COMPILE_IFELSE( 317 [AC_LANG_SOURCE($3)], 318 [ 319 # 320 # Not a problem. 321 # 322 AC_MSG_RESULT(no) 323 ], 324 [ 325 # 326 # A problem. 327 # 328 AC_MSG_RESULT(yes) 329 can_add_to_cflags=no 330 ]) 331 fi 332 CFLAGS="$save_CFLAGS" 333 if test x"$can_add_to_cflags" = "xyes" 334 then 335 $1="$$1 $2" 336 fi 337 ], 338 [ 339 AC_MSG_RESULT([no]) 340 CFLAGS="$save_CFLAGS" 341 ]) 342 ac_c_werror_flag="$save_ac_c_werror_flag" 343 ]) 344 345dnl 346dnl Check whether the compiler supports an option to generate 347dnl Makefile-style dependency lines 348dnl 349dnl GCC uses -M for this. Non-GCC compilers that support this 350dnl use a variety of flags, including but not limited to -M. 351dnl 352dnl We test whether the flag in question is supported, as older 353dnl versions of compilers might not support it. 354dnl 355dnl We don't try all the possible flags, just in case some flag means 356dnl "generate dependencies" on one compiler but means something else 357dnl on another compiler. 358dnl 359dnl Most compilers that support this send the output to the standard 360dnl output by default. IBM's XLC, however, supports -M but sends 361dnl the output to {sourcefile-basename}.u, and AIX has no /dev/stdout 362dnl to work around that, so we don't bother with XLC. 363dnl 364AC_DEFUN(AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT, 365 [ 366 AC_MSG_CHECKING([whether the compiler supports generating dependencies]) 367 if test "$GCC" = yes ; then 368 # 369 # GCC, or a compiler deemed to be GCC by AC_PROG_CC (even 370 # though it's not); we assume that, in this case, the flag 371 # would be -M. 372 # 373 ac_lbl_dependency_flag="-M" 374 else 375 # 376 # Not GCC or a compiler deemed to be GCC; what platform is 377 # this? (We're assuming that if the compiler isn't GCC 378 # it's the compiler from the vendor of the OS; that won't 379 # necessarily be true for x86 platforms, where it might be 380 # the Intel C compiler.) 381 # 382 case "$host_os" in 383 384 irix*|osf*|darwin*) 385 # 386 # MIPS C for IRIX, DEC C, and clang all use -M. 387 # 388 ac_lbl_dependency_flag="-M" 389 ;; 390 391 solaris*) 392 # 393 # Sun C uses -xM. 394 # 395 ac_lbl_dependency_flag="-xM" 396 ;; 397 398 hpux*) 399 # 400 # HP's older C compilers don't support this. 401 # HP's newer C compilers support this with 402 # either +M or +Make; the older compilers 403 # interpret +M as something completely 404 # different, so we use +Make so we don't 405 # think it works with the older compilers. 406 # 407 ac_lbl_dependency_flag="+Make" 408 ;; 409 410 *) 411 # 412 # Not one of the above; assume no support for 413 # generating dependencies. 414 # 415 ac_lbl_dependency_flag="" 416 ;; 417 esac 418 fi 419 420 # 421 # Is ac_lbl_dependency_flag defined and, if so, does the compiler 422 # complain about it? 423 # 424 # Note: clang doesn't seem to exit with an error status when handed 425 # an unknown non-warning error, even if you pass it 426 # -Werror=unknown-warning-option. However, it always supports 427 # -M, so the fact that this test always succeeds with clang 428 # isn't an issue. 429 # 430 if test ! -z "$ac_lbl_dependency_flag"; then 431 AC_LANG_CONFTEST( 432 [AC_LANG_SOURCE([[int main(void) { return 0; }]])]) 433 if AC_RUN_LOG([eval "$CC $ac_lbl_dependency_flag conftest.c >/dev/null 2>&1"]); then 434 AC_MSG_RESULT([yes, with $ac_lbl_dependency_flag]) 435 DEPENDENCY_CFLAG="$ac_lbl_dependency_flag" 436 MKDEP='${top_srcdir}/mkdep' 437 else 438 AC_MSG_RESULT([no]) 439 # 440 # We can't run mkdep, so have "make depend" do 441 # nothing. 442 # 443 MKDEP='${top_srcdir}/nomkdep' 444 fi 445 rm -rf conftest* 446 else 447 AC_MSG_RESULT([no]) 448 # 449 # We can't run mkdep, so have "make depend" do 450 # nothing. 451 # 452 MKDEP='${top_srcdir}/nomkdep' 453 fi 454 AC_SUBST(DEPENDENCY_CFLAG) 455 AC_SUBST(MKDEP) 456 ]) 457 458dnl 459dnl Determine what options are needed to build a shared library 460dnl 461dnl usage: 462dnl 463dnl AC_LBL_SHLIBS_INIT 464dnl 465dnl results: 466dnl 467dnl V_SHLIB_CCOPT (modified to build position-independent code) 468dnl V_SHLIB_CMD 469dnl V_SHLIB_OPT 470dnl V_SONAME_OPT 471dnl 472AC_DEFUN(AC_LBL_SHLIBS_INIT, 473 [AC_PREREQ(2.50) 474 if test "$GCC" = yes ; then 475 # 476 # On platforms where we build a shared library: 477 # 478 # add options to generate position-independent code, 479 # if necessary (it's the default in AIX and Darwin/macOS); 480 # 481 # define option to set the soname of the shared library, 482 # if the OS supports that; 483 # 484 # add options to specify, at link time, a directory to 485 # add to the run-time search path, if that's necessary. 486 # 487 V_SHLIB_CMD="\$(CC)" 488 V_SHLIB_OPT="-shared" 489 case "$host_os" in 490 491 aix*) 492 ;; 493 494 freebsd*|netbsd*|openbsd*|dragonfly*|linux*|osf*|haiku*|midipix*) 495 # 496 # Platforms where the C compiler is GCC or accepts 497 # compatible command-line arguments, and the linker 498 # is the GNU linker or accepts compatible command-line 499 # arguments. 500 # 501 # Some instruction sets require -fPIC on some 502 # operating systems. Check for them. If you 503 # have a combination that requires it, add it 504 # here. 505 # 506 PIC_OPT=-fpic 507 case "$host_cpu" in 508 509 sparc64*) 510 case "$host_os" in 511 512 freebsd*|openbsd*|linux*) 513 PIC_OPT=-fPIC 514 ;; 515 esac 516 ;; 517 esac 518 V_SHLIB_CCOPT="$V_SHLIB_CCOPT $PIC_OPT" 519 V_SONAME_OPT="-Wl,-soname," 520 ;; 521 522 hpux*) 523 V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic" 524 # 525 # XXX - this assumes GCC is using the HP linker, 526 # rather than the GNU linker, and that the "+h" 527 # option is used on all HP-UX platforms, both .sl 528 # and .so. 529 # 530 V_SONAME_OPT="-Wl,+h," 531 # 532 # By default, directories specified with -L 533 # are added to the run-time search path, so 534 # we don't add them in pcap-config. 535 # 536 ;; 537 538 solaris*) 539 V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic" 540 # 541 # Sun/Oracle's C compiler, GCC, and GCC-compatible 542 # compilers support -Wl,{comma-separated list of options}, 543 # and we use the C compiler, not ld, for all linking, 544 # including linking to produce a shared library. 545 # 546 V_SONAME_OPT="-Wl,-h," 547 ;; 548 esac 549 else 550 # 551 # Set the appropriate compiler flags and, on platforms 552 # where we build a shared library: 553 # 554 # add options to generate position-independent code, 555 # if necessary (it's the default in Darwin/macOS); 556 # 557 # if we generate ".so" shared libraries, define the 558 # appropriate options for building the shared library; 559 # 560 # add options to specify, at link time, a directory to 561 # add to the run-time search path, if that's necessary. 562 # 563 # Note: spaces after V_SONAME_OPT are significant; on 564 # some platforms the soname is passed with a GCC-like 565 # "-Wl,-soname,{soname}" option, with the soname part 566 # of the option, while on other platforms the C compiler 567 # driver takes it as a regular option with the soname 568 # following the option. 569 # 570 case "$host_os" in 571 572 aix*) 573 V_SHLIB_CMD="\$(CC)" 574 V_SHLIB_OPT="-G -bnoentry -bexpall" 575 ;; 576 577 freebsd*|netbsd*|openbsd*|dragonfly*|linux*) 578 # 579 # Platforms where the C compiler is GCC or accepts 580 # compatible command-line arguments, and the linker 581 # is the GNU linker or accepts compatible command-line 582 # arguments. 583 # 584 # XXX - does 64-bit SPARC require -fPIC? 585 # 586 V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic" 587 V_SHLIB_CMD="\$(CC)" 588 V_SHLIB_OPT="-shared" 589 V_SONAME_OPT="-Wl,-soname," 590 ;; 591 592 hpux*) 593 V_SHLIB_CCOPT="$V_SHLIB_CCOPT +z" 594 V_SHLIB_CMD="\$(LD)" 595 V_SHLIB_OPT="-b" 596 V_SONAME_OPT="+h " 597 # 598 # By default, directories specified with -L 599 # are added to the run-time search path, so 600 # we don't add them in pcap-config. 601 # 602 ;; 603 604 osf*) 605 # 606 # Presumed to be DEC OSF/1, Digital UNIX, or 607 # Tru64 UNIX. 608 # 609 V_SHLIB_CMD="\$(CC)" 610 V_SHLIB_OPT="-shared" 611 V_SONAME_OPT="-soname " 612 ;; 613 614 solaris*) 615 V_SHLIB_CCOPT="$V_SHLIB_CCOPT -Kpic" 616 V_SHLIB_CMD="\$(CC)" 617 V_SHLIB_OPT="-G" 618 # 619 # Sun/Oracle's C compiler, GCC, and GCC-compatible 620 # compilers support -Wl,{comma-separated list of options}, 621 # and we use the C compiler, not ld, for all linking, 622 # including linking to produce a shared library. 623 # 624 V_SONAME_OPT="-Wl,-h," 625 ;; 626 esac 627 fi 628]) 629 630# 631# Try compiling a sample of the type of code that appears in 632# gencode.c with "inline", "__inline__", and "__inline". 633# 634# Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough, 635# as it just tests whether a function returning "int" can be inlined; 636# at least some versions of HP's C compiler can inline that, but can't 637# inline a function that returns a struct pointer. 638# 639# Make sure we use the V_CCOPT flags, because some of those might 640# disable inlining. 641# 642AC_DEFUN(AC_LBL_C_INLINE, 643 [AC_MSG_CHECKING(for inline) 644 save_CFLAGS="$CFLAGS" 645 CFLAGS="$V_CCOPT" 646 AC_CACHE_VAL(ac_cv_lbl_inline, [ 647 ac_cv_lbl_inline="" 648 ac_lbl_cc_inline=no 649 for ac_lbl_inline in inline __inline__ __inline 650 do 651 AC_TRY_COMPILE( 652 [#define inline $ac_lbl_inline 653 static inline struct iltest *foo(void); 654 struct iltest { 655 int iltest1; 656 int iltest2; 657 }; 658 659 static inline struct iltest * 660 foo() 661 { 662 static struct iltest xxx; 663 664 return &xxx; 665 }],,ac_lbl_cc_inline=yes,) 666 if test "$ac_lbl_cc_inline" = yes ; then 667 break; 668 fi 669 done 670 if test "$ac_lbl_cc_inline" = yes ; then 671 ac_cv_lbl_inline=$ac_lbl_inline 672 fi]) 673 CFLAGS="$save_CFLAGS" 674 if test ! -z "$ac_cv_lbl_inline" ; then 675 AC_MSG_RESULT($ac_cv_lbl_inline) 676 else 677 AC_MSG_RESULT(no) 678 fi 679 AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])]) 680 681# 682# Test whether we have __atomic_load_n() and __atomic_store_n(). 683# 684# We use AC_TRY_LINK because AC_TRY_COMPILE will succeed, as the 685# compiler will just think that those functions are undefined, 686# and perhaps warn about that, but not fail to compile. 687# 688AC_DEFUN(AC_PCAP_C___ATOMICS, 689 [ 690 AC_MSG_CHECKING(for __atomic_load_n) 691 AC_CACHE_VAL(ac_cv_have___atomic_load_n, 692 AC_TRY_LINK([], 693 [ 694 int i = 17; 695 int j; 696 j = __atomic_load_n(&i, __ATOMIC_RELAXED); 697 ], 698 ac_have___atomic_load_n=yes, 699 ac_have___atomic_load_n=no)) 700 AC_MSG_RESULT($ac_have___atomic_load_n) 701 if test $ac_have___atomic_load_n = yes ; then 702 AC_DEFINE(HAVE___ATOMIC_LOAD_N, 1, 703 [define if __atomic_load_n is supported by the compiler]) 704 fi 705 706 AC_MSG_CHECKING(for __atomic_store_n) 707 AC_CACHE_VAL(ac_cv_have___atomic_store_n, 708 AC_TRY_LINK([], 709 [ 710 int i; 711 __atomic_store_n(&i, 17, __ATOMIC_RELAXED); 712 ], 713 ac_have___atomic_store_n=yes, 714 ac_have___atomic_store_n=no)) 715 AC_MSG_RESULT($ac_have___atomic_store_n) 716 if test $ac_have___atomic_store_n = yes ; then 717 AC_DEFINE(HAVE___ATOMIC_STORE_N, 1, 718 [define if __atomic_store_n is supported by the compiler]) 719 fi]) 720 721dnl 722dnl If using gcc, make sure we have ANSI ioctl definitions 723dnl 724dnl usage: 725dnl 726dnl AC_LBL_FIXINCLUDES 727dnl 728AC_DEFUN(AC_LBL_FIXINCLUDES, 729 [if test "$GCC" = yes ; then 730 AC_MSG_CHECKING(for ANSI ioctl definitions) 731 AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes, 732 AC_TRY_COMPILE( 733 [/* 734 * This generates a "duplicate case value" when fixincludes 735 * has not be run. 736 */ 737# include <sys/types.h> 738# include <sys/time.h> 739# include <sys/ioctl.h> 740# ifdef HAVE_SYS_IOCCOM_H 741# include <sys/ioccom.h> 742# endif], 743 [switch (0) { 744 case _IO('A', 1):; 745 case _IO('B', 1):; 746 }], 747 ac_cv_lbl_gcc_fixincludes=yes, 748 ac_cv_lbl_gcc_fixincludes=no)) 749 AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes) 750 if test $ac_cv_lbl_gcc_fixincludes = no ; then 751 # Don't cache failure 752 unset ac_cv_lbl_gcc_fixincludes 753 AC_MSG_ERROR(see the INSTALL for more info) 754 fi 755 fi]) 756 757dnl 758dnl Checks to see if union wait is used with WEXITSTATUS() 759dnl 760dnl usage: 761dnl 762dnl AC_LBL_UNION_WAIT 763dnl 764dnl results: 765dnl 766dnl DECLWAITSTATUS (defined) 767dnl 768AC_DEFUN(AC_LBL_UNION_WAIT, 769 [AC_MSG_CHECKING(if union wait is used) 770 AC_CACHE_VAL(ac_cv_lbl_union_wait, 771 AC_TRY_COMPILE([ 772# include <sys/types.h> 773# include <sys/wait.h>], 774 [int status; 775 u_int i = WEXITSTATUS(status); 776 u_int j = waitpid(0, &status, 0);], 777 ac_cv_lbl_union_wait=no, 778 ac_cv_lbl_union_wait=yes)) 779 AC_MSG_RESULT($ac_cv_lbl_union_wait) 780 if test $ac_cv_lbl_union_wait = yes ; then 781 AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait]) 782 else 783 AC_DEFINE(DECLWAITSTATUS,int,[type for wait]) 784 fi]) 785 786dnl 787dnl Checks to see if -R is used 788dnl 789dnl usage: 790dnl 791dnl AC_LBL_HAVE_RUN_PATH 792dnl 793dnl results: 794dnl 795dnl ac_cv_lbl_have_run_path (yes or no) 796dnl 797AC_DEFUN(AC_LBL_HAVE_RUN_PATH, 798 [AC_MSG_CHECKING(for ${CC-cc} -R) 799 AC_CACHE_VAL(ac_cv_lbl_have_run_path, 800 [echo 'main(){}' > conftest.c 801 ${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1 802 if test ! -s conftest.out ; then 803 ac_cv_lbl_have_run_path=yes 804 else 805 ac_cv_lbl_have_run_path=no 806 fi 807 rm -f -r conftest*]) 808 AC_MSG_RESULT($ac_cv_lbl_have_run_path) 809 ]) 810 811dnl 812dnl If the file .devel exists: 813dnl Add some warning flags if the compiler supports them 814dnl If an os prototype include exists, symlink os-proto.h to it 815dnl 816dnl usage: 817dnl 818dnl AC_LBL_DEVEL(copt) 819dnl 820dnl results: 821dnl 822dnl $1 (copt appended) 823dnl HAVE_OS_PROTO_H (defined) 824dnl os-proto.h (symlinked) 825dnl 826AC_DEFUN(AC_LBL_DEVEL, 827 [rm -f os-proto.h 828 if test "${LBL_CFLAGS+set}" = set; then 829 $1="$$1 ${LBL_CFLAGS}" 830 fi 831 if test -f .devel ; then 832 # 833 # Skip all the warning option stuff on some compilers. 834 # 835 if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then 836 AC_LBL_CHECK_COMPILER_OPT($1, -W) 837 AC_LBL_CHECK_COMPILER_OPT($1, -Wall) 838 AC_LBL_CHECK_COMPILER_OPT($1, -Wcomma) 839 AC_LBL_CHECK_COMPILER_OPT($1, -Wdocumentation) 840 AC_LBL_CHECK_COMPILER_OPT($1, -Wformat-nonliteral) 841 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-noreturn) 842 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes) 843 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-variable-declarations) 844 AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith) 845 AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-sign) 846 AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow) 847 AC_LBL_CHECK_COMPILER_OPT($1, -Wsign-compare) 848 AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes) 849 AC_LBL_CHECK_COMPILER_OPT($1, -Wunused-parameter) 850 AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused) 851 # Warns about safeguards added in case the enums are 852 # extended 853 # AC_LBL_CHECK_COMPILER_OPT($1, -Wcovered-switch-default) 854 # 855 # This can cause problems with ntohs(), ntohl(), 856 # htons(), and htonl() on some platforms, such 857 # as OpenBSD 6.3 with Clang 5.0.1. I guess the 858 # problem is that the macro that ultimately does 859 # the byte-swapping involves a conditional 860 # expression that tests whether the value being 861 # swapped is a compile-time constant or not, 862 # using __builtin_constant_p(), and, depending 863 # on whether it is, does a compile-time swap or 864 # a run-time swap; perhaps the compiler always 865 # considers one of the two results of the 866 # conditional expressin is never evaluated, 867 # because the conditional check is done at 868 # compile time, and thus always says "that 869 # expression is never executed". 870 # 871 # (Perhaps there should be a way of flagging 872 # an expression that you *want* evaluated at 873 # compile time, so that the compiler 1) warns 874 # if it *can't* be evaluated at compile time 875 # and 2) *doesn't* warn that the true or false 876 # branch will never be reached.) 877 # 878 AC_LBL_CHECK_COMPILER_OPT($1, -Wunreachable-code, 879 [ 880#include <arpa/inet.h> 881 882unsigned short 883testme(unsigned short a) 884{ 885 return ntohs(a); 886} 887 ], 888 [generates warnings from ntohs()]) 889 AC_LBL_CHECK_COMPILER_OPT($1, -Wshorten-64-to-32) 890 fi 891 AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT() 892 # 893 # We used to set -n32 for IRIX 6 when not using GCC (presumed 894 # to mean that we're using MIPS C or MIPSpro C); it specified 895 # the "new" faster 32-bit ABI, introduced in IRIX 6.2. I'm 896 # not sure why that would be something to do *only* with a 897 # .devel file; why should the ABI for which we produce code 898 # depend on .devel? 899 # 900 os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'` 901 name="lbl/os-$os.h" 902 if test -f $name ; then 903 ln -s $name os-proto.h 904 AC_DEFINE(HAVE_OS_PROTO_H, 1, 905 [if there's an os_proto.h for this platform, to use additional prototypes]) 906 else 907 AC_MSG_WARN(can't find $name) 908 fi 909 fi]) 910 911dnl 912dnl Improved version of AC_CHECK_LIB 913dnl 914dnl Thanks to John Hawkinson (jhawk@mit.edu) 915dnl 916dnl usage: 917dnl 918dnl AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [, 919dnl ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]]) 920dnl 921dnl results: 922dnl 923dnl LIBS 924dnl 925dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS" 926dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more. 927dnl We keep it around for reference purposes in case it's ever 928dnl useful in the future. 929dnl 930 931define(AC_LBL_CHECK_LIB, 932[AC_MSG_CHECKING([for $2 in -l$1]) 933dnl Use a cache variable name containing the library, function 934dnl name, and extra libraries to link with, because the test really is 935dnl for library $1 defining function $2, when linked with potinal 936dnl library $5, not just for library $1. Separate tests with the same 937dnl $1 and different $2's or $5's may have different results. 938ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'` 939AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var, 940[ac_save_LIBS="$LIBS" 941LIBS="-l$1 $5 $LIBS" 942AC_TRY_LINK(dnl 943ifelse([$2], [main], , dnl Avoid conflicting decl of main. 944[/* Override any gcc2 internal prototype to avoid an error. */ 945]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus 946extern "C" 947#endif 948])dnl 949[/* We use char because int might match the return type of a gcc2 950 builtin and then its argument prototype would still apply. */ 951char $2(); 952]), 953 [$2()], 954 eval "ac_cv_lbl_lib_$ac_lib_var=yes", 955 eval "ac_cv_lbl_lib_$ac_lib_var=no") 956LIBS="$ac_save_LIBS" 957])dnl 958if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then 959 AC_MSG_RESULT(yes) 960 ifelse([$3], , 961[changequote(, )dnl 962 ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \ 963 -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'` 964changequote([, ])dnl 965 AC_DEFINE_UNQUOTED($ac_tr_lib) 966 LIBS="-l$1 $LIBS" 967], [$3]) 968else 969 AC_MSG_RESULT(no) 970ifelse([$4], , , [$4 971])dnl 972fi 973]) 974 975dnl 976dnl AC_LBL_LIBRARY_NET 977dnl 978dnl This test is for network applications that need socket functions and 979dnl getaddrinfo()/getnameinfo()-ish functions. We now require 980dnl getaddrinfo() and getnameinfo(). We also prefer versions of 981dnl recvmsg() that conform to the Single UNIX Specification, so that we 982dnl can check whether a datagram received with recvmsg() was truncated 983dnl when received due to the buffer being too small. 984dnl 985dnl On most operating systems, they're available in the system library. 986dnl 987dnl Under Solaris, we need to link with libsocket and libnsl to get 988dnl getaddrinfo() and getnameinfo() and, if we have libxnet, we need to 989dnl link with libxnet before libsocket to get a version of recvmsg() 990dnl that conforms to the Single UNIX Specification. 991dnl 992dnl We use getaddrinfo() because we want a portable thread-safe way 993dnl of getting information for a host name or port; there exist _r 994dnl versions of gethostbyname() and getservbyname() on some platforms, 995dnl but not on all platforms. 996dnl 997AC_DEFUN(AC_LBL_LIBRARY_NET, [ 998 # 999 # Most operating systems have getaddrinfo() in the default searched 1000 # libraries (i.e. libc). Check there first. 1001 # 1002 AC_CHECK_FUNC(getaddrinfo,, 1003 [ 1004 # 1005 # Not found in the standard system libraries. 1006 # Try libsocket, which requires libnsl. 1007 # 1008 AC_CHECK_LIB(socket, getaddrinfo, 1009 [ 1010 # 1011 # OK, we found it in libsocket. 1012 # 1013 LIBS="-lsocket -lnsl $LIBS" 1014 ], 1015 [ 1016 # 1017 # Not found in libsocket; test for it in libnetwork, which 1018 # is where it is in Haiku. 1019 # 1020 AC_CHECK_LIB(network, getaddrinfo, 1021 [ 1022 # 1023 # OK, we found it in libnetwork. 1024 # 1025 LIBS="-lnetwork $LIBS" 1026 ], 1027 [ 1028 # 1029 # We didn't find it. 1030 # 1031 AC_MSG_ERROR([getaddrinfo is required, but wasn't found]) 1032 ]) 1033 ], -lnsl) 1034 1035 # 1036 # OK, do we have recvmsg() in libxnet? 1037 # We also link with libsocket and libnsl. 1038 # 1039 AC_CHECK_LIB(xnet, recvmsg, 1040 [ 1041 # 1042 # Yes - link with it as well. 1043 # 1044 LIBS="-lxnet $LIBS" 1045 ], , -lsocket -lnsl) 1046 ]) 1047 # DLPI needs putmsg under HPUX so test for -lstr while we're at it 1048 AC_SEARCH_LIBS(putmsg, str) 1049]) 1050 1051m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) 1052dnl pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- 1053dnl serial 11 (pkg-config-0.29) 1054dnl 1055dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>. 1056dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com> 1057dnl 1058dnl This program is free software; you can redistribute it and/or modify 1059dnl it under the terms of the GNU General Public License as published by 1060dnl the Free Software Foundation; either version 2 of the License, or 1061dnl (at your option) any later version. 1062dnl 1063dnl This program is distributed in the hope that it will be useful, but 1064dnl WITHOUT ANY WARRANTY; without even the implied warranty of 1065dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1066dnl General Public License for more details. 1067dnl 1068dnl You should have received a copy of the GNU General Public License 1069dnl along with this program; if not, write to the Free Software 1070dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 1071dnl 02111-1307, USA. 1072dnl 1073dnl As a special exception to the GNU General Public License, if you 1074dnl distribute this file as part of a program that contains a 1075dnl configuration script generated by Autoconf, you may include it under 1076dnl the same distribution terms that you use for the rest of that 1077dnl program. 1078 1079dnl PKG_PREREQ(MIN-VERSION) 1080dnl ----------------------- 1081dnl Since: 0.29 1082dnl 1083dnl Verify that the version of the pkg-config macros are at least 1084dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's 1085dnl installed version of pkg-config, this checks the developer's version 1086dnl of pkg.m4 when generating configure. 1087dnl 1088dnl To ensure that this macro is defined, also add: 1089dnl m4_ifndef([PKG_PREREQ], 1090dnl [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])]) 1091dnl 1092dnl See the "Since" comment for each macro you use to see what version 1093dnl of the macros you require. 1094m4_defun([PKG_PREREQ], 1095[m4_define([PKG_MACROS_VERSION], [0.29]) 1096m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1, 1097 [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])]) 1098])dnl PKG_PREREQ 1099 1100dnl PKG_PROG_PKG_CONFIG([MIN-VERSION]) 1101dnl ---------------------------------- 1102dnl Since: 0.16 1103dnl 1104dnl Search for the pkg-config tool and set the PKG_CONFIG variable to 1105dnl first found in the path. Checks that the version of pkg-config found 1106dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.17.0 is 1107dnl used since that's the first version where --static was supported. 1108AC_DEFUN([PKG_PROG_PKG_CONFIG], 1109[m4_pattern_forbid([^_?PKG_[A-Z_]+$]) 1110m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$]) 1111m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$]) 1112AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility]) 1113AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path]) 1114AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path]) 1115 1116if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then 1117 AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) 1118fi 1119if test -n "$PKG_CONFIG"; then 1120 _pkg_min_version=m4_default([$1], [0.17.0]) 1121 AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version]) 1122 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then 1123 AC_MSG_RESULT([yes]) 1124 else 1125 AC_MSG_RESULT([no]) 1126 PKG_CONFIG="" 1127 fi 1128fi[]dnl 1129])dnl PKG_PROG_PKG_CONFIG 1130 1131dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) 1132dnl ------------------------------------------------------------------- 1133dnl Since: 0.18 1134dnl 1135dnl Check to see whether a particular set of modules exists. Similar to 1136dnl PKG_CHECK_MODULES(), but does not set variables or print errors. 1137AC_DEFUN([PKG_CHECK_EXISTS], 1138[ 1139if test -n "$PKG_CONFIG" && \ 1140 AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then 1141 m4_default([$2], [:]) 1142m4_ifvaln([$3], [else 1143 $3])dnl 1144fi]) 1145 1146dnl _PKG_CONFIG([VARIABLE], [FLAGS], [MODULES]) 1147dnl --------------------------------------------- 1148dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting 1149dnl pkg_failed based on the result. 1150m4_define([_PKG_CONFIG], 1151[if test -n "$$1"; then 1152 pkg_cv_[]$1="$$1" 1153 elif test -n "$PKG_CONFIG"; then 1154 PKG_CHECK_EXISTS([$3], 1155 [pkg_cv_[]$1=`$PKG_CONFIG $2 "$3" 2>/dev/null` 1156 test "x$?" != "x0" && pkg_failed=yes ], 1157 [pkg_failed=yes]) 1158 else 1159 pkg_failed=untried 1160fi[]dnl 1161])dnl _PKG_CONFIG 1162 1163dnl _PKG_SHORT_ERRORS_SUPPORTED 1164dnl --------------------------- 1165dnl Internal check to see if pkg-config supports short errors. 1166AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED], 1167[ 1168if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then 1169 _pkg_short_errors_supported=yes 1170else 1171 _pkg_short_errors_supported=no 1172fi[]dnl 1173])dnl _PKG_SHORT_ERRORS_SUPPORTED 1174 1175 1176dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], 1177dnl [ACTION-IF-NOT-FOUND]) 1178dnl -------------------------------------------------------------- 1179dnl Since: 0.4.0 1180AC_DEFUN([PKG_CHECK_MODULES], 1181[ 1182AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $2, overriding pkg-config])dnl 1183AC_ARG_VAR([$1][_LIBS], [linker flags for $2, overriding pkg-config])dnl 1184AC_ARG_VAR([$1][_LIBS_STATIC], [static-link linker flags for $2, overriding pkg-config])dnl 1185 1186pkg_failed=no 1187AC_MSG_CHECKING([for $2 with pkg-config]) 1188PKG_CHECK_EXISTS($2, 1189 [ 1190 # 1191 # The package was found, so try to get its C flags and 1192 # libraries. 1193 # 1194 _PKG_CONFIG([$1][_CFLAGS], [--cflags], [$2]) 1195 _PKG_CONFIG([$1][_LIBS], [--libs], [$2]) 1196 _PKG_CONFIG([$1][_LIBS_STATIC], [--libs --static], [$2]) 1197 1198 m4_define([_PKG_TEXT], [ 1199Alternatively, you may set the environment variables $1[]_CFLAGS 1200and $1[]_LIBS to avoid the need to call pkg-config. 1201See the pkg-config man page for more details.]) 1202 1203 if test $pkg_failed = yes; then 1204 # 1205 # That failed - report an error. 1206 # 1207 AC_MSG_RESULT([error]) 1208 _PKG_SHORT_ERRORS_SUPPORTED 1209 if test $_pkg_short_errors_supported = yes; then 1210 $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` 1211 else 1212 $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` 1213 fi 1214 # Put the nasty error message in config.log where it belongs 1215 echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD 1216 1217 m4_default([$4], [AC_MSG_ERROR( 1218[Package requirements ($2) were not met: 1219 1220$$1_PKG_ERRORS 1221 1222Consider adjusting the PKG_CONFIG_PATH environment variable if you 1223installed software in a non-standard prefix. 1224 1225_PKG_TEXT])[]dnl 1226 ]) 1227 elif test $pkg_failed = untried; then 1228 # 1229 # We don't have pkg-config, so it didn't work. 1230 # 1231 AC_MSG_RESULT([not found (pkg-config not found)]) 1232 else 1233 # 1234 # We found the package. 1235 # 1236 $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS 1237 $1[]_LIBS=$pkg_cv_[]$1[]_LIBS 1238 $1[]_LIBS_STATIC=$pkg_cv_[]$1[]_LIBS_STATIC 1239 AC_MSG_RESULT([found]) 1240 $3 1241 fi[]dnl 1242 ], 1243 [ 1244 # 1245 # The package isn't present. 1246 # 1247 AC_MSG_RESULT([not found]) 1248 ]) 1249])dnl PKG_CHECK_MODULES 1250 1251 1252dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], 1253dnl [ACTION-IF-NOT-FOUND]) 1254dnl --------------------------------------------------------------------- 1255dnl Since: 0.29 1256dnl 1257dnl Checks for existence of MODULES and gathers its build flags with 1258dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags 1259dnl and VARIABLE-PREFIX_LIBS from --libs. 1260AC_DEFUN([PKG_CHECK_MODULES_STATIC], 1261[ 1262_save_PKG_CONFIG=$PKG_CONFIG 1263PKG_CONFIG="$PKG_CONFIG --static" 1264PKG_CHECK_MODULES($@) 1265PKG_CONFIG=$_save_PKG_CONFIG[]dnl 1266])dnl PKG_CHECK_MODULES_STATIC 1267 1268 1269dnl PKG_INSTALLDIR([DIRECTORY]) 1270dnl ------------------------- 1271dnl Since: 0.27 1272dnl 1273dnl Substitutes the variable pkgconfigdir as the location where a module 1274dnl should install pkg-config .pc files. By default the directory is 1275dnl $libdir/pkgconfig, but the default can be changed by passing 1276dnl DIRECTORY. The user can override through the --with-pkgconfigdir 1277dnl parameter. 1278AC_DEFUN([PKG_INSTALLDIR], 1279[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])]) 1280m4_pushdef([pkg_description], 1281 [pkg-config installation directory @<:@]pkg_default[@:>@]) 1282AC_ARG_WITH([pkgconfigdir], 1283 [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],, 1284 [with_pkgconfigdir=]pkg_default) 1285AC_SUBST([pkgconfigdir], [$with_pkgconfigdir]) 1286m4_popdef([pkg_default]) 1287m4_popdef([pkg_description]) 1288])dnl PKG_INSTALLDIR 1289 1290 1291dnl PKG_NOARCH_INSTALLDIR([DIRECTORY]) 1292dnl -------------------------------- 1293dnl Since: 0.27 1294dnl 1295dnl Substitutes the variable noarch_pkgconfigdir as the location where a 1296dnl module should install arch-independent pkg-config .pc files. By 1297dnl default the directory is $datadir/pkgconfig, but the default can be 1298dnl changed by passing DIRECTORY. The user can override through the 1299dnl --with-noarch-pkgconfigdir parameter. 1300AC_DEFUN([PKG_NOARCH_INSTALLDIR], 1301[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])]) 1302m4_pushdef([pkg_description], 1303 [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@]) 1304AC_ARG_WITH([noarch-pkgconfigdir], 1305 [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],, 1306 [with_noarch_pkgconfigdir=]pkg_default) 1307AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir]) 1308m4_popdef([pkg_default]) 1309m4_popdef([pkg_description]) 1310])dnl PKG_NOARCH_INSTALLDIR 1311 1312 1313dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE, 1314dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) 1315dnl ------------------------------------------- 1316dnl Since: 0.28 1317dnl 1318dnl Retrieves the value of the pkg-config variable for the given module. 1319AC_DEFUN([PKG_CHECK_VAR], 1320[ 1321AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl 1322 1323_PKG_CONFIG([$1], [--variable="][$3]["], [$2]) 1324AS_VAR_COPY([$1], [pkg_cv_][$1]) 1325 1326AS_VAR_IF([$1], [""], [$5], [$4])dnl 1327])dnl PKG_CHECK_VAR 1328