git.m6w6.name Git - m6w6/ext-http/blob - autoconf/pecl/pecl.m4

   1
   2 yes() {
   3         true
   4 }
   5 no() {
   6         false
   7 }
   8 dnl
   9 dnl PECL_INIT(name)
  10 dnl
  11 dnl Start configuring the PECL extension.
  12 dnl
  13 AC_DEFUN([PECL_INIT], [dnl
  14         m4_define([PECL_NAME],[$1])dnl
  15 ])dnl
  16 dnl
  17 dnl
  18 dnl PECL_VAR(name)
  19 dnl
  20 AC_DEFUN([PECL_VAR], [dnl
  21 AS_TR_CPP([PHP_]PECL_NAME[_$1])dnl
  22 ])dnl
  23 dnl
  24 dnl PECL_CACHE_VAR(name)
  25 dnl
  26 AC_DEFUN([PECL_CACHE_VAR], [dnl
  27 AS_TR_SH([PECL_cv_$1])dnl
  28 ])dnl
  29 dnl
  30 dnl PECL_SAVE_VAR(name)
  31 dnl
  32 AC_DEFUN([PECL_SAVE_VAR], [dnl
  33 AS_TR_SH([PECL_sv_$1])dnl
  34 ])dnl
  35 dnl
  36 dnl PECL_DEFINE(what, to[, desc])
  37 dnl
  38 AC_DEFUN([PECL_DEFINE], [dnl
  39         AC_DEFINE(PECL_VAR([$1]), ifelse([$2],,1,[$2]), ifelse([$3],,[ ],[$3]))
  40 ])dnl
  41 dnl
  42 dnl PECL_DEFINE_UQ(what, to[, desc])
  43 dnl
  44 AC_DEFUN([PECL_DEFINE_UQ], [dnl
  45         AC_DEFINE_UNQUOTED(PECL_VAR([$1]), [$2], ifelse([$3],,[ ],[$3]))
  46 ])dnl
  47 dnl
  48 dnl PECL_DEFINE_SH(what, to[, desc])
  49 dnl
  50 AC_DEFUN([PECL_DEFINE_SH], [dnl
  51         PECL_VAR([$1])=$2
  52         PECL_DEFINE_UQ([$1], [$2], [$3])
  53 ])
  54 dnl
  55 dnl PECL_DEFINE_FN(fn)
  56 dnl
  57 AC_DEFUN([PECL_DEFINE_FN], [
  58         AC_DEFINE(AS_TR_CPP([HAVE_$1]), [1], [ ])
  59 ])
  60 dnl
  61 dnl PECL_SAVE_ENV(var, ns)
  62 dnl
  63 AC_DEFUN([PECL_SAVE_ENV], [
  64         PECL_SAVE_VAR([$2_$1])=[$]$1
  65 ])
  66 dnl
  67 dnl PECL_RESTORE_ENV(var, ns)
  68 dnl
  69 AC_DEFUN([PECL_RESTORE_ENV], [
  70         $1=$PECL_SAVE_VAR([$2_$1])
  71 ])
  72 dnl
  73 dnl PECL_COUNT_CHECKS(incdec)
  74 dnl
  75 AC_DEFUN([PECL_COUNT_CHECKS], [
  76         PECL_VAR([_checks])=$(($PECL_VAR([_checks])$1))
  77 ])
  78 dnl
  79 dnl PECL_EVAL_LIBLINE(libline)
  80 dnl
  81 AC_DEFUN([PECL_EVAL_LIBLINE], [
  82         PECL_SAVE_ENV(ext_shared, pecl)
  83         ext_shared=no
  84         PHP_EVAL_LIBLINE([$1], _pecl_eval_libline_dummy)
  85         PECL_RESTORE_ENV(ext_shared, pecl)
  86 ])
  87 dnl
  88 dnl PECL_PROG_EGREP
  89 dnl
  90 dnl Checks for an egrep. Defines $EGREP.
  91 dnl
  92 AC_DEFUN([PECL_PROG_EGREP], [
  93         ifdef([AC_PROG_EGREP], [
  94                 AC_PROG_EGREP
  95         ], [
  96                 AC_CHECK_PROG(EGREP, egrep, egrep)
  97         ])
  98 ])
  99 dnl
 100 dnl PECL_PROG_AWK
 101 dnl
 102 dnl Checks for an awk. Defines $AWK.
 103 dnl
 104 AC_DEFUN([PECL_PROG_AWK], [
 105         ifdef([AC_PROG_AWK], [
 106                 AC_PROG_AWK
 107         ], [
 108                 AC_CHECK_PROG(AWK, awk, awk)
 109         ])
 110 ])
 111 dnl
 112 dnl PECL_PROG_SED
 113 dnl
 114 dnl Checks for the sed program. Defines $SED.
 115 dnl
 116 AC_DEFUN([PECL_PROG_SED], [
 117         ifdef([AC_PROG_SED], [
 118                 AC_PROG_SED
 119         ], [
 120                 ifdef([LT_AC_PROG_SED], [
 121                         LT_AC_PROG_SED
 122                 ], [
 123                         AC_CHECK_PROG(SED, sed, sed)
 124                 ])
 125         ])
 126 ])
 127 dnl
 128 dnl PECL_PROG_PKGCONFIG
 129 dnl
 130 dnl Checks for pkg-config program and defines $PKG_CONFIG (to false if not found).
 131 dnl
 132 AC_DEFUN([PECL_PROG_PKGCONFIG], [
 133         if test -z "$PKG_CONFIG"; then
 134                 AC_PATH_PROG([PKG_CONFIG], [pkg-config], [false])
 135         fi
 136 ])
 137 dnl
 138 dnl PECL_HAVE_PHP_EXT(name[, code-if-yes[, code-if-not]])
 139 dnl
 140 dnl Check whether ext/$name is enabled in $PHP_EXECUTABLE (PECL build)
 141 dnl or if $PHP_<NAME> is defined to anything else than "no" (in-tree build).
 142 dnl Defines shell var PECL_VAR(HAVE_EXT_<NAME>) to true or false.
 143 dnl
 144 AC_DEFUN([PECL_HAVE_PHP_EXT], [
 145         AC_REQUIRE([PECL_PROG_EGREP])dnl
 146         AC_CACHE_CHECK([whether ext/$1 is enabled], PECL_CACHE_VAR([HAVE_EXT_$1]), [
 147                 PECL_CACHE_VAR([HAVE_EXT_$1])=no
 148                 if test -x "$PHP_EXECUTABLE"; then
 149                         if $PHP_EXECUTABLE -m | $EGREP -q ^$1\$; then
 150                                 PECL_CACHE_VAR([HAVE_EXT_$1])=yes
 151                         fi
 152                 elif test -n "$AS_TR_CPP([PHP_$1])" && test "$AS_TR_CPP([PHP_$1])" != "no"; then
 153                         PECL_CACHE_VAR([HAVE_EXT_$1])=yes
 154                 fi
 155         ])
 156         if $PECL_CACHE_VAR([HAVE_EXT_$1]); then
 157                 PECL_VAR([HAVE_EXT_$1])=true
 158                 PECL_DEFINE([HAVE_EXT_$1])
 159                 $2
 160         else
 161                 PECL_VAR([HAVE_EXT_$1])=false
 162                 $3
 163         fi
 164 ])
 165 dnl
 166 dnl PECL_HAVE_PHP_EXT_HEADER(ext[, header])
 167 dnl
 168 dnl Check where to find a header for ext and add the found dir to $INCLUDES.
 169 dnl If header is not specified php_<ext>.h is assumed.
 170 dnl Defines shell var PHP_<PECL_NAME>_EXT_<EXT>_INCDIR to the found dir.
 171 dnl Defines PHP_<PECL_NAME>_HAVE_<HEADER> to the found path.
 172 dnl
 173 AC_DEFUN([PECL_HAVE_PHP_EXT_HEADER], [dnl
 174         AC_REQUIRE([PECL_PROG_SED])dnl
 175         m4_define([EXT_HEADER], ifelse([$2],,php_$1.h,[$2]))dnl
 176         AC_CACHE_CHECK([for EXT_HEADER of ext/$1], PECL_CACHE_VAR([EXT_$1]_INCDIR), [
 177                 for i in $(printf "%s" "$INCLUDES" | $SED -e's/-I//g') $abs_srcdir ../$1; do
 178                         if test -d $i; then
 179                                 for j in $i/EXT_HEADER $i/ext/$1/EXT_HEADER; do
 180                                         if test -f $j; then
 181                                                 PECL_CACHE_VAR([EXT_$1]_INCDIR)=$(dirname "$j")
 182                                                 break
 183                                         fi
 184                                 done
 185                         fi
 186                 done
 187         ])
 188         PECL_VAR([EXT_$1]_INCDIR)=$PECL_CACHE_VAR([EXT_$1]_INCDIR)
 189         PHP_ADD_INCLUDE([$PECL_VAR([EXT_$1]_INCDIR)])
 190         PECL_DEFINE_UQ([HAVE_]EXT_HEADER, "$PECL_VAR([EXT_$1]_INCDIR)/EXT_HEADER")
 191 ])
 192 dnl
 193 dnl PECL_HAVE_CONST(header, const[, type=int[, code-if-yes[, code-if-mno]]])
 194 dnl
 195 AC_DEFUN([PECL_HAVE_CONST], [dnl
 196         AC_REQUIRE([PECL_PROG_EGREP])dnl
 197         AC_CACHE_CHECK([for $2 in $1], PECL_CACHE_VAR([HAVE_$1_$2]), [
 198                 AC_TRY_COMPILE([
 199                         #include "$1"
 200                 ], [
 201                         ]ifelse([$3],,int,[$3])[ _c = $2;
 202                         (void) _c;
 203                 ], [
 204                         PECL_CACHE_VAR([HAVE_$1_$2])=yes
 205                 ], [
 206                         PECL_CACHE_VAR([HAVE_$1_$2])=no
 207                 ])
 208         ])
 209         if $PECL_CACHE_VAR([HAVE_$1_$2]); then
 210                 PECL_DEFINE([HAVE_$2])
 211                 $4
 212         else
 213                 ifelse([$5],,:,[$5])
 214         fi
 215 ])
 216 dnl
 217 dnl _PECL_TR_VERSION(version)
 218 dnl
 219 AC_DEFUN([_PECL_TR_VERSION], [dnl
 220 AC_REQUIRE([PECL_PROG_AWK])dnl
 221 $(printf "%s" $1 | $AWK -F "[.]" '{print $[]1*1000000 + $[]2*10000 + $[]3*100 + $[]4}')
 222 ])
 223 dnl
 224 dnl PECL_CHECKED_VERSION(name)
 225 dnl
 226 dnl Shell var name of an already checked version.
 227 dnl
 228 AC_DEFUN([PECL_CHECKED_VERSION], [PECL_VAR([$1][_VERSION])])
 229 dnl
 230 dnl PECL_HAVE_VERSION(name, min-version[, code-if-yes[, code-if-not]])
 231 dnl
 232 dnl Perform a min-version check while in an PECL_CHECK_* block.
 233 dnl Expands AC_MSG_ERROR when code-if-not is empty and the version check fails.
 234 dnl
 235 AC_DEFUN([PECL_HAVE_VERSION], [
 236         aversion=_PECL_TR_VERSION([$PECL_CHECKED_VERSION([$1])])
 237         mversion=_PECL_TR_VERSION([$2])
 238         AC_MSG_CHECKING([whether $1 version $PECL_CHECKED_VERSION([$1]) >= $2])
 239         if test -z "$aversion" || test "$aversion" -lt "$mversion"; then
 240                 ifelse($4,,AC_MSG_ERROR([no]), [
 241                         AC_MSG_RESULT([no])
 242                         $4
 243                 ])
 244         else
 245                 AC_MSG_RESULT([ok])
 246                 $3
 247         fi
 248 ])
 249 dnl
 250 dnl PECL_CHECK_CUSTOM(name, path, header, lib, version)
 251 dnl
 252 AC_DEFUN([PECL_CHECK_CUSTOM], [
 253         PECL_COUNT_CHECKS([+1])
 254         PECL_SAVE_ENV([CPPFLAGS], [$1])
 255         PECL_SAVE_ENV([LDFLAGS], [$1])
 256         PECL_SAVE_ENV([LIBS], [$1])
 257
 258         AC_MSG_CHECKING([for $1])
 259         AC_CACHE_VAL(PECL_CACHE_VAR([$1_prefix]), [
 260                 for path in $2 /usr/local /usr /opt; do
 261                         if test "$path" = "" || test "$path" = "yes" || test "$path" = "no"; then
 262                                 continue
 263                         elif test -f "$path/include/$3"; then
 264                                 PECL_CACHE_VAR([$1_prefix])="$path"
 265                                 break
 266                         fi
 267                 done
 268         ])
 269         if test -n "$PECL_CACHE_VAR([$1_prefix])"; then
 270                 CPPFLAGS="$CPPFLAGS -I$PECL_CACHE_VAR([$1_prefix])/include"
 271                 LDFLAGS="$LDFLAGS -L$PECL_CACHE_VAR([$1_prefix])/$PHP_LIBDIR"
 272                 LIBS="$LIBS -l$4"
 273                 dnl PECL_EVAL_LIBLINE([$LDFLAGS $LIBS])
 274
 275                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_version]), [
 276                         pushd $PECL_CACHE_VAR([$1_prefix]) >/dev/null
 277                         PECL_CACHE_VAR([$1_version])=$5
 278                         popd >/dev/null
 279                 ])
 280                 PECL_CHECKED_VERSION([$1])=$PECL_CACHE_VAR([$1_version])
 281
 282                 if test -n "$PECL_CHECKED_VERSION([$1])"; then
 283                         PECL_VAR([HAVE_$1])=true
 284                         PECL_DEFINE([HAVE_$1])
 285                         PECL_DEFINE_UQ($1[_VERSION], "$PECL_CHECKED_VERSION([$1])")
 286                 else
 287                         PECL_VAR([HAVE_$1])=false
 288                 fi
 289         else
 290                 PECL_VAR([HAVE_$1])=false
 291         fi
 292         AC_MSG_RESULT([${PECL_CHECKED_VERSION([$1]):-no}])
 293 ])
 294 dnl
 295 dnl PECL_CHECK_CONFIG(name, prog-config, version-flag, cppflags-flag, ldflags-flag, libs-flag)
 296 dnl
 297 AC_DEFUN([PECL_CHECK_CONFIG], [
 298         PECL_COUNT_CHECKS([+1])
 299         PECL_SAVE_ENV([CPPFLAGS], [$1])
 300         PECL_SAVE_ENV([LDFLAGS], [$1])
 301         PECL_SAVE_ENV([LIBS], [$1])
 302
 303         AC_MSG_CHECKING([for $1])
 304         ifelse($2, [$PKG_CONFIG $1], [
 305                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_exists]), [
 306                         if $($2 --exists); then
 307                                 PECL_CACHE_VAR([$1_exists])=yes
 308                         else
 309                                 PECL_CACHE_VAR([$1_exists])=no
 310                         fi
 311                 ])
 312                 if $PECL_CACHE_VAR([$1_exists]); then
 313         ])
 314                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_version]), [
 315                         PECL_CACHE_VAR([$1_version])=$($2 $3)
 316                 ])
 317                 PECL_CHECKED_VERSION([$1])=$PECL_CACHE_VAR([$1_version])
 318                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_cppflags]), [
 319                         PECL_CACHE_VAR([$1_cppflags])=$($2 $4)
 320                 ])
 321                 CPPFLAGS="$CPPFLAGS $PECL_CACHE_VAR([$1_cppflags])"
 322                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_ldflags]), [
 323                         PECL_CACHE_VAR([$1_ldflags])=$($2 $5)
 324                 ])
 325                 LDFLAGS="$LDFLAGS $PECL_CACHE_VAR([$1_ldflags])"
 326                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_libs]), [
 327                         PECL_CACHE_VAR([$1_libs])=$($2 $6)
 328                 ])
 329                 LIBS="$LIBS $PECL_CACHE_VAR([$1_libs])"
 330                 dnl PECL_EVAL_LIBLINE([$LDFLAGS $LIBS])
 331         ifelse($2, [$PKG_CONFIG $1], [
 332                 fi
 333         ])
 334
 335         AC_MSG_RESULT([${PECL_CHECKED_VERSION([$1]):-no}])
 336
 337         if test -n "$PECL_CHECKED_VERSION([$1])"; then
 338                 PECL_VAR([HAVE_$1])=true
 339                 PECL_DEFINE([HAVE_$1])
 340                 PECL_DEFINE_UQ([$1_VERSION], "$PECL_CHECKED_VERSION([$1])")
 341         else
 342                 PECL_VAR([HAVE_$1])=false
 343         fi
 344 ])
 345 dnl
 346 dnl PECL_CHECK_PKGCONFIG(pkg[, additional-pkg-config-path])
 347 dnl
 348 AC_DEFUN([PECL_CHECK_PKGCONFIG], [dnl
 349         AC_REQUIRE([PECL_PROG_PKGCONFIG])dnl
 350         ifelse($2,,, [
 351                 PECL_SAVE_VAR(pkgconfig_path)="$PKG_CONFIG_PATH"
 352                 if test -d "$2"; then
 353                         export PKG_CONFIG_PATH="$2/lib/pkgconfig:$PKG_CONFIG_PATH"
 354                 fi
 355         ])
 356         PECL_CHECK_CONFIG([$1], [$PKG_CONFIG $1], [--modversion], [--cflags-only-I], [--libs-only-L], [--libs-only-l])
 357         ifelse($2,,, [
 358                 PKG_CONFIG_PATH="$PECL_SAVE_VAR(pkgconfig_path)"
 359         ])
 360 ])
 361 dnl
 362 dnl PECL_CHECK_DONE(name, success[, incline, libline])
 363 dnl
 364 AC_DEFUN([PECL_CHECK_DONE], [
 365         PECL_COUNT_CHECKS([-1])
 366         success=$2
 367         if $success && test -n "$LDFLAGS$LIBS"; then
 368                 AC_MSG_CHECKING([whether $1 can be linked])
 369                 AC_TRY_LINK([], [], [success=yes], [success=no])
 370                 AC_MSG_RESULT([$success])
 371                 if ! $success; then
 372                         AC_MSG_WARN([$1 was found, but fails to link with:])
 373                         AC_MSG_WARN([    LDFLAGS='$LDFLAGS'])
 374                         AC_MSG_WARN([    LIBS='$LIBS'])
 375                         AC_MSG_WARN([Missing or updated library paths?])
 376                 fi
 377         fi
 378         if $success; then
 379                 _cppflags=$PECL_SAVE_VAR([$1_CPPFLAGS])
 380                 _ldflags=$PECL_SAVE_VAR([$1_LDFLAGS])
 381                 _libs=$PECL_SAVE_VAR([$1_LIBS])
 382                 incline=${CPPFLAGS:${#_cppflags}}
 383                 libline=["${LDFLAGS:${#_ldflags}} ${LIBS:${#_libs}}"]
 384                 PECL_DEFINE([HAVE_$1])
 385         else
 386                 incline=$3
 387                 libline=$4
 388         fi
 389
 390         PECL_RESTORE_ENV([CPPFLAGS], [$1])
 391         PECL_RESTORE_ENV([LDFLAGS], [$1])
 392         PECL_RESTORE_ENV([LIBS], [$1])
 393
 394         PHP_EVAL_INCLINE([$incline])
 395         PHP_EVAL_LIBLINE([$libline], AS_TR_CPP(PECL_NAME[_SHARED_LIBADD]))
 396 ])
 397
 398 dnl
 399 dnl PECL_CHECK_CA([additional-ca-paths,[ additional-ca-bundles]])
 400 dnl
 401 AC_DEFUN([PECL_CHECK_CA], [
 402         AC_CACHE_CHECK([for default CA path], PECL_CACHE_VAR([CAPATH]), [
 403                 PECL_VAR([CAPATH])=
 404                 for ca_path in $1 \
 405                         /etc/ssl/certs \
 406                         /System/Library/OpenSSL
 407                 do
 408                         # check if it's actually a hashed directory
 409                         if test -d "$ca_path" && ls "$ca_path"/@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@@<:@0-9a-f@:>@.0 >/dev/null 2>&1; then
 410                                 PECL_CACHE_VAR([CAPATH])=$ca_path
 411                                 break
 412                         fi
 413                 done
 414         ])
 415         if test -n "$PECL_CACHE_VAR([CAPATH])"; then
 416                 PECL_DEFINE_SH([CAPATH], "$PECL_CACHE_VAR([CAPATH])")
 417         fi
 418
 419         AC_CACHE_CHECK([for default CA info], PECL_CACHE_VAR([CAINFO]), [
 420                 for ca_info in $2 \
 421                         /etc/ssl/{cert,ca-bundle}.pem \
 422                         /{etc,usr/share}/ssl/certs/ca-{bundle,ceritifcates}.crt \
 423                         /etc/{pki/ca-trust,ca-certificates}/extracted/pem/tls-ca-bundle.pem \
 424                         /etc/pki/tls/certs/ca-bundle{,.trust}.crt \
 425                         /usr/local/etc/{,open}ssl/cert.pem \
 426                         /usr/local/share/certs/ca-root-nss.crt \
 427                         /{usr,usr/local,opt}/local/share/curl/curl-ca-bundle.crt
 428                 do
 429                         if test -f "$ca_info"; then
 430                                 PECL_CACHE_VAR([CAINFO])=$ca_info
 431                                 break
 432                         fi
 433                 done
 434         ])
 435         if test -n "$PECL_CACHE_VAR([CAINFO])"; then
 436                 PECL_DEFINE_SH([CAINFO], "$PECL_CACHE_VAR([CAINFO])")
 437         fi
 438 ])