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