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_PROG_EGREP
  74 dnl
  75 dnl Checks for an egrep. Defines $EGREP.
  76 dnl
  77 AC_DEFUN([PECL_PROG_EGREP], [
  78         ifdef([AC_PROG_EGREP], [
  79                 AC_PROG_EGREP
  80         ], [
  81                 AC_CHECK_PROG(EGREP, egrep, egrep)
  82         ])
  83 ])
  84 dnl
  85 dnl PECL_PROG_AWK
  86 dnl
  87 dnl Checks for an awk. Defines $AWK.
  88 dnl
  89 AC_DEFUN([PECL_PROG_AWK], [
  90         ifdef([AC_PROG_AWK], [
  91                 AC_PROG_AWK
  92         ], [
  93                 AC_CHECK_PROG(AWK, awk, awk)
  94         ])
  95 ])
  96 dnl
  97 dnl PECL_PROG_SED
  98 dnl
  99 dnl Checks for the sed program. Defines $SED.
 100 dnl
 101 AC_DEFUN([PECL_PROG_SED], [
 102         ifdef([AC_PROG_SED], [
 103                 AC_PROG_SED
 104         ], [
 105                 ifdef([LT_AC_PROG_SED], [
 106                         LT_AC_PROG_SED
 107                 ], [
 108                         AC_CHECK_PROG(SED, sed, sed)
 109                 ])
 110         ])
 111 ])
 112 dnl
 113 dnl PECL_PROG_PKGCONFIG
 114 dnl
 115 dnl Checks for pkg-config program and defines $PKG_CONFIG (to false if not found).
 116 dnl
 117 AC_DEFUN([PECL_PROG_PKGCONFIG], [
 118         if test -z "$PKG_CONFIG"; then
 119                 AC_PATH_PROG([PKG_CONFIG], [pkg-config], [false])
 120         fi
 121 ])
 122 dnl
 123 dnl PECL_HAVE_PHP_EXT(name[, code-if-yes[, code-if-not]])
 124 dnl
 125 dnl Check whether ext/$name is enabled in $PHP_EXECUTABLE (PECL build)
 126 dnl or if $PHP_<NAME> is defined to anything else than "no" (in-tree build).
 127 dnl Defines shell var PECL_VAR(HAVE_EXT_<NAME>) to true or false.
 128 dnl
 129 AC_DEFUN([PECL_HAVE_PHP_EXT], [
 130         AC_REQUIRE([PECL_PROG_EGREP])dnl
 131         AC_CACHE_CHECK([whether ext/$1 is enabled], PECL_CACHE_VAR([HAVE_EXT_$1]), [
 132                 PECL_CACHE_VAR([HAVE_EXT_$1])=no
 133                 if test -x "$PHP_EXECUTABLE"; then
 134                         if $PHP_EXECUTABLE -m | $EGREP -q ^$1\$; then
 135                                 PECL_CACHE_VAR([HAVE_EXT_$1])=yes
 136                         fi
 137                 elif test -n "$AS_TR_CPP([PHP_$1])" && test "$AS_TR_CPP([PHP_$1])" != "no"; then
 138                         PECL_CACHE_VAR([HAVE_EXT_$1])=yes
 139                 fi
 140         ])
 141         if $PECL_CACHE_VAR([HAVE_EXT_$1]); then
 142                 PECL_VAR([HAVE_EXT_$1])=true
 143                 PECL_DEFINE([HAVE_EXT_$1])
 144                 $2
 145         else
 146                 PECL_VAR([HAVE_EXT_$1])=false
 147                 $3
 148         fi
 149 ])
 150 dnl
 151 dnl PECL_HAVE_PHP_EXT_HEADER(ext[, header])
 152 dnl
 153 dnl Check where to find a header for ext and add the found dir to $INCLUDES.
 154 dnl If header is not specified php_<ext>.h is assumed.
 155 dnl Defines shell var PHP_<PECL_NAME>_EXT_<EXT>_INCDIR to the found dir.
 156 dnl Defines PHP_<PECL_NAME>_HAVE_<HEADER> to the found path.
 157 dnl
 158 AC_DEFUN([PECL_HAVE_PHP_EXT_HEADER], [dnl
 159         AC_REQUIRE([PECL_PROG_SED])dnl
 160         m4_define([EXT_HEADER], ifelse([$2],,php_$1.h,[$2]))dnl
 161         AC_CACHE_CHECK([for EXT_HEADER of ext/$1], PECL_CACHE_VAR([EXT_$1]_INCDIR), [
 162                 for i in $(printf "%s" "$INCLUDES" | $SED -e's/-I//g') $abs_srcdir ../$1; do
 163                         if test -d $i; then
 164                                 for j in $i/EXT_HEADER $i/ext/$1/EXT_HEADER; do
 165                                         if test -f $j; then
 166                                                 PECL_CACHE_VAR([EXT_$1]_INCDIR)=$(dirname "$j")
 167                                                 break
 168                                         fi
 169                                 done
 170                         fi
 171                 done
 172         ])
 173         PECL_VAR([EXT_$1]_INCDIR)=$PECL_CACHE_VAR([EXT_$1]_INCDIR)
 174         PHP_ADD_INCLUDE([$PECL_VAR([EXT_$1]_INCDIR)])
 175         PECL_DEFINE_UQ([HAVE_]EXT_HEADER, "$PECL_VAR([EXT_$1]_INCDIR)/EXT_HEADER")
 176 ])
 177 dnl
 178 dnl PECL_HAVE_CONST(header, const[, type=int[, code-if-yes[, code-if-mno]]])
 179 dnl
 180 AC_DEFUN([PECL_HAVE_CONST], [dnl
 181         AC_REQUIRE([PECL_PROG_EGREP])dnl
 182         AC_CACHE_CHECK([for $2 in $1], PECL_CACHE_VAR([HAVE_$1_$2]), [
 183                 AC_TRY_COMPILE([
 184                         #include "$1"
 185                 ], [
 186                         ]ifelse([$3],,int,[$3])[ _c = $2;
 187                 ], [
 188                         PECL_CACHE_VAR([HAVE_$1_$2])=yes
 189                 ], [
 190                         PECL_CACHE_VAR([HAVE_$1_$2])=no
 191                 ])
 192         ])
 193         if $PECL_CACHE_VAR([HAVE_$1_$2]); then
 194                 PECL_DEFINE([HAVE_$2])
 195                 $4
 196         else
 197                 ifelse([$5],,:,[$5])
 198         fi
 199 ])
 200 dnl
 201 dnl _PECL_TR_VERSION(version)
 202 dnl
 203 AC_DEFUN([_PECL_TR_VERSION], [dnl
 204 AC_REQUIRE([PECL_PROG_AWK])dnl
 205 $(printf "%s" $1 | $AWK -F "[.]" '{print $[]1*1000000 + $[]2*10000 + $[]3*100 + $[]4}')
 206 ])
 207 dnl
 208 dnl PECL_CHECKED_VERSION(name)
 209 dnl
 210 dnl Shell var name of an already checked version.
 211 dnl
 212 AC_DEFUN([PECL_CHECKED_VERSION], [PECL_VAR([$1][_VERSION])])
 213 dnl
 214 dnl PECL_HAVE_VERSION(name, min-version[, code-if-yes[, code-if-not]])
 215 dnl
 216 dnl Perform a min-version check while in an PECL_CHECK_* block.
 217 dnl Expands AC_MSG_ERROR when code-if-not is empty and the version check fails.
 218 dnl
 219 AC_DEFUN([PECL_HAVE_VERSION], [
 220         aversion=_PECL_TR_VERSION([$PECL_CHECKED_VERSION([$1])])
 221         mversion=_PECL_TR_VERSION([$2])
 222         AC_MSG_CHECKING([whether $1 version $PECL_CHECKED_VERSION([$1]) >= $2])
 223         if test "$aversion" -lt "$mversion"; then
 224                 ifelse($4,,AC_MSG_ERROR([no]), [
 225                         AC_MSG_RESULT([no])
 226                         $4
 227                 ])
 228         else
 229                 AC_MSG_RESULT([ok])
 230                 $3
 231         fi
 232 ])
 233 dnl
 234 dnl PECL_CHECK_CUSTOM(name, path, header, lib, version)
 235 dnl
 236 AC_DEFUN([PECL_CHECK_CUSTOM], [
 237         PECL_SAVE_ENV([CPPFLAGS], [$1])
 238         PECL_SAVE_ENV([LDFLAGS], [$1])
 239         PECL_SAVE_ENV([LIBS], [$1])
 240
 241         AC_MSG_CHECKING([for $1])
 242         AC_CACHE_VAL(PECL_CACHE_VAR([$1_prefix]), [
 243                 for path in $2 /usr/local /usr /opt; do
 244                         if test "$path" = "" || test "$path" = "yes" || test "$path" = "no"; then
 245                                 continue
 246                         elif test -f "$path/include/$3"; then
 247                                 PECL_CACHE_VAR([$1_prefix])="$path"
 248                                 break
 249                         fi
 250                 done
 251         ])
 252         if test -n "$PECL_CACHE_VAR([$1_prefix])"; then
 253                 CPPFLAGS="-I$PECL_CACHE_VAR([$1_prefix])/include"
 254                 LDFLAGS="-L$PECL_CACHE_VAR([$1_prefix])/$PHP_LIBDIR"
 255                 LIBS="-l$4"
 256
 257                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_version]), [
 258                         PECL_CACHE_VAR([$1_version])=$5
 259                 ])
 260                 PECL_CHECKED_VERSION([$1])=$PECL_CACHE_VAR([$1_version])
 261
 262                 if test -n "$PECL_CHECKED_VERSION([$1])"; then
 263                         PECL_VAR([HAVE_$1])=true
 264                         PECL_DEFINE([HAVE_$1])
 265                         PECL_DEFINE_UQ($1[_VERSION], "$PECL_CHECKED_VERSION([$1])")
 266                 else
 267                         PECL_VAR([HAVE_$1])=false
 268                 fi
 269         fi
 270         AC_MSG_RESULT([${PECL_CHECKED_VERSION([$1]):-no}])
 271 ])
 272 dnl
 273 dnl PECL_CHECK_CONFIG(name, prog-config, version-flag, cppflags-flag, ldflags-flag, libs-flag)
 274 dnl
 275 AC_DEFUN([PECL_CHECK_CONFIG], [
 276         PECL_SAVE_ENV([CPPFLAGS], [$1])
 277         PECL_SAVE_ENV([LDFLAGS], [$1])
 278         PECL_SAVE_ENV([LIBS], [$1])
 279
 280
 281         AC_MSG_CHECKING([for $1])
 282         ifelse($2, [$PKG_CONFIG $1], [
 283                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_exists]), [
 284                         if $($2 --exists); then
 285                                 PECL_CACHE_VAR([$1_exists])=yes
 286                         else
 287                                 PECL_CACHE_VAR([$1_exists])=no
 288                         fi
 289                 ])
 290                 if $PECL_CACHE_VAR([$1_exists]); then
 291         ])
 292                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_version]), [
 293                         PECL_CACHE_VAR([$1_version])=$($2 $3)
 294                 ])
 295                 PECL_CHECKED_VERSION([$1])=$PECL_CACHE_VAR([$1_version])
 296                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_cppflags]), [
 297                         PECL_CACHE_VAR([$1_cppflags])=$($2 $4)
 298                 ])
 299                 CPPFLAGS=$PECL_CACHE_VAR([$1_cppflags])
 300                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_ldflags]), [
 301                         PECL_CACHE_VAR([$1_ldflags])=$($2 $5)
 302                 ])
 303                 LDFLAGS=$PECL_CACHE_VAR([$1_ldflags])
 304                 AC_CACHE_VAL(PECL_CACHE_VAR([$1_libs]), [
 305                         PECL_CACHE_VAR([$1_libs])=$($2 $6)
 306                 ])
 307                 LIBS=$PECL_CACHE_VAR([$1_libs])
 308         ifelse($2, [$PKG_CONFIG $1], [
 309                 fi
 310         ])
 311
 312         if test -n "$PECL_CHECKED_VERSION([$1])"; then
 313                 PECL_VAR([HAVE_$1])=true
 314                 PECL_DEFINE([HAVE_$1])
 315                 PECL_DEFINE_UQ([$1_VERSION], "$PECL_CHECKED_VERSION([$1])")
 316         else
 317                 PECL_VAR([HAVE_$1])=false
 318         fi
 319
 320         AC_MSG_RESULT([${PECL_CHECKED_VERSION([$1]):-no}])
 321 ])
 322 dnl
 323 dnl PECL_CHECK_PKGCONFIG(pkg[, additional-pkg-config-path])
 324 dnl
 325 AC_DEFUN([PECL_CHECK_PKGCONFIG], [dnl
 326         AC_REQUIRE([PECL_PROG_PKGCONFIG])dnl
 327         ifelse($2,,,PKG_CONFIG_PATH="$2/lib/pkgconfig:$PKG_CONFIG_PATH")
 328         PECL_CHECK_CONFIG([$1], [$PKG_CONFIG $1], [--modversion], [--cflags-only-I], [--libs-only-L], [--libs-only-l])
 329 ])
 330 dnl
 331 dnl PECL_CHECK_DONE(name, success[, incline, libline])
 332 dnl
 333 AC_DEFUN([PECL_CHECK_DONE], [
 334         if $2; then
 335                 incline=$CPPFLAGS
 336                 libline="$LDFLAGS $LIBS"
 337                 PECL_DEFINE([HAVE_$1])
 338         else
 339                 incline=$3
 340                 libline=$4
 341         fi
 342
 343         PECL_RESTORE_ENV([CPPFLAGS], [$1])
 344         PECL_RESTORE_ENV([LDFLAGS], [$1])
 345         PECL_RESTORE_ENV([LIBS], [$1])
 346
 347         PHP_EVAL_INCLINE([$incline])
 348         PHP_EVAL_LIBLINE([$libline], AS_TR_CPP(PECL_NAME[_SHARED_LIBADD]))
 349 ])
 350
 351 dnl
 352 dnl PECL_CHECK_CA([additional-ca-paths,[ additional-ca-bundles]])
 353 dnl
 354 AC_DEFUN([PECL_CHECK_CA], [
 355         AC_CACHE_CHECK([for default CA path], PECL_CACHE_VAR([CAPATH]), [
 356                 PECL_VAR([CAPATH])=
 357                 for ca_path in $1 \
 358                         /etc/ssl/certs \
 359                         /System/Library/OpenSSL
 360                 do
 361                         # check if it's actually a hashed directory
 362                         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
 363                                 PECL_CACHE_VAR([CAPATH])=$ca_path
 364                                 break
 365                         fi
 366                 done
 367         ])
 368         if test -n "$PECL_CACHE_VAR([CAPATH])"; then
 369                 PECL_DEFINE_SH([CAPATH], "$PECL_CACHE_VAR([CAPATH])")
 370         fi
 371
 372         AC_CACHE_CHECK([for default CA info], PECL_CACHE_VAR([CAINFO]), [
 373                 for ca_info in $2 \
 374                         /etc/ssl/{cert,ca-bundle}.pem \
 375                         /{etc,usr/share}/ssl/certs/ca-{bundle,ceritifcates}.crt \
 376                         /etc/{pki/ca-trust,ca-certificates}/extracted/pem/tls-ca-bundle.pem \
 377                         /etc/pki/tls/certs/ca-bundle{,.trust}.crt \
 378                         /usr/local/etc/{,open}ssl/cert.pem \
 379                         /usr/local/share/certs/ca-root-nss.crt \
 380                         /{usr,usr/local,opt}/local/share/curl/curl-ca-bundle.crt
 381                 do
 382                         if test -f "$ca_info"; then
 383                                 PECL_CACHE_VAR([CAINFO])=$ca_info
 384                                 break
 385                         fi
 386                 done
 387         ])
 388         if test -n "$PECL_CACHE_VAR([CAINFO])"; then
 389                 PECL_DEFINE_SH([CAINFO], "$PECL_CACHE_VAR([CAINFO])")
 390         fi
 391 ])