Open Build Service

Changes of Revision 4

php8-memcached.changes Changed

php8-memcached.spec Changed

memcached-3.2.0.tgz/memcached-3.2.0/README.markdown Deleted

@@ -1,52 +0,0 @@
-Build Status
-------------
-!Build Status(https://travis-ci.org/php-memcached-dev/php-memcached.png)(https://travis-ci.org/php-memcached-dev/php-memcached)
-
-Description
------------
-This is the PECL memcached(https://pecl.php.net/package/memcached) extension,
-using the libmemcached library to connect to memcached servers.
-
-memcached(https://memcached.org) is a high-performance, distributed memory
-object caching system, generic in nature, but intended for use in speeding up
-dynamic web applications by alleviating database load.
-
-Building
---------
-
-    $ phpize
-    $ ./configure
-    $ make
-    $ make test
-
-Dependencies
-------------
-
-php-memcached 3.x:
-* Supports PHP 7.0 - 8.1.
-* Requires libmemcached 1.x or higher.
-* Optionally supports igbinary 2.0 or higher.
-* Optionally supports msgpack 2.0 or higher.
-
-php-memcached 2.x:
-* Supports PHP 5.2 - 5.6.
-* Requires libmemcached 0.44 or higher.
-* Optionally supports igbinary 1.0 or higher.
-* Optionally supports msgpack 0.5 or higher.
-
-libmemcached(http://libmemcached.org/libMemcached.html) or the new
-libmemcached-awesome(https://github.com/awesomized/libmemcached) version
-1.0.18 or higher is recommended for best performance and compatibility with
-memcached servers.
-
-igbinary(https://github.com/igbinary/igbinary) is a faster and more compact
-binary serializer for PHP data structures. When installing php-memcached from
-source code, the igbinary module must be installed first so that php-memcached
-can access its C header files. Load both modules in your `php.ini` at runtime
-to begin using igbinary.
-
-msgpack(https://msgpack.org) is a faster and more compact data structure
-representation that is interoperable with msgpack implementations for other
-languages. When installing php-memcached from source code, the msgpack module
-must be installed first so that php-memcached can access its C header files.
-Load both modules in your `php.ini` at runtime to begin using msgpack.

memcached-3.2.0.tgz/memcached-3.2.0/config.m4 Deleted

@@ -1,409 +0,0 @@
-dnl vim:se ts=2 sw=2 et:
-
-PHP_ARG_ENABLE(memcached, whether to enable memcached support,
-  --enable-memcached              Enable memcached support)
-
-PHP_ARG_WITH(libmemcached-dir,  for libmemcached,
-  --with-libmemcached-dir=DIR     Set the path to libmemcached install prefix., yes)
-
-PHP_ARG_ENABLE(memcached-session, whether to enable memcached session handler support,
-  --enable-memcached-session      Enable memcached session handler support, yes, no)
-
-PHP_ARG_ENABLE(memcached-igbinary, whether to enable memcached igbinary serializer support,
-  --enable-memcached-igbinary     Enable memcached igbinary serializer support, no, no)
-
-PHP_ARG_ENABLE(memcached-json, whether to enable memcached json serializer support,
-  --enable-memcached-json         Enable memcached json serializer support, no, no)
-
-PHP_ARG_ENABLE(memcached-msgpack, whether to enable memcached msgpack serializer support,
-  --enable-memcached-msgpack      Enable memcached msgpack serializer support, no, no)
-
-PHP_ARG_ENABLE(memcached-sasl, whether to enable memcached sasl support,
-  --enable-memcached-sasl         Enable memcached sasl support, yes, no)
-
-PHP_ARG_ENABLE(memcached-protocol, whether to enable memcached protocol support,
-  --enable-memcached-protocol     Enable memcached protocol support, no, no)
-
-PHP_ARG_WITH(system-fastlz, whether to use system FastLZ library,
-  --with-system-fastlz            Use system FastLZ library, no, no)
-
-if test -z "$PHP_ZLIB_DIR"; then
-PHP_ARG_WITH(zlib-dir, for ZLIB,
-  --with-zlib-dir=DIR             Set the path to ZLIB install prefix., no)
-fi
-
-if test -z "$PHP_DEBUG"; then
-  AC_ARG_ENABLE(debug,
-    --enable-debug          Compile with debugging symbols,
-    PHP_DEBUG=$enableval
-  ,    PHP_DEBUG=no
-  )
-fi
-
-if test "$PHP_MEMCACHED" != "no"; then
-
-  AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
-  if test "x$PKG_CONFIG" = "xno"; then
-    AC_MSG_RESULT(pkg-config not found)
-    AC_MSG_ERROR(Please reinstall the pkg-config distribution)
-  fi
-
-  dnl # zlib
-  if test "$PHP_ZLIB_DIR" != "no" && test "$PHP_ZLIB_DIR" != "yes"; then
-    if test -f "$PHP_ZLIB_DIR/include/zlib/zlib.h"; then
-      PHP_ZLIB_DIR="$PHP_ZLIB_DIR"
-      PHP_ZLIB_INCDIR="$PHP_ZLIB_DIR/include/zlib"
-    elif test -f "$PHP_ZLIB_DIR/include/zlib.h"; then
-      PHP_ZLIB_DIR="$PHP_ZLIB_DIR"
-      PHP_ZLIB_INCDIR="$PHP_ZLIB_DIR/include"
-    else
-      AC_MSG_ERROR(Can't find ZLIB headers under "$PHP_ZLIB_DIR")
-    fi
-  else
-    for i in /usr/local /usr/local/opt/zlib /usr; do
-      if test -f "$i/include/zlib/zlib.h"; then
-        PHP_ZLIB_DIR="$i"
-        PHP_ZLIB_INCDIR="$i/include/zlib"
-      elif test -f "$i/include/zlib.h"; then
-        PHP_ZLIB_DIR="$i"
-        PHP_ZLIB_INCDIR="$i/include"
-      fi
-    done
-  fi
-
-  AC_MSG_CHECKING(for zlib location)
-  if test "$PHP_ZLIB_DIR" != "no" && test "$PHP_ZLIB_DIR" != "yes"; then
-    AC_MSG_RESULT($PHP_ZLIB_DIR)
-    PHP_ADD_LIBRARY_WITH_PATH(z, $PHP_ZLIB_DIR/$PHP_LIBDIR, MEMCACHED_SHARED_LIBADD)
-    PHP_ADD_INCLUDE($PHP_ZLIB_INCDIR)
-  else
-    AC_MSG_ERROR(memcached support requires ZLIB. Use --with-zlib-dir=<DIR> to specify the prefix where ZLIB headers and library are located)
-  fi
-
-  if test "$PHP_MEMCACHED_SESSION" != "no"; then
-    AC_MSG_CHECKING(for session includes)
-    session_inc_path=""
-
-    if test -f "$abs_srcdir/include/php/ext/session/php_session.h"; then
-      session_inc_path="$abs_srcdir/include/php"
-    elif test -f "$abs_srcdir/ext/session/php_session.h"; then
-      session_inc_path="$abs_srcdir"
-    elif test -f "$phpincludedir/ext/session/php_session.h"; then
-      session_inc_path="$phpincludedir"
-    else
-      for i in php php4 php5 php6; do
-        if test -f "$prefix/include/$i/ext/session/php_session.h"; then
-          session_inc_path="$prefix/include/$i"
-        fi
-      done
-    fi
-
-    if test "$session_inc_path" = ""; then
-      AC_MSG_ERROR(Cannot find php_session.h)
-    else
-      AC_MSG_RESULT($session_inc_path)
-    fi
-  fi
-
-  if test "$PHP_MEMCACHED_JSON" != "no"; then
-    AC_MSG_CHECKING(for json includes)
-    json_inc_path=""
-
-    if test -f "$abs_srcdir/include/php/ext/json/php_json.h"; then
-      json_inc_path="$abs_srcdir/include/php"
-    elif test -f "$abs_srcdir/ext/json/php_json.h"; then
-      json_inc_path="$abs_srcdir"
-    elif test -f "$phpincludedir/ext/json/php_json.h"; then
-      json_inc_path="$phpincludedir"
-    else
-      for i in php php4 php5 php6; do
-        if test -f "$prefix/include/$i/ext/json/php_json.h"; then
-          json_inc_path="$prefix/include/$i"
-        fi
-      done
-    fi
-    if test "$json_inc_path" = ""; then
-      AC_MSG_ERROR(Cannot find php_json.h)
-    else
-      AC_DEFINE(HAVE_JSON_API,1,Whether JSON API is available)
-      AC_MSG_RESULT($json_inc_path)
-    fi
-  fi
-
-  if test "$PHP_MEMCACHED_IGBINARY" != "no"; then
-    AC_MSG_CHECKING(for igbinary includes)
-    igbinary_inc_path=""
-
-    if test -f "$abs_srcdir/include/php/ext/igbinary/igbinary.h"; then
-      igbinary_inc_path="$abs_srcdir/include/php"
-    elif test -f "$abs_srcdir/ext/igbinary/igbinary.h"; then
-      igbinary_inc_path="$abs_srcdir"
-    elif test -f "$phpincludedir/ext/session/igbinary.h"; then
-      igbinary_inc_path="$phpincludedir"
-    elif test -f "$phpincludedir/ext/igbinary/igbinary.h"; then
-      igbinary_inc_path="$phpincludedir"
-    else
-      for i in php php4 php5 php6; do
-        if test -f "$prefix/include/$i/ext/igbinary/igbinary.h"; then
-          igbinary_inc_path="$prefix/include/$i"
-        fi
-      done
-    fi
-
-    if test "$igbinary_inc_path" = ""; then
-      AC_MSG_ERROR(Cannot find igbinary.h)
-    else
-      AC_MSG_RESULT($igbinary_inc_path)
-    fi
-  fi
-
-  if test "$PHP_MEMCACHED_MSGPACK" != "no"; then
-    AC_MSG_CHECKING(for msgpack includes)
-    msgpack_inc_path=""
-
-    if test -f "$abs_srcdir/include/php/ext/msgpack/php_msgpack.h"; then
-      msgpack_inc_path="$abs_srcdir/include/php"
-    elif test -f "$abs_srcdir/ext/msgpack/php_msgpack.h"; then
-      msgpack_inc_path="$abs_srcdir"
-    elif test -f "$phpincludedir/ext/session/php_msgpack.h"; then
-      msgpack_inc_path="$phpincludedir"
-    elif test -f "$phpincludedir/ext/msgpack/php_msgpack.h"; then
-      msgpack_inc_path="$phpincludedir"
-    else
-      for i in php php4 php5 php6; do
-        if test -f "$prefix/include/$i/ext/msgpack/php_msgpack.h"; then
-          msgpack_inc_path="$prefix/include/$i"
-        fi
-      done
-    fi
-
-    if test "$msgpack_inc_path" = ""; then
-      AC_MSG_ERROR(Cannot find php_msgpack.h)
-    else
-      AC_MSG_RESULT($msgpack_inc_path)
-    fi
-  fi
-
-  AC_MSG_CHECKING(for memcached session support)
-  if test "$PHP_MEMCACHED_SESSION" != "no"; then
-    AC_MSG_RESULT(enabled)
-    AC_DEFINE(HAVE_MEMCACHED_SESSION,1,Whether memcache session handler is enabled)
-    SESSION_INCLUDES="-I$session_inc_path"
-    ifdef(PHP_ADD_EXTENSION_DEP,
-    
-      PHP_ADD_EXTENSION_DEP(memcached, session)
-    )
-  else
-    SESSION_INCLUDES=""
-    AC_MSG_RESULT(disabled)
-  fi
-
-  AC_MSG_CHECKING(for memcached igbinary support)
-  if test "$PHP_MEMCACHED_IGBINARY" != "no"; then
-    AC_MSG_RESULT(enabled)
-    AC_DEFINE(HAVE_MEMCACHED_IGBINARY,1,Whether memcache igbinary serializer is enabled)
-    IGBINARY_INCLUDES="-I$igbinary_inc_path"
-    ifdef(PHP_ADD_EXTENSION_DEP,
-    
-      PHP_ADD_EXTENSION_DEP(memcached, igbinary)
-    )
-  else
-    IGBINARY_INCLUDES=""
-    AC_MSG_RESULT(disabled)
-  fi
-
-  AC_MSG_CHECKING(for memcached msgpack support)
-  if test "$PHP_MEMCACHED_MSGPACK" != "no"; then
-    AC_MSG_RESULT(enabled)
-    AC_DEFINE(HAVE_MEMCACHED_MSGPACK,1,Whether memcache msgpack serializer is enabled)
-    MSGPACK_INCLUDES="-I$msgpack_inc_path"
-    ifdef(PHP_ADD_EXTENSION_DEP,
-    
-      PHP_ADD_EXTENSION_DEP(memcached, msgpack)
-    )
-  else
-    MSGPACK_INCLUDES=""
-    AC_MSG_RESULT(disabled)
-  fi
-
-  AC_MSG_CHECKING(for libmemcached location)
-  export ORIG_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
-
-  if test "$PHP_LIBMEMCACHED_DIR" != "no" && test "$PHP_LIBMEMCACHED_DIR" != "yes"; then
-    export PKG_CONFIG_PATH="$PHP_LIBMEMCACHED_DIR/$PHP_LIBDIR/pkgconfig"
-
-    if test ! -f "$PHP_LIBMEMCACHED_DIR/include/libmemcached/memcached.h"; then
-      AC_MSG_ERROR(Unable to find memcached.h under $PHP_LIBMEMCACHED_DIR)
-    fi
-  else
-    export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/$PHP_LIBDIR/pkgconfig:/usr/$PHP_LIBDIR/pkgconfig:/opt/$PHP_LIBDIR/pkgconfig"
-  fi
-
-  if ! $PKG_CONFIG --exists libmemcached; then
-    AC_MSG_ERROR(memcached support requires libmemcached. Use --with-libmemcached-dir=<DIR> to specify the prefix where libmemcached headers and library are located)
-  else
-    PHP_LIBMEMCACHED_VERSION=`$PKG_CONFIG libmemcached --modversion`
-    PHP_LIBMEMCACHED_DIR=`$PKG_CONFIG libmemcached --variable=prefix`
-
-    AC_MSG_RESULT(found version $PHP_LIBMEMCACHED_VERSION, under $PHP_LIBMEMCACHED_DIR)
-
-    PHP_LIBMEMCACHED_LIBS=`$PKG_CONFIG libmemcached --libs`
-    PHP_LIBMEMCACHED_INCLUDES=`$PKG_CONFIG libmemcached --cflags`
-
-    PHP_EVAL_LIBLINE($PHP_LIBMEMCACHED_LIBS, MEMCACHED_SHARED_LIBADD)
-    PHP_EVAL_INCLINE($PHP_LIBMEMCACHED_INCLUDES)
-
-    ORIG_CFLAGS="$CFLAGS"
-    CFLAGS="$CFLAGS $INCLUDES"
-
-    dnl # Always check if libmemcached was built with SASL support,
-    dnl # because it will require sasl.h even if not used here.
-    AC_CACHE_CHECK(for libmemcached sasl.h requirement, ac_cv_memc_sasl_support, 
-      AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <libmemcached/memcached.h>, 
-        #if LIBMEMCACHED_WITH_SASL_SUPPORT
-          /* yes */
-        #else
-        #  error "no sasl support"
-        #endif
-        ),
-        ac_cv_memc_sasl_support="yes",
-        ac_cv_memc_sasl_support="no"
-      )
-    )
-
-    if test "$ac_cv_memc_sasl_support" = "yes"; then
-      AC_CHECK_HEADERS(sasl/sasl.h, ac_cv_have_memc_sasl_h="yes", ac_cv_have_memc_sasl_h="no")
-    fi
-
-    dnl # If libmemcached requires sasl.h but we can't find sasl.h, that's a hard error
-    dnl # regardless of the option --enable-memcached-sasl or --disable-memcached-sasl
-    AC_MSG_CHECKING(whether to enable sasl support)
-    if test "$ac_cv_memc_sasl_support" = "yes" && test "$ac_cv_have_memc_sasl_h" = "no"; then
-      AC_MSG_ERROR(no, libmemcached built with sasl required, but sasl.h not found.)
-    fi
-
-    if test "$PHP_MEMCACHED_SASL" != "no"; then
-      AC_MSG_RESULT(yes)
-      if test "$ac_cv_memc_sasl_support" = "yes" && test "$ac_cv_have_memc_sasl_h" = "yes"; then
-        PHP_CHECK_LIBRARY(sasl2, sasl_client_init, PHP_ADD_LIBRARY(sasl2, 1, MEMCACHED_SHARED_LIBADD))
-        AC_DEFINE(HAVE_MEMCACHED_SASL, 1, Have SASL support)
-      else
-        AC_MSG_ERROR(no, libmemcached built with sasl disabled. Run configure with --disable-memcached-sasl or update libmemcached with sasl support)
-      fi
-    else
-      AC_MSG_RESULT(no)
-    fi
-
-    ORIG_CFLAGS="$CFLAGS"
-    ORIG_LIBS="$LIBS"
-
-    CFLAGS="$CFLAGS $PHP_LIBMEMCACHED_INCLUDES"
-    LIBS="$LIBS $PHP_LIBMEMCACHED_LIBS"
-
-    AC_CACHE_CHECK(whether memcached_exist is defined, ac_cv_have_memcached_exist, 
-      AC_LINK_IFELSE(
-        AC_LANG_PROGRAM(#include <libmemcached/memcached.h>,
-          memcached_exist (NULL, NULL, 0);),
-          ac_cv_have_memcached_exist="yes",
-          ac_cv_have_memcached_exist="no")
-    )
-
-    CFLAGS="$ORIG_CFLAGS"
-    LIBS="$ORIG_LIBS"
-
-    CFLAGS="$CFLAGS $PHP_LIBMEMCACHED_INCLUDES"
-    LIBS="$LIBS $PHP_LIBMEMCACHED_LIBS"
-
-    if test "$ac_cv_have_memcached_exist" = "yes"; then
-      AC_DEFINE(HAVE_MEMCACHED_EXIST, 1, Whether memcached_exist is defined)
-    fi
-
-    AC_CACHE_CHECK(whether memcached_set_encoding_key is defined, ac_cv_have_memcached_set_encoding_key, 
-      AC_LINK_IFELSE(
-        AC_LANG_PROGRAM(#include <libmemcached/memcached.h>,
-          memcached_set_encoding_key (NULL, NULL, 0);),
-        ac_cv_have_memcached_set_encoding_key="yes",
-        ac_cv_have_memcached_set_encoding_key="no")
-    )
-
-    CFLAGS="$ORIG_CFLAGS"
-    LIBS="$ORIG_LIBS"
-
-    if test "$ac_cv_have_memcached_set_encoding_key" = "yes"; then
-      AC_DEFINE(HAVE_MEMCACHED_SET_ENCODING_KEY, 1, Whether memcached_set_encoding_key is defined)
-    fi
-
-    PHP_MEMCACHED_FILES="php_memcached.c php_libmemcached_compat.c  g_fmt.c"
-
-    if test "$PHP_SYSTEM_FASTLZ" != "no"; then
-      AC_CHECK_HEADERS(fastlz.h, ac_cv_have_fastlz="yes", ac_cv_have_fastlz="no")
-      PHP_CHECK_LIBRARY(fastlz, fastlz_compress,
-          PHP_ADD_LIBRARY(fastlz, 1, MEMCACHED_SHARED_LIBADD),
-          AC_MSG_ERROR(FastLZ library not found))
-    else
-      ac_cv_have_fastlz="no"
-      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} fastlz/fastlz.c"
-    fi
-
-    if test "$PHP_MEMCACHED_SESSION" != "no"; then
-      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} php_memcached_session.c"
-    fi
-
-    LIBEVENT_INCLUDES=""
-    AC_MSG_CHECKING(for memcached protocol support)
-    if test "$PHP_MEMCACHED_PROTOCOL" != "no"; then
-      AC_MSG_RESULT(enabled)
-
-      AC_CACHE_CHECK(whether libmemcachedprotocol is usable, ac_cv_have_libmemcachedprotocol, 
-        AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <libmemcachedprotocol-0.0/handler.h>,
-          memcached_binary_protocol_callback_st s_test_impl;
-            s_test_impl.interface.v1.delete_object = 0;
-          ),
-          ac_cv_have_libmemcachedprotocol="yes",
-          ac_cv_have_libmemcachedprotocol="no"
-        )
-      )
-
-      if test "$ac_cv_have_libmemcachedprotocol" != "yes"; then
-        AC_MSG_ERROR(Cannot enable libmemcached protocol)
-      fi
-
-      PHP_ADD_LIBRARY_WITH_PATH(memcachedprotocol, $PHP_LIBMEMCACHED_DIR/$PHP_LIBDIR, MEMCACHED_SHARED_LIBADD)
-
-      AC_MSG_CHECKING(for libevent)
-      if $PKG_CONFIG --exists libevent; then
-        PHP_MEMCACHED_LIBEVENT_VERSION=`$PKG_CONFIG libevent --modversion`
-        PHP_MEMCACHED_LIBEVENT_PREFIX=`$PKG_CONFIG libevent --variable=prefix`
-
-        AC_MSG_RESULT(found version $PHP_MEMCACHED_LIBEVENT_VERSION, under $PHP_MEMCACHED_LIBEVENT_PREFIX)
-        LIBEVENT_LIBS=`$PKG_CONFIG libevent --libs`
-        LIBEVENT_INCLUDES=`$PKG_CONFIG libevent --cflags`
-
-        PHP_EVAL_LIBLINE($LIBEVENT_LIBS, MEMCACHED_SHARED_LIBADD)
-        PHP_EVAL_INCLINE($LIBEVENT_INCLUDES)
-      else
-        AC_MSG_ERROR(Unable to find libevent installation)
-      fi
-      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} php_memcached_server.c"
-      AC_DEFINE(HAVE_MEMCACHED_PROTOCOL,1,Whether memcached protocol is enabled)
-    else
-      AC_MSG_RESULT(disabled)
-    fi
-
-    CFLAGS="$ORIG_CFLAGS"
-
-    export PKG_CONFIG_PATH="$ORIG_PKG_CONFIG_PATH"
-    PHP_SUBST(MEMCACHED_SHARED_LIBADD)
-
-    PHP_NEW_EXTENSION(memcached, $PHP_MEMCACHED_FILES, $ext_shared,,$SESSION_INCLUDES $IGBINARY_INCLUDES $LIBEVENT_INCLUDES $MSGPACK_INCLUDES)
-    if test "ac_cv_have_fastlz" != "yes"; then
-      PHP_ADD_BUILD_DIR($ext_builddir/fastlz, 1)
-    fi
-
-    ifdef(PHP_ADD_EXTENSION_DEP,
-    
-      PHP_ADD_EXTENSION_DEP(memcached, spl, true)
-    )
-  fi
-fi
-

memcached-3.2.0.tgz/memcached-3.2.0/config.w32 Deleted

@@ -1,43 +0,0 @@
-// vim:ft=javascript
-
-ARG_ENABLE('memcached', 'libmemcached extension', 'no');
-
-ARG_ENABLE('memcached-session', 'whether to enable memcached session handler support', 'no');
-ARG_ENABLE('memcached-igbinary', 'whether to enable memcached igbinary serializer support', 'no');
-ARG_ENABLE('memcached-json', 'whether to enable memcached json serializer support', 'no');
-
-if (PHP_MEMCACHED == "yes") {
-
-  if (!CHECK_LIB("memcached.lib;libmemcached.lib", "memcached", PHP_MEMCACHED)) { 
-	ERROR("memcached: library 'memcached' not found");
-  }
-  
-  if (!CHECK_HEADER_ADD_INCLUDE("libmemcached/memcached.h", "CFLAGS_MEMCACHED")) {
-	ERROR("memcached: header 'libmemcached/memcached.h' not found");
-  }
-
-  if (PHP_MEMCACHED_JSON != "no"){
-	AC_DEFINE("HAVE_JSON_API",1);
-  }
-  
-  var memcached_extra_src = "";
-  
-  if (PHP_MEMCACHED_SESSION != "no"){
-	AC_DEFINE("HAVE_MEMCACHED_SESSION",1);
-	ADD_EXTENSION_DEP("memcached", "session", true)
-	memcached_extra_src += " php_memcached_session.c";
-  }
-  
-  if (PHP_MEMCACHED_IGBINARY != "no"){
-	AC_DEFINE("HAVE_MEMCACHED_IGBINARY",1);
-	ADD_EXTENSION_DEP("memcached", "igbinary", true);
-	if (!CHECK_HEADER_ADD_INCLUDE("igbinary.h", "CFLAGS_MEMCACHED")) {
-		ERROR("memcached: header 'igbinary.h' not found");
-	  }
-  }
-  
-  EXTENSION("memcached", "php_memcached.c php_libmemcached_compat.c g_fmt.c"+memcached_extra_src, null, " /DHAVE_SSIZE_T");
-  ADD_SOURCES(configure_module_dirname+"\\fastlz", "fastlz.c", "memcached");
-  AC_DEFINE("HAVE_MEMCACHED", 1, "memcached support");
-  AC_DEFINE("MEMCACHED_EXPORTS", 1)
-}

memcached-3.2.0.tgz/memcached-3.2.0/memcached.ini Deleted

@@ -1,163 +0,0 @@
-memcached
-; Use session locking
-; valid values: On, Off
-; the default is On
-;memcached.sess_locking = On
-
-; The minimum time, in milliseconds, to wait between session lock attempts.
-; This value is double on each lock retry until memcached.sess_lock_wait_max
-; is reached, after which any further retries will take sess_lock_wait_max seconds.
-; Default is 150.
-;memcached.sess_lock_wait_min = 150;
-
-; The maximum time, in milliseconds, to wait between session lock attempts.
-; Default is 150.
-;memcached.sess_lock_wait_max = 150;
-
-; The number of times to retry locking the session lock, not including the first attempt.
-; Default is 5.
-;memcached.sess_lock_retries = 5;
-
-; The time, in seconds, before a lock should release itself.
-; Setting to 0 results in the default behaviour, which is to
-; use PHP's max_execution_time.
-;memcached.sess_lock_expire = 0;
-
-; memcached session key prefix
-; valid values are strings less than 219 bytes long
-; the default value is "memc.sess.key."
-;memcached.sess_prefix = "memc.sess.key."
-
-; Whether or not to re-use the memcached connections corresponding to the value(s)
-; of session.save_path after the execution of the script ends.
-; Don't use this if certain settings (e.g. SASL settings, sess_binary_protocol) would
-; be overridden between requests.
-; Default is Off.
-;memcached.sess_persistent = Off
-
-; memcached session consistent hash mode
-; if set to On, consistent hashing (libketama) is used
-; for session handling.
-; When consistent hashing is used, one can add or remove cache
-; node(s) without messing up too much with existing keys
-; default is On
-;memcached.sess_consistent_hash = On
-
-; memcached session consistent hash type
-; if set to 'ketama', consistent hashing (libketama) is used
-; for session handling (default for php-memcached 3.x)
-; if set to 'ketama_weighted', weighted consistent hashing (libketama) is used
-; for session handling (default for php-memcached 2.x)
-;memcached.sess_consistent_hash_type = "ketama"
-
-; Allow failed memcached server to automatically be removed.
-; Default is Off. (In previous versions, this setting was called memcached.sess_remove_failed)
-;memcached.sess_remove_failed_servers = Off
-
-; Set this value to enable the server be removed after
-; configured number of continuous times connection failure.
-;memcached.sess_server_failure_limit = 0
-
-; Write data to a number of additional memcached servers
-; This is "poor man's HA" as libmemcached calls it.
-; If this value is positive and sess_remove_failed_servers is enabled
-; when a memcached server fails the session will continue to be available
-; from a replica. However, if the failed memcache server
-; becomes available again it will read the session from there
-; which could have old data or no data at all
-;memcached.sess_number_of_replicas = 0
-
-; Use the memcached binary protocol for memcached sessions (Instead of the text protocol)
-; libmemcached replicas work only if binary mode is enabled.
-; However, certain proxies (such as twemproxy) will work only if the binary protocol is disabled.
-; In older versions of php-memcached, this setting was Off and was called memcached.sess_binary.
-; Default is On with libmemcached 1.0.18 or newer.
-; Default is Off with older version.
-;memcached.sess_binary_protocol = On
-
-; memcached session replica read randomize
-;memcached.sess_randomize_replica_read = Off
-
-; memcached connect timeout value
-; In non-blocking mode this changes the value of the timeout
-; during socket connection in milliseconds. Specifying -1 means an infinite timeout.
-;memcached.sess_connect_timeout = 1000
-
-; Session SASL username
-; Both username and password need to be set for SASL to be enabled
-;memcached.sess_sasl_username = NULL
-
-; Session SASL password
-;memcached.sess_sasl_password = NULL
-
-; Set the compression type
-; valid values are: fastlz, zlib
-; the default is fastlz
-;memcached.compression_type = "fastlz"
-
-; Compression factor
-; Store compressed value only if the compression
-; factor (saving) exceeds the set limit.
-;
-;  store compressed if:
-;    plain_len > comp_len * factor
-;
-; the default value is 1.3 (23% space saving)
-;memcached.compression_factor = "1.3"
-
-; The compression threshold
-;
-; Do not compress serialized values below this threshold.
-; the default is 2000 bytes
-;memcached.compression_threshold = 2000
-
-; Set the default serializer for new memcached objects.
-; valid values are: php, igbinary, json, json_array, msgpack
-;
-; json - standard php JSON encoding. This serializer
-;        is fast and compact but only works on UTF-8
-;        encoded data and does not fully implement
-;        serializing. See the JSON extension.
-; json_array - as json, but decodes into arrays
-; php - the standard php serializer
-; igbinary - a binary serializer
-; msgpack - a cross-language binary serializer
-;
-; The default is igbinary if available, then msgpack if available, then php otherwise.
-;memcached.serializer = "igbinary"
-
-; The amount of retries for failed store commands.
-; This mechanism allows transparent fail-over to secondary servers when
-; set/increment/decrement/setMulti operations fail on the desired server in a multi-server
-; environment.
-; the default is 0
-;memcached.store_retry_count = 0
-
-; Sets the default for consistent hashing for new connections.
-; (To configure consistent hashing for session connections,
-; use memcached.sess_consistent_hash instead)
-;
-; If set to On, consistent hashing (libketama) is used
-; for session handling.
-; When consistent hashing is used, one can add or remove cache
-; node(s) without messing up too much with existing keys
-; default is Off
-;memcached.default_consistent_hash = Off
-
-; Sets the default memcached protocol for new connections.
-; (To configure the memcached protocol for connections used by sessions,
-; use memcached.sess_binary_protocol instead)
-;
-; If set to On, the memcached binary protocol is used by default.
-; If set to Off, the memcached text protocol is used.
-; Default is Off
-;memcached.default_binary_protocol = Off
-
-; Sets the default memcached connection timeout for new connections.
-; (To configure the memcached connection timeout for sessions,
-; use memcached.sess_connect_timeout instead)
-; In non-blocking mode this changes the value of the timeout.
-; during socket connection in milliseconds. Specifying -1 means an infinite timeout.
-; Specifying 0 means using the memcached library's default connection timeout.
-; Default is 0.
-;memcached.default_connect_timeout = 0

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached.c Deleted

@@ -1,4368 +0,0 @@
-/*
-  +----------------------------------------------------------------------+
-  | Copyright (c) 2009-2010 The PHP Group                                |
-  +----------------------------------------------------------------------+
-  | This source file is subject to version 3.01 of the PHP license,      |
-  | that is bundled with this package in the file LICENSE, and is        |
-  | available through the world-wide-web at the following url:           |
-  | http://www.php.net/license/3_01.txt.                                 |
-  | If you did not receive a copy of the PHP license and are unable to   |
-  | obtain it through the world-wide-web, please send a note to          |
-  | license@php.net so we can mail you a copy immediately.               |
-  +----------------------------------------------------------------------+
-  | Authors: Andrei Zmievski <andrei@php.net>                            |
-  +----------------------------------------------------------------------+
-*/
-
-/* TODO
- * - set LIBKETAMA_COMPATIBLE as the default?
- * - fix unserialize(serialize($memc))
- */
-
-#include "php_memcached.h"
-#include "php_memcached_private.h"
-#include "php_memcached_server.h"
-#include "g_fmt.h"
-
-#include <ctype.h>
-#include <limits.h>
-
-#ifdef HAVE_MEMCACHED_SESSION
-# include "php_memcached_session.h"
-#endif
-#ifdef HAVE_FASTLZ_H
-#include <fastlz.h>
-#else
-#include "fastlz/fastlz.h"
-#endif
-#include <zlib.h>
-
-#ifdef HAVE_JSON_API
-# include "ext/json/php_json.h"
-#endif
-
-#ifdef HAVE_MEMCACHED_IGBINARY
-#ifdef PHP_WIN32
-//Windows extensions are generally built together,
-//so it wont be in the installed location
-#include "igbinary.h"
-#else
-# include "ext/igbinary/igbinary.h"
-#endif
-#endif
-
-#ifdef HAVE_MEMCACHED_MSGPACK
-# include "ext/msgpack/php_msgpack.h"
-#endif
-
-# include "ext/spl/spl_exceptions.h"
-
-static int le_memc;
-
-static int php_memc_list_entry(void) {
-	return le_memc;
-}
-
-/****************************************
-  Protocol parameters
-****************************************/
-#define MEMC_OBJECT_KEY_MAX_LENGTH 250
-
-/****************************************
-  Custom options
-****************************************/
-#define MEMC_OPT_COMPRESSION        -1001
-#define MEMC_OPT_PREFIX_KEY         -1002
-#define MEMC_OPT_SERIALIZER         -1003
-#define MEMC_OPT_COMPRESSION_TYPE   -1004
-#define MEMC_OPT_STORE_RETRY_COUNT  -1005
-#define MEMC_OPT_USER_FLAGS         -1006
-
-/****************************************
-  Custom result codes
-****************************************/
-#define MEMC_RES_PAYLOAD_FAILURE -1001
-
-/****************************************
-  Payload value flags
-****************************************/
-#define MEMC_CREATE_MASK(start, n_bits) (((1 << n_bits) - 1) << start)
-
-#define MEMC_MASK_TYPE     MEMC_CREATE_MASK(0, 4)
-#define MEMC_MASK_INTERNAL MEMC_CREATE_MASK(4, 12)
-#define MEMC_MASK_USER     MEMC_CREATE_MASK(16, 16)
-
-#define MEMC_VAL_GET_TYPE(flags)       ((flags) & MEMC_MASK_TYPE)
-#define MEMC_VAL_SET_TYPE(flags, type) ((flags) |= ((type) & MEMC_MASK_TYPE))
-
-#define MEMC_VAL_IS_STRING     0
-#define MEMC_VAL_IS_LONG       1
-#define MEMC_VAL_IS_DOUBLE     2
-#define MEMC_VAL_IS_BOOL       3
-#define MEMC_VAL_IS_SERIALIZED 4
-#define MEMC_VAL_IS_IGBINARY   5
-#define MEMC_VAL_IS_JSON       6
-#define MEMC_VAL_IS_MSGPACK    7
-
-#define MEMC_VAL_COMPRESSED          (1<<0)
-#define MEMC_VAL_COMPRESSION_ZLIB    (1<<1)
-#define MEMC_VAL_COMPRESSION_FASTLZ  (1<<2)
-
-#define MEMC_VAL_GET_FLAGS(internal_flags)               (((internal_flags) & MEMC_MASK_INTERNAL) >> 4)
-#define MEMC_VAL_SET_FLAG(internal_flags, internal_flag) ((internal_flags) |= (((internal_flag) << 4) & MEMC_MASK_INTERNAL))
-#define MEMC_VAL_HAS_FLAG(internal_flags, internal_flag) ((MEMC_VAL_GET_FLAGS(internal_flags) & (internal_flag)) == (internal_flag))
-#define MEMC_VAL_DEL_FLAG(internal_flags, internal_flag) (internal_flags &= (~(((internal_flag) << 4) & MEMC_MASK_INTERNAL)))
-
-/****************************************
-  User-defined flags
-****************************************/
-#define MEMC_VAL_GET_USER_FLAGS(flags)            ((flags & MEMC_MASK_USER) >> 16)
-#define MEMC_VAL_SET_USER_FLAGS(flags, udf_flags) ((flags) |= ((udf_flags << 16) & MEMC_MASK_USER))
-#define MEMC_VAL_USER_FLAGS_MAX                   ((1 << 16) - 1)
-
-/****************************************
-  "get" operation flags
-****************************************/
-#define MEMC_GET_PRESERVE_ORDER 1
-#define MEMC_GET_EXTENDED       2
-
-/****************************************
-  Helper macros
-****************************************/
-#define RETURN_FROM_GET RETURN_FALSE
-
-/****************************************
-  Structures and definitions
-****************************************/
-
-typedef enum {
-	MEMC_OP_SET,
-	MEMC_OP_TOUCH,
-	MEMC_OP_ADD,
-	MEMC_OP_REPLACE,
-	MEMC_OP_APPEND,
-	MEMC_OP_PREPEND
-} php_memc_write_op;
-
-typedef struct {
-
-	zend_bool is_persistent;
-	zend_bool compression_enabled;
-	zend_bool encoding_enabled;
-
-	zend_long serializer;
-	zend_long compression_type;
-
-	zend_long store_retry_count;
-	zend_long set_udf_flags;
-
-#ifdef HAVE_MEMCACHED_SASL
-	zend_bool has_sasl_data;
-#endif
-} php_memc_user_data_t;
-
-typedef struct {
-	memcached_st *memc;
-	zend_bool is_pristine;
-	int rescode;
-	int memc_errno;
-	zend_object zo;
-} php_memc_object_t;
-
-typedef struct {
-	size_t num_valid_keys;
-
-	const char **mkeys;
-	size_t *mkeys_len;
-
-	zend_string **strings;
-
-} php_memc_keys_t;
-
-typedef struct {
-	zval *object;
-	zend_fcall_info fci;
-	zend_fcall_info_cache fcc;
-} php_memc_result_callback_ctx_t;
-
-static inline php_memc_object_t *php_memc_fetch_object(zend_object *obj) {
-	return (php_memc_object_t *)((char *)obj - XtOffsetOf(php_memc_object_t, zo));
-}
-#define Z_MEMC_OBJ_P(zv) php_memc_fetch_object(Z_OBJ_P(zv));
-
-#define MEMC_METHOD_INIT_VARS                          \
-	zval*                  object         = getThis(); \
-	php_memc_object_t*     intern         = NULL;      \
-	php_memc_user_data_t*  memc_user_data = NULL;
-
-#if PHP_VERSION_ID < 80000
-#define MEMC_METHOD_FETCH_OBJECT                                                      \
-	intern = Z_MEMC_OBJ_P(object);                                                    \
-	if (!intern->memc) {                                                              \
-		php_error_docref(NULL, E_WARNING, "Memcached constructor was not called");    \
-		return;                                                                       \
-	}                                                                                 \
-	memc_user_data = (php_memc_user_data_t *) memcached_get_user_data(intern->memc);  \
-	(void)memc_user_data; /* avoid unused variable warning */
-#else
-#define MEMC_METHOD_FETCH_OBJECT                                                      \
-	intern = Z_MEMC_OBJ_P(object);                                                    \
-	if (!intern->memc) {                                                              \
-		zend_throw_error(NULL, "Memcached constructor was not called");               \
-		RETURN_THROWS();                                                                       \
-	}                                                                                 \
-	memc_user_data = (php_memc_user_data_t *) memcached_get_user_data(intern->memc);  \
-	(void)memc_user_data; /* avoid unused variable warning */
-#endif
-
-static
-zend_bool s_memc_valid_key_binary(zend_string *key)
-{
-	return memchr(ZSTR_VAL(key), '\n', ZSTR_LEN(key)) == NULL;
-}
-
-static
-zend_bool s_memc_valid_key_ascii(zend_string *key)
-{
-	const char *str = ZSTR_VAL(key);
-	size_t i, len = ZSTR_LEN(key);
-
-	for (i = 0; i < len; i++) {
-		if (!isgraph(stri) || isspace(stri))
-			return 0;
-	}
-	return 1;
-}
-
-#define MEMC_CHECK_KEY(intern, key)                                               \
-	if (UNEXPECTED(ZSTR_LEN(key) == 0 ||                                          \
-		ZSTR_LEN(key) > MEMC_OBJECT_KEY_MAX_LENGTH ||                             \
-		(memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) \
-				? !s_memc_valid_key_binary(key)                                   \
-				: !s_memc_valid_key_ascii(key)                                    \
-		))) {                                                                     \
-		intern->rescode = MEMCACHED_BAD_KEY_PROVIDED;                             \
-		RETURN_FALSE;                                                             \
-	}
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-typedef struct {
-	php_memc_proto_handler_t *handler;
-	zend_object zo;
-} php_memc_server_t;
-
-static inline php_memc_server_t *php_memc_server_fetch_object(zend_object *obj) {
-	return (php_memc_server_t *)((char *)obj - XtOffsetOf(php_memc_server_t, zo));
-}
-#define Z_MEMC_SERVER_P(zv) php_memc_server_fetch_object(Z_OBJ_P(zv))
-
-static zend_object_handlers memcached_server_object_handlers;
-static zend_class_entry *memcached_server_ce = NULL;
-#endif
-
-static zend_class_entry *memcached_ce = NULL;
-static zend_class_entry *memcached_exception_ce = NULL;
-static zend_object_handlers memcached_object_handlers;
-
-ZEND_DECLARE_MODULE_GLOBALS(php_memcached)
-
-#ifdef COMPILE_DL_MEMCACHED
-ZEND_GET_MODULE(memcached)
-#endif
-
-static PHP_INI_MH(OnUpdateCompressionType)
-{
-	if (!new_value) {
-		MEMC_G(compression_type) = COMPRESSION_TYPE_FASTLZ;
-	} else if (!strcmp(ZSTR_VAL(new_value), "fastlz")) {
-		MEMC_G(compression_type) = COMPRESSION_TYPE_FASTLZ;
-	} else if (!strcmp(ZSTR_VAL(new_value), "zlib")) {
-		MEMC_G(compression_type) = COMPRESSION_TYPE_ZLIB;
-	} else {
-		return FAILURE;
-	}
-	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
-}
-
-static PHP_INI_MH(OnUpdateSerializer)
-{
-	if (!new_value) {
-		MEMC_G(serializer_type) = SERIALIZER_DEFAULT;
-	} else if (!strcmp(ZSTR_VAL(new_value), "php")) {
-		MEMC_G(serializer_type) = SERIALIZER_PHP;
-#ifdef HAVE_MEMCACHED_IGBINARY
-	} else if (!strcmp(ZSTR_VAL(new_value), "igbinary")) {
-		MEMC_G(serializer_type) = SERIALIZER_IGBINARY;
-#endif // IGBINARY
-#ifdef HAVE_JSON_API
-	} else if (!strcmp(ZSTR_VAL(new_value), "json")) {
-		MEMC_G(serializer_type) = SERIALIZER_JSON;
-	} else if (!strcmp(ZSTR_VAL(new_value), "json_array")) {
-		MEMC_G(serializer_type) = SERIALIZER_JSON_ARRAY;
-#endif // JSON
-#ifdef HAVE_MEMCACHED_MSGPACK
-	} else if (!strcmp(ZSTR_VAL(new_value), "msgpack")) {
-		MEMC_G(serializer_type) = SERIALIZER_MSGPACK;
-#endif // msgpack
-	} else {
-		return FAILURE;
-	}
-
-	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
-}
-
-#ifdef HAVE_MEMCACHED_SESSION
-static
-PHP_INI_MH(OnUpdateDeprecatedLockValue)
-{
-	if (ZSTR_LEN(new_value) > 0 && strcmp(ZSTR_VAL(new_value), "not set")) {
-		php_error_docref(NULL, E_DEPRECATED, "memcached.sess_lock_wait and memcached.sess_lock_max_wait are deprecated. Please update your configuration to use memcached.sess_lock_wait_min, memcached.sess_lock_wait_max and memcached.sess_lock_retries");
-	}
-	return FAILURE;
-}
-
-static
-PHP_INI_MH(OnUpdateSessionPrefixString)
-{
-	if (new_value && ZSTR_LEN(new_value) > 0) {
-		if (ZSTR_LEN(new_value) > MEMCACHED_MAX_KEY) {
-			php_error_docref(NULL, E_WARNING, "memcached.sess_prefix too long (max: %d)", MEMCACHED_MAX_KEY - 1);
-			return FAILURE;
-		}
-		if (!s_memc_valid_key_ascii(new_value)) {
-			php_error_docref(NULL, E_WARNING, "memcached.sess_prefix cannot contain whitespace or control characters");
-			return FAILURE;
-		}
-	}
-	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
-}
-
-static
-PHP_INI_MH(OnUpdateConsistentHash)
-{
-	if (!new_value) {
-		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA;
-	} else if (!strcmp(ZSTR_VAL(new_value), "ketama")) {
-		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA;
-	} else if (!strcmp(ZSTR_VAL(new_value), "ketama_weighted")) {
-		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED;
-	} else {
-		php_error_docref(NULL, E_WARNING, "memcached.sess_consistent_hash_type must be ketama or ketama_weighted");
-		return FAILURE;
-	}
-	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
-}
-#endif // HAVE_MEMCACHED_SESSION
-
-#define MEMC_INI_ENTRY(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_ENTRY("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals)
-
-#define MEMC_INI_BOOL(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_BOOLEAN("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals)
-
-#define MEMC_INI_LINK(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_ENTRY_EX("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals, display_link_numbers)
-
-#define MEMC_SESSION_INI_ENTRY(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_ENTRY("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals)
-
-#define MEMC_SESSION_INI_BOOL(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_BOOLEAN("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals)
-
-#define MEMC_SESSION_INI_LINK(key, default_value, update_fn, gkey) \
-	STD_PHP_INI_ENTRY_EX("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals, display_link_numbers)
-
-
-/* {{{ INI entries */
-PHP_INI_BEGIN()
-
-#ifdef HAVE_MEMCACHED_SESSION
-	MEMC_SESSION_INI_BOOL ("locking",                "1",          OnUpdateBool,           lock_enabled)
-	MEMC_SESSION_INI_ENTRY("lock_wait_min",          "150",        OnUpdateLongGEZero,     lock_wait_min)
-	MEMC_SESSION_INI_ENTRY("lock_wait_max",          "150",        OnUpdateLongGEZero,     lock_wait_max)
-	MEMC_SESSION_INI_ENTRY("lock_retries",           "5",          OnUpdateLong,           lock_retries)
-	MEMC_SESSION_INI_ENTRY("lock_expire",            "0",          OnUpdateLongGEZero,     lock_expiration)
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX < 0x01000018
-	MEMC_SESSION_INI_BOOL ("binary_protocol",        "0",          OnUpdateBool,           binary_protocol_enabled)
-#else
-	MEMC_SESSION_INI_BOOL ("binary_protocol",        "1",          OnUpdateBool,           binary_protocol_enabled)
-#endif
-	MEMC_SESSION_INI_BOOL ("consistent_hash",        "1",          OnUpdateBool,           consistent_hash_enabled)
-	MEMC_SESSION_INI_ENTRY("consistent_hash_type",   "ketama",     OnUpdateConsistentHash, consistent_hash_name)
-	MEMC_SESSION_INI_ENTRY("number_of_replicas",     "0",          OnUpdateLongGEZero,     number_of_replicas)
-	MEMC_SESSION_INI_BOOL ("randomize_replica_read", "0",          OnUpdateBool,           randomize_replica_read_enabled)
-	MEMC_SESSION_INI_BOOL ("remove_failed_servers",  "0",          OnUpdateBool,           remove_failed_servers_enabled)
-	MEMC_SESSION_INI_ENTRY("server_failure_limit",   "0",          OnUpdateLongGEZero,     server_failure_limit)
-	MEMC_SESSION_INI_LINK ("connect_timeout",        "0",          OnUpdateLong,           connect_timeout)
-
-	MEMC_SESSION_INI_ENTRY("sasl_username",          "",           OnUpdateString,         sasl_username)
-	MEMC_SESSION_INI_ENTRY("sasl_password",          "",           OnUpdateString,         sasl_password)
-	MEMC_SESSION_INI_BOOL ("persistent",             "0",          OnUpdateBool,           persistent_enabled)
-	MEMC_SESSION_INI_ENTRY("prefix",                 "memc.sess.key.", OnUpdateSessionPrefixString,         prefix)
-	
-	/* Deprecated */
-	STD_PHP_INI_ENTRY("memcached.sess_lock_wait", "not set", PHP_INI_ALL, OnUpdateDeprecatedLockValue, no_effect, zend_php_memcached_globals, php_memcached_globals)
-	STD_PHP_INI_ENTRY("memcached.sess_lock_max_wait", "not set", PHP_INI_ALL, OnUpdateDeprecatedLockValue, no_effect, zend_php_memcached_globals, php_memcached_globals)
-	
-#endif
-
-	MEMC_INI_ENTRY("compression_type",      "fastlz",                OnUpdateCompressionType, compression_name)
-	MEMC_INI_ENTRY("compression_factor",    "1.3",                   OnUpdateReal,            compression_factor)
-	MEMC_INI_ENTRY("compression_threshold", "2000",                  OnUpdateLong,            compression_threshold)
-	MEMC_INI_ENTRY("serializer",            SERIALIZER_DEFAULT_NAME, OnUpdateSerializer,      serializer_name)
-	MEMC_INI_ENTRY("store_retry_count",     "0",                     OnUpdateLong,            store_retry_count)
-
-	MEMC_INI_BOOL ("default_consistent_hash",       "0", OnUpdateBool,       default_behavior.consistent_hash_enabled)
-	MEMC_INI_BOOL ("default_binary_protocol",       "0", OnUpdateBool,       default_behavior.binary_protocol_enabled)
-	MEMC_INI_LINK ("default_connect_timeout",       "0", OnUpdateLong,       default_behavior.connect_timeout)
-
-PHP_INI_END()
-/* }}} */
-
-#undef MEMC_INI_BOOL
-#undef MEMC_INI_LINK
-#undef MEMC_INI_ENTRY
-#undef MEMC_SESSION_INI_BOOL
-#undef MEMC_SESSION_INI_LINK
-#undef MEMC_SESSION_INI_ENTRY
-
-/****************************************
-  Forward declarations
-****************************************/
-static void php_memc_get_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-static void php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-static void php_memc_store_impl(INTERNAL_FUNCTION_PARAMETERS, int op, zend_bool by_key);
-static void php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-static void php_memc_delete_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-static void php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-static void php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
-
-/* Invoke PHP functions */
-static zend_bool s_invoke_cache_callback(zval *zobject, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_bool with_cas, zend_string *key, zval *value);
-
-/* Iterate result sets */
-typedef zend_bool (*php_memc_result_apply_fn)(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *context);
-
-static
-memcached_return php_memc_result_apply(php_memc_object_t *intern, php_memc_result_apply_fn result_apply_fn, zend_bool fetch_delay, void *context);
-
-static
-zend_bool php_memc_mget_apply(php_memc_object_t *intern, zend_string *server_key,
-								php_memc_keys_t *keys, php_memc_result_apply_fn result_apply_fn,
-								zend_bool with_cas, void *context);
-
-
-/* Callback functions for different server list iterations */
-static
-	memcached_return s_server_cursor_list_servers_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context);
-
-static
-	memcached_return s_server_cursor_version_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context);
-
-static
-	zend_bool s_memc_write_zval (php_memc_object_t *intern, php_memc_write_op op, zend_string *server_key, zend_string *key, zval *value, time_t expiration);
-
-static
-	void php_memc_destroy(memcached_st *memc, php_memc_user_data_t *memc_user_data);
-
-static
-	zend_bool s_memcached_result_to_zval(memcached_st *memc, memcached_result_st *result, zval *return_value);
-
-static
-	zend_string *s_zval_to_payload(php_memc_object_t *intern, zval *value, uint32_t *flags);
-
-static
-	void s_hash_to_keys(php_memc_keys_t *keys_out, HashTable *hash_in, zend_bool preserve_order, zval *return_value);
-
-static
-	void s_clear_keys(php_memc_keys_t *keys);
-
-
-/****************************************
-  Exported helper functions
-****************************************/
-
-zend_bool php_memc_init_sasl_if_needed()
-{
-#ifdef HAVE_MEMCACHED_SASL
-	if (MEMC_G(sasl_initialised)) {
-		return 1;
-	}
-	if (sasl_client_init(NULL) != SASL_OK) {
-		php_error_docref(NULL, E_ERROR, "Failed to initialize SASL library");
-		return 0;
-	}
-	return 1;
-#else
-	php_error_docref(NULL, E_ERROR, "Memcached not built with sasl support");
-	return 0;
-#endif
-}
-
-char *php_memc_printable_func (zend_fcall_info *fci, zend_fcall_info_cache *fci_cache)
-{
-	char *buffer = NULL;
-
-	if (fci->object) {
-		spprintf (&buffer, 0, "%s::%s", ZSTR_VAL(fci->object->ce->name), ZSTR_VAL(fci_cache->function_handler->common.function_name));
-	} else {
-		if (Z_TYPE (fci->function_name) == IS_OBJECT) {
-			spprintf (&buffer, 0, "%s", ZSTR_VAL(Z_OBJCE(fci->function_name)->name));
-		}
-		else {
-			spprintf (&buffer, 0, "%s", Z_STRVAL(fci->function_name));
-		}
-	}
-	return buffer;
-}
-
-
-/****************************************
-  Handling error codes
-****************************************/
-
-static
-zend_bool s_memcached_return_is_error(memcached_return status, zend_bool strict)
-{
-	zend_bool result = 0;
-
-	switch (status) {
-		case MEMCACHED_SUCCESS:
-		case MEMCACHED_STORED:
-		case MEMCACHED_DELETED:
-		case MEMCACHED_STAT:
-		case MEMCACHED_END:
-		case MEMCACHED_BUFFERED:
-			result = 0;
-			break;
-
-		case MEMCACHED_SOME_ERRORS:
-			result = strict;
-			break;
-
-		default:
-			result = 1;
-			break;
-	}
-	return result;
-}
-
-static
-int s_memc_status_handle_result_code(php_memc_object_t *intern, memcached_return status)
-{
-	intern->rescode = status;
-	intern->memc_errno = 0;
-
-	if (s_memcached_return_is_error(status, 1)) {
-		intern->memc_errno = memcached_last_error_errno(intern->memc);
-		return FAILURE;
-	}
-	return SUCCESS;
-}
-
-static
-void s_memc_set_status(php_memc_object_t *intern, memcached_return status, int memc_errno)
-{
-	intern->rescode = status;
-	intern->memc_errno = memc_errno;
-}
-
-static
-zend_bool s_memc_status_has_error(php_memc_object_t *intern)
-{
-	return s_memcached_return_is_error(intern->rescode, 1);
-}
-
-static
-zend_bool s_memc_status_has_result_code(php_memc_object_t *intern, memcached_return status)
-{
-	return intern->rescode == status;
-}
-
-/****************************************
-  Marshall cas tokens
-****************************************/
-
-static
-void s_uint64_to_zval (zval *target, uint64_t value)
-{
-	if (value >= ((uint64_t) LONG_MAX)) {
-		zend_string *buffer;
-#ifdef PRIu64
-		buffer = strpprintf (0, "%" PRIu64, value);
-#else
-		/* Best effort */
-		buffer = strpprintf (0, "%llu", value);
-#endif
-		ZVAL_STR(target, buffer);
-	}
-	else {
-		ZVAL_LONG (target, (zend_long) value);
-	}
-}
-
-static
-uint64_t s_zval_to_uint64 (zval *cas)
-{
-	switch (Z_TYPE_P (cas)) {
-		case IS_LONG:
-			return (uint64_t) zval_get_long (cas);
-		break;
-
-		case IS_DOUBLE:
-			if (Z_DVAL_P (cas) < 0.0)
-				return 0;
-
-			return (uint64_t) zval_get_double (cas);
-		break;
-
-		case IS_STRING:
-		{
-			uint64_t val;
-			char *end;
-
-			errno = 0;
-			val = (uint64_t) strtoull (Z_STRVAL_P (cas), &end, 0);
-
-			if (*end || (errno == ERANGE && val == UINT64_MAX) || (errno != 0 && val == 0)) {
-				php_error_docref(NULL, E_ERROR, "Failed to unmarshall cas token");
-				return 0;
-			}
-			return val;
-		}
-		break;
-	}
-	return 0;
-}
-
-
-/****************************************
-  Iterate over memcached results and mget
-****************************************/
-
-static
-memcached_return php_memc_result_apply(php_memc_object_t *intern, php_memc_result_apply_fn result_apply_fn, zend_bool fetch_delay, void *context)
-{
-	memcached_result_st result, *result_ptr;
-	memcached_return rc, status = MEMCACHED_SUCCESS;
-
-	memcached_result_create(intern->memc, &result);
-
-	do {
-		result_ptr = memcached_fetch_result(intern->memc, &result, &rc);
-
-		if (s_memcached_return_is_error(rc, 0)) {
-			status = rc;
-		}
-
-		/* nothing returned */
-		if (!result_ptr) {
-			break;
-		}
-		else {
-			zend_string *key;
-			zval val, zcas;
-			zend_bool retval;
-
-			uint64_t cas;
-			uint32_t flags;
-
-			const char *res_key;
-			size_t res_key_len;
-			
-			if (!s_memcached_result_to_zval(intern->memc, &result, &val)) {
-				if (EG(exception)) {
-					status = MEMC_RES_PAYLOAD_FAILURE;
-					memcached_quit(intern->memc);
-					break;
-				}
-				status = MEMCACHED_SOME_ERRORS;
-				continue;
-			}
-
-			res_key     = memcached_result_key_value(&result);
-			res_key_len = memcached_result_key_length(&result);
-			cas         = memcached_result_cas(&result);
-			flags       = memcached_result_flags(&result);
-
-			s_uint64_to_zval(&zcas, cas);
-
-			key = zend_string_init (res_key, res_key_len, 0);
-			retval = result_apply_fn(intern, key, &val, &zcas, flags, context);
-
-			zend_string_release(key);
-			zval_ptr_dtor(&val);
-			zval_ptr_dtor(&zcas);
-
-			/* Stop iterating on false */
-			if (!retval) {
-				if (!fetch_delay) {
-					/* Make sure we clear our results */
-					while (memcached_fetch_result(intern->memc, &result, &rc)) {}
-				}
-				break;
-			}
-		}
-	} while (result_ptr != NULL);
-
-	memcached_result_free(&result);
-	return status;
-}
-
-static
-zend_bool php_memc_mget_apply(php_memc_object_t *intern, zend_string *server_key, php_memc_keys_t *keys,
-						php_memc_result_apply_fn result_apply_fn, zend_bool with_cas, void *context)
-{
-	memcached_return status;
-	int mget_status;
-	uint64_t orig_cas_flag = 0;
-
-	// Reset status code
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	if (!keys->num_valid_keys) {
-		intern->rescode = MEMCACHED_BAD_KEY_PROVIDED;
-		return 0;
-	}
-
-	if (with_cas) {
-		orig_cas_flag = memcached_behavior_get (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS);
-
-		if (!orig_cas_flag) {
-			memcached_behavior_set (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
-		}
-	}
-
-	if (server_key) {
-		status = memcached_mget_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), keys->mkeys, keys->mkeys_len, keys->num_valid_keys);
-	} else {
-		status = memcached_mget(intern->memc, keys->mkeys, keys->mkeys_len, keys->num_valid_keys);
-	}
-
-	/* Need to handle result code before restoring cas flags, would mess up errno */
-	mget_status = s_memc_status_handle_result_code(intern, status);
-		
-	if (with_cas && !orig_cas_flag) {
-		memcached_behavior_set (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, orig_cas_flag);
-	}
-
-	/* Return on failure codes */
-	if (mget_status == FAILURE) {
-		return 0;
-	}
-
-	if (!result_apply_fn) {
-		/* no callback, for example getDelayed */
-		return 1;
-	}
-
-	status = php_memc_result_apply(intern, result_apply_fn, 0, context);
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		return 0;
-	}
-
-	return 1;
-}
-
-/****************************************
-  Invoke callbacks
-****************************************/
-
-static
-zend_bool s_invoke_new_instance_cb(zval *object, zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zend_string *persistent_id)
-{
-	zend_bool ret = 1;
-	zval retval;
-	zval params2;
-
-	ZVAL_COPY(&params0, object);
-	if (persistent_id) {
-		ZVAL_STR(&params1, zend_string_copy(persistent_id));
-	} else {
-		ZVAL_NULL(&params1);
-	}
-
-	fci->retval = &retval;
-	fci->params = params;
-	fci->param_count = 2;
-
-	if (zend_call_function(fci, fci_cache) == FAILURE) {
-		char *buf = php_memc_printable_func (fci, fci_cache);
-		php_error_docref(NULL, E_WARNING, "Failed to invoke 'on_new' callback %s()", buf);
-		efree (buf);
-		ret = 0;
-	}
-
-	zval_ptr_dtor(&params0);
-	zval_ptr_dtor(&params1);
-	zval_ptr_dtor(&retval);
-
-	return ret;
-}
-
-static
-zend_bool s_invoke_cache_callback(zval *zobject, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_bool with_cas, zend_string *key, zval *value)
-{
-	zend_bool status = 0;
-	zval params4;
-	zval retval;
-	php_memc_object_t *intern = Z_MEMC_OBJ_P(zobject);
-
-	/* Prepare params */
-	ZVAL_COPY(&params0, zobject);
-	ZVAL_STR_COPY(&params1, key);    /* key */
-	ZVAL_NEW_REF(&params2, value);   /* value */
-
-	if (with_cas) {
-		fci->param_count = 3;
-	} else {
-		ZVAL_NEW_EMPTY_REF(&params3);    /* expiration */
-		ZVAL_NULL(Z_REFVAL(params3));
-		fci->param_count = 4;
-	}
-
-	fci->retval = &retval;
-	fci->params = params;
-
-	if (zend_call_function(fci, fcc) == SUCCESS) {
-		if (zend_is_true(&retval)) {
-			time_t expiration;
-			zval *val = Z_REFVAL(params2);
-
-			if (with_cas) {
-				if (Z_TYPE_P(val) == IS_ARRAY) {
-					zval *rv = zend_hash_str_find(Z_ARRVAL_P(val), "value", sizeof("value") - 1);
-					if (rv) {
-						zval *cas = zend_hash_str_find(Z_ARRVAL_P(val), "cas", sizeof("cas") -1);
-						expiration = cas? Z_LVAL_P(cas) : 0;
-						status = s_memc_write_zval (intern, MEMC_OP_SET, NULL, key, rv, expiration);
-					}
-					/* memleak?  zval_ptr_dtor(value); */
-					ZVAL_COPY(value, val);
-				}
-			} else {
-				expiration = zval_get_long(Z_REFVAL(params3));
-				status = s_memc_write_zval (intern, MEMC_OP_SET, NULL, key, val, expiration);
-				/* memleak?  zval_ptr_dtor(value); */
-				ZVAL_COPY(value, val);
-			}
-		}
-	}
-	else {
-		s_memc_set_status(intern, MEMCACHED_NOTFOUND, 0);
-	}
-
-	zval_ptr_dtor(&params0);
-	zval_ptr_dtor(&params1);
-	zval_ptr_dtor(&params2);
-	if (!with_cas) {
-		zval_ptr_dtor(&params3);
-	}
-	zval_ptr_dtor(&retval);
-
-	return status;
-}
-
-/****************************************
-  Wrapper for setting from zval
-****************************************/
-
-static
-zend_bool s_compress_value (php_memc_compression_type compression_type, zend_string **payload_in, uint32_t *flags)
-{
-	/* status */
-	zend_bool compress_status = 0;
-	zend_string *payload = *payload_in;
-	uint32_t compression_type_flag = 0;
-
-	/* Additional 5% for the data */
-	size_t buffer_size = (size_t) (((double) ZSTR_LEN(payload) * 1.05) + 1.0);
-	char *buffer       = emalloc(buffer_size);
-
-	/* Store compressed size here */
-	size_t compressed_size = 0;
-	uint32_t original_size = ZSTR_LEN(payload);
-
-	switch (compression_type) {
-
-		case COMPRESSION_TYPE_FASTLZ:
-		{
-			compressed_size = fastlz_compress(ZSTR_VAL(payload), ZSTR_LEN(payload), buffer);
-
-			if (compressed_size > 0) {
-				compress_status = 1;
-				compression_type_flag = MEMC_VAL_COMPRESSION_FASTLZ;
-			}
-		}
-			break;
-
-		case COMPRESSION_TYPE_ZLIB:
-		{
-			compressed_size = buffer_size;
-			int status = compress((Bytef *) buffer, &compressed_size, (Bytef *) ZSTR_VAL(payload), ZSTR_LEN(payload));
-
-			if (status == Z_OK) {
-				compress_status = 1;
-				compression_type_flag = MEMC_VAL_COMPRESSION_ZLIB;
-			}
-		}
-			break;
-
-		default:
-			compress_status = 0;
-			break;
-	}
-
-	/* This means the value was too small to be compressed and ended up larger */
-	if (ZSTR_LEN(payload) <= (compressed_size * MEMC_G(compression_factor))) {
-		compress_status = 0;
-	}
-
-	/* Replace the payload with the compressed copy */
-	if (compress_status) {
-		MEMC_VAL_SET_FLAG(*flags, MEMC_VAL_COMPRESSED | compression_type_flag);
-		payload = zend_string_realloc(payload, compressed_size + sizeof(uint32_t), 0);
-
-		/* Copy the uin32_t at the beginning */
-		memcpy(ZSTR_VAL(payload), &original_size, sizeof(uint32_t));
-		memcpy(ZSTR_VAL(payload) + sizeof (uint32_t), buffer, compressed_size);
-		efree(buffer);
-
-		zend_string_forget_hash_val(payload);
-		*payload_in = payload;
-
-		return 1;
-	}
-
-	/* Original payload was not modified */
-	efree(buffer);
-	return 0;
-}
-
-static
-zend_bool s_serialize_value (php_memc_serializer_type serializer, zval *value, smart_str *buf, uint32_t *flags)
-{
-	switch (serializer) {
-
-		/*
-			Igbinary serialization
-		*/
-#ifdef HAVE_MEMCACHED_IGBINARY
-		case SERIALIZER_IGBINARY:
-		{
-			uint8_t *buffer;
-			size_t buffer_len;
-
-			if (igbinary_serialize(&buffer, &buffer_len, value) != 0) {
-				php_error_docref(NULL, E_WARNING, "could not serialize value with igbinary");
-				return 0;
-			}
-			smart_str_appendl (buf, (char *)buffer, buffer_len);
-			efree(buffer);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_IGBINARY);
-		}
-			break;
-#endif
-
-		/*
-			JSON serialization
-		*/
-#ifdef HAVE_JSON_API
-		case SERIALIZER_JSON:
-		case SERIALIZER_JSON_ARRAY:
-		{
-			php_json_encode(buf, value, 0);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_JSON);
-		}
-			break;
-#endif
-
-		/*
-			msgpack serialization
-		*/
-#ifdef HAVE_MEMCACHED_MSGPACK
-		case SERIALIZER_MSGPACK:
-			php_msgpack_serialize(buf, value);
-			if (!buf->s) {
-				php_error_docref(NULL, E_WARNING, "could not serialize value with msgpack");
-				return 0;
-			}
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_MSGPACK);
-			break;
-#endif
-
-		/*
-			PHP serialization
-		*/
-		default:
-		{
-			php_serialize_data_t var_hash;
-			PHP_VAR_SERIALIZE_INIT(var_hash);
-			php_var_serialize(buf, value, &var_hash);
-			PHP_VAR_SERIALIZE_DESTROY(var_hash);
-
-			if (!buf->s) {
-				php_error_docref(NULL, E_WARNING, "could not serialize value");
-				return 0;
-			}
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_SERIALIZED);
-		}
-			break;
-	}
-
-	/* Check for exceptions caused by serializers */
-	if (EG(exception) && buf->s->len) {
-		return 0;
-	}
-	return 1;
-}
-
-static
-zend_string *s_zval_to_payload(php_memc_object_t *intern, zval *value, uint32_t *flags)
-{
-	zend_string *payload;
-	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
-	zend_bool should_compress = memc_user_data->compression_enabled;
-
-	switch (Z_TYPE_P(value)) {
-
-		case IS_STRING:
-			payload = zval_get_string(value);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_STRING);
-			break;
-
-		case IS_LONG:
-		{
-			smart_str buffer = {0};
-			smart_str_append_long (&buffer, Z_LVAL_P(value));
-			smart_str_0(&buffer);
-			payload = buffer.s;
-
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_LONG);
-			should_compress = 0;
-		}
-			break;
-
-		case IS_DOUBLE:
-		{
-			char buffer40;
-			php_memcached_g_fmt(buffer, Z_DVAL_P(value));
-			payload = zend_string_init (buffer, strlen (buffer), 0);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_DOUBLE);
-			should_compress = 0;
-		}
-			break;
-
-		case IS_TRUE:
-			payload = zend_string_init ("1", 1, 0);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_BOOL);
-			should_compress = 0;
-			break;
-
-		case IS_FALSE:
-			payload = zend_string_alloc (0, 0);
-			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_BOOL);
-			should_compress = 0;
-			break;
-
-		default:
-		{
-			smart_str buffer = {0};
-
-			if (!s_serialize_value (memc_user_data->serializer, value, &buffer, flags)) {
-				smart_str_free(&buffer);
-				return NULL;
-			}
-			payload = buffer.s;
-		}
-			break;
-	}
-
-	/* turn off compression for values below the threshold */
-	if (ZSTR_LEN(payload) == 0 || ZSTR_LEN(payload) < MEMC_G(compression_threshold)) {
-		should_compress = 0;
-	}
-
-	/* If we have compression flag, compress the value */
-	if (should_compress) {
-		/* s_compress_value() will always leave a valid payload, even if that payload
-		 * did not actually get compressed. The flags will be set according to the
-		 * to the compression type or no compression.
-		 *
-		 * No need to check the return value because the payload is always valid.
-		 */
-		(void)s_compress_value (memc_user_data->compression_type, &payload, flags);
-	}
-
-	if (memc_user_data->set_udf_flags >= 0) {
-		MEMC_VAL_SET_USER_FLAGS(*flags, ((uint32_t) memc_user_data->set_udf_flags));
-	}
-
-	return payload;
-}
-
-static
-zend_bool s_should_retry_write (php_memc_object_t *intern, memcached_return status)
-{
-	if (memcached_server_count (intern->memc) == 0) {
-		return 0;
-	}
-
-	return s_memcached_return_is_error (status, 1);
-}
-
-static
-zend_bool s_memc_write_zval (php_memc_object_t *intern, php_memc_write_op op, zend_string *server_key, zend_string *key, zval *value, time_t expiration)
-{
-	uint32_t flags = 0;
-	zend_string *payload = NULL;
-	memcached_return status = 0;
-	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
-	zend_long retries = memc_user_data->store_retry_count;
-
-	if (value) {
-		payload = s_zval_to_payload(intern, value, &flags);
-
-		if (!payload) {
-			s_memc_set_status(intern, MEMC_RES_PAYLOAD_FAILURE, 0);
-			return 0;
-		}
-	}
-
-#define memc_write_using_fn(fn_name) payload ? fn_name(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags) : MEMC_RES_PAYLOAD_FAILURE;
-#define memc_write_using_fn_by_key(fn_name) payload ? fn_name(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags) : MEMC_RES_PAYLOAD_FAILURE;
-
-	if (server_key) {
-		switch (op) {
-			case MEMC_OP_SET:
-				status = memc_write_using_fn_by_key(memcached_set_by_key);
-			break;
-
-			case MEMC_OP_TOUCH:
-				status = php_memcached_touch_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), expiration);
-			break;
-			
-			case MEMC_OP_ADD:
-				status = memc_write_using_fn_by_key(memcached_add_by_key);
-			break;
-			
-			case MEMC_OP_REPLACE:
-				status = memc_write_using_fn_by_key(memcached_replace_by_key);
-			break;
-			
-			case MEMC_OP_APPEND:
-				status = memc_write_using_fn_by_key(memcached_append_by_key);
-			break;
-
-			case MEMC_OP_PREPEND:
-				status = memc_write_using_fn_by_key(memcached_prepend_by_key);
-			break;
-		}
-
-		if (status == MEMCACHED_END) {
-			status = MEMCACHED_SUCCESS;
-		}
-	}
-	else {
-retry:
-		switch (op) {
-			case MEMC_OP_SET:
-				status = memc_write_using_fn(memcached_set);
-			break;
-
-			case MEMC_OP_TOUCH:
-				status = php_memcached_touch(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), expiration);
-			break;
-			
-			case MEMC_OP_ADD:
-				status = memc_write_using_fn(memcached_add);
-			break;
-			
-			case MEMC_OP_REPLACE:
-				status = memc_write_using_fn(memcached_replace);
-			break;
-			
-			case MEMC_OP_APPEND:
-				status = memc_write_using_fn(memcached_append);
-			break;
-
-			case MEMC_OP_PREPEND:
-				status = memc_write_using_fn(memcached_prepend);
-			break;
-		}
-		if (status == MEMCACHED_END) {
-			status = MEMCACHED_SUCCESS;
-		}
-	}
-
-	if (s_should_retry_write (intern, status) && retries-- > 0) {
-		goto retry;
-	}
-
-#undef memc_write_using_fn
-#undef memc_write_using_fn_by_key
-
-	if (payload) {
-		zend_string_release(payload);
-	}
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		return 0;
-	}
-	return 1;
-}
-
-
-/****************************************
-  Methods
-****************************************/
-
-
-/* {{{ Memcached::__construct(string persistent_id, callback on_new, string connection_str))
-   Creates a Memcached object, optionally using persistent memcache connection */
-static PHP_METHOD(Memcached, __construct)
-{
-	php_memc_object_t *intern;
-	php_memc_user_data_t *memc_user_data;
-
-	zend_string *persistent_id = NULL;
-	zend_string *conn_str = NULL;
-	zend_string *plist_key = NULL;
-	zend_fcall_info fci = {0};
-	zend_fcall_info_cache fci_cache;
-
-	zend_bool is_persistent = 0;
-
-	/* "|S!f!S" */
-	ZEND_PARSE_PARAMETERS_START(0, 3)
-	        Z_PARAM_OPTIONAL
-	        Z_PARAM_STR_EX(persistent_id, 1, 0)
-	        Z_PARAM_FUNC_EX(fci, fci_cache, 1, 0)
-	        Z_PARAM_STR(conn_str)
-	ZEND_PARSE_PARAMETERS_END();
-
-	intern = Z_MEMC_OBJ_P(getThis());
-	intern->is_pristine = 1;
-
-	if (persistent_id && persistent_id->len) {
-		zend_resource *le;
-
-		plist_key = zend_string_alloc(sizeof("memcached:id=") + persistent_id->len - 1, 0);
-		snprintf(ZSTR_VAL(plist_key), plist_key->len + 1, "memcached:id=%s", ZSTR_VAL(persistent_id));
-
-		if ((le = zend_hash_find_ptr(&EG(persistent_list), plist_key)) != NULL) {
-			if (le->type == php_memc_list_entry()) {
-				intern->memc = le->ptr;
-				intern->is_pristine = 0;
-				zend_string_release (plist_key);
-				return;
-			}
-		}
-		is_persistent = 1;
-	}
-
-	if (conn_str && conn_str->len > 0) {
-		intern->memc = memcached (ZSTR_VAL(conn_str), ZSTR_LEN(conn_str));
-	}
-	else {
-		intern->memc = memcached (NULL, 0);
-	}
-
-	if (!intern->memc) {
-		php_error_docref(NULL, E_ERROR, "Failed to allocate memory for memcached structure");
-		/* never reached */
-	}
-
-	memc_user_data                    = pecalloc (1, sizeof(*memc_user_data), is_persistent);
-	memc_user_data->serializer        = MEMC_G(serializer_type);
-	memc_user_data->compression_type  = MEMC_G(compression_type);
-	memc_user_data->compression_enabled = 1;
-	memc_user_data->encoding_enabled  = 0;
-	memc_user_data->store_retry_count = MEMC_G(store_retry_count);
-	memc_user_data->set_udf_flags     = -1;
-	memc_user_data->is_persistent     = is_persistent;
-
-	memcached_set_user_data(intern->memc, memc_user_data);
-
-	/* Set default behaviors */
-	if (MEMC_G(default_behavior.consistent_hash_enabled)) {
-		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT);
-		if (rc != MEMCACHED_SUCCESS) {
-			php_error_docref(NULL, E_WARNING, "Failed to turn on consistent hash: %s", memcached_strerror(intern->memc, rc));
-		}
-	}
-
-	if (MEMC_G(default_behavior.binary_protocol_enabled)) {
-		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
-		if (rc != MEMCACHED_SUCCESS) {
-			php_error_docref(NULL, E_WARNING, "Failed to turn on binary protocol: %s", memcached_strerror(intern->memc, rc));
-		}
-		/* Also enable TCP_NODELAY when binary protocol is enabled */
-		rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
-		if (rc != MEMCACHED_SUCCESS) {
-			php_error_docref(NULL, E_WARNING, "Failed to set TCP_NODELAY: %s", memcached_strerror(intern->memc, rc));
-		}
-	}
-
-	if (MEMC_G(default_behavior.connect_timeout)) {
-		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, MEMC_G(default_behavior.connect_timeout));
-		if (rc != MEMCACHED_SUCCESS) {
-			php_error_docref(NULL, E_WARNING, "Failed to set connect timeout: %s", memcached_strerror(intern->memc, rc));
-		}
-	}
-
-	if (fci.size) {
-		if (!s_invoke_new_instance_cb(getThis(), &fci, &fci_cache, persistent_id) || EG(exception)) {
-			/* error calling or exception thrown from callback */
-			if (plist_key) {
-				zend_string_release(plist_key);
-			}
-			/*
-				Setting intern->memc null prevents object destruction from freeing the memcached_st
-				We free it manually here because it might be persistent and has not been
-				registered to persistent_list yet
-			*/
-			php_memc_destroy(intern->memc, memc_user_data);
-			intern->memc = NULL;
-			return;
-		}
-	}
-
-	if (plist_key) {
-		zend_resource le;
-
-		le.type = php_memc_list_entry();
-		le.ptr  = intern->memc;
-
-		GC_SET_REFCOUNT(&le, 1);
-
-		/* plist_key is not a persistent allocated key, thus we use str_update here */
-		if (zend_hash_str_update_mem(&EG(persistent_list), ZSTR_VAL(plist_key), ZSTR_LEN(plist_key), &le, sizeof(le)) == NULL) {
-			zend_string_release(plist_key);
-			php_error_docref(NULL, E_ERROR, "could not register persistent entry");
-			/* not reached */
-		}
-		zend_string_release(plist_key);
-	}
-}
-/* }}} */
-
-
-
-static
-void s_hash_to_keys(php_memc_keys_t *keys_out, HashTable *hash_in, zend_bool preserve_order, zval *return_value)
-{
-	size_t idx = 0, alloc_count;
-	zval *zv;
-
-	keys_out->num_valid_keys = 0;
-
-	alloc_count = zend_hash_num_elements(hash_in);
-	if (!alloc_count) {
-		return;
-	}
-	keys_out->mkeys     = ecalloc (alloc_count, sizeof (char *));
-	keys_out->mkeys_len = ecalloc (alloc_count, sizeof (size_t));
-	keys_out->strings   = ecalloc (alloc_count, sizeof (zend_string *));
-
-	ZEND_HASH_FOREACH_VAL(hash_in, zv) {
-		zend_string *key = zval_get_string(zv);
-
-		if (preserve_order && return_value) {
-			add_assoc_null_ex(return_value, ZSTR_VAL(key), ZSTR_LEN(key));
-		}
-
-		if (ZSTR_LEN(key) > 0 && ZSTR_LEN(key) < MEMCACHED_MAX_KEY) {
-			keys_out->mkeysidx     = ZSTR_VAL(key);
-			keys_out->mkeys_lenidx = ZSTR_LEN(key);
-
-			keys_out->stringsidx = key;
-			idx++;
-		}
-		else {
-			zend_string_release (key);
-		}
-
-	} ZEND_HASH_FOREACH_END();
-
-	if (!idx) {
-		efree (keys_out->mkeys);
-		efree (keys_out->mkeys_len);
-		efree (keys_out->strings);
-	}
-	keys_out->num_valid_keys = idx;
-}
-
-static
-void s_key_to_keys(php_memc_keys_t *keys_out, zend_string *key)
-{
-	zval zv_keys;
-
-	array_init(&zv_keys);
-	add_next_index_str(&zv_keys, zend_string_copy(key));
-
-	s_hash_to_keys(keys_out, Z_ARRVAL(zv_keys), 0, NULL);
-	zval_ptr_dtor(&zv_keys);
-}
-
-static
-void s_clear_keys(php_memc_keys_t *keys)
-{
-	size_t i;
-
-	if (!keys->num_valid_keys) {
-		return;
-	}
-
-	for (i = 0; i < keys->num_valid_keys; i++) {
-		zend_string_release (keys->stringsi);
-	}
-	efree(keys->strings);
-	efree(keys->mkeys);
-	efree(keys->mkeys_len);
-}
-
-typedef struct {
-	zend_bool extended;
-	zval *return_value;
-} php_memc_get_ctx_t;
-
-static
-zend_bool s_get_apply_fn(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
-{
-	php_memc_get_ctx_t *context = (php_memc_get_ctx_t *) in_context;
-
-	if (context->extended) {
-		Z_TRY_ADDREF_P(value);
-		Z_TRY_ADDREF_P(cas);
-
-		array_init (context->return_value);
-		add_assoc_zval (context->return_value, "value", value);
-		add_assoc_zval (context->return_value, "cas",   cas);
-		add_assoc_long (context->return_value, "flags", (zend_long) MEMC_VAL_GET_USER_FLAGS(flags));
-	}
-	else {
-		ZVAL_COPY(context->return_value, value);
-	}
-	return 0; /* Stop after one */
-}
-
-static
-void php_memc_get_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	php_memc_get_ctx_t context = {0};
-	php_memc_keys_t keys = {0};
-	zend_long get_flags = 0;
-	zend_string *key;
-	zend_string *server_key = NULL;
-	zend_bool mget_status;
-	memcached_return status = MEMCACHED_SUCCESS;
-	zend_fcall_info fci = empty_fcall_info;
-	zend_fcall_info_cache fcc = empty_fcall_info_cache;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		/* "SS|f!l" */
-		ZEND_PARSE_PARAMETERS_START(2, 4)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
-		        Z_PARAM_LONG(get_flags)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "S|f!l" */
-		ZEND_PARSE_PARAMETERS_START(1, 3)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
-		        Z_PARAM_LONG(get_flags)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-
-	context.extended = (get_flags & MEMC_GET_EXTENDED);
-
-	context.return_value = return_value;
-
-	s_key_to_keys(&keys, key);
-	mget_status = php_memc_mget_apply(intern, server_key, &keys, s_get_apply_fn, context.extended, &context);
-	s_clear_keys(&keys);
-
-	if (!mget_status) {
-		if (s_memc_status_has_result_code(intern, MEMCACHED_NOTFOUND) && fci.size > 0) {
-			status = s_invoke_cache_callback(object, &fci, &fcc, context.extended, key, return_value);
-
-			if (!status) {
-				zval_ptr_dtor(return_value);
-				RETURN_FROM_GET;
-			}
-		}
-	}
-
-	if (s_memc_status_has_error(intern)) {
-		zval_ptr_dtor(return_value);
-		RETURN_FROM_GET;
-	}
-}
-
-/* {{{ Memcached::get(string key , mixed callback , int get_flags = 0)
-   Returns a value for the given key or false */
-PHP_METHOD(Memcached, get)
-{
-	php_memc_get_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::getByKey(string server_key, string key , mixed callback , int get_flags = 0)
-   Returns a value for key from the server identified by the server key or false */
-PHP_METHOD(Memcached, getByKey)
-{
-	php_memc_get_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-static
-zend_bool s_get_multi_apply_fn(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
-{
-	php_memc_get_ctx_t *context = (php_memc_get_ctx_t *) in_context;
-
-	Z_TRY_ADDREF_P(value);
-
-	if (context->extended) {
-		zval node;
-
-		Z_TRY_ADDREF_P(cas);
-
-		array_init(&node);
-		add_assoc_zval(&node, "value", value);
-		add_assoc_zval(&node, "cas",   cas);
-		add_assoc_long(&node, "flags", (zend_long) MEMC_VAL_GET_USER_FLAGS(flags));
-
-		zend_symtable_update(Z_ARRVAL_P(context->return_value), key, &node);
-	}
-	else {
-		zend_symtable_update(Z_ARRVAL_P(context->return_value), key, value);
-	}
-	return 1;
-}
-
-/* {{{ -- php_memc_getMulti_impl */
-static void php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	php_memc_get_ctx_t context;
-	php_memc_keys_t keys_out;
-
-	zval *keys = NULL;
-	zend_string *server_key = NULL;
-	zend_long flags = 0;
-	MEMC_METHOD_INIT_VARS;
-	zend_bool retval, preserve_order;
-
-	if (by_key) {
-		/* "Sa|l" */
-		ZEND_PARSE_PARAMETERS_START(2, 3)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_ARRAY(keys)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(flags)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "a|l" */
-		ZEND_PARSE_PARAMETERS_START(1, 2)
-		        Z_PARAM_ARRAY(keys)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(flags)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	array_init(return_value);
-	if (zend_hash_num_elements(Z_ARRVAL_P(keys)) == 0) {
-		/* BC compatible */
-		s_memc_set_status(intern, MEMCACHED_NOTFOUND, 0);
-		return;
-	}
-
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	preserve_order = (flags & MEMC_GET_PRESERVE_ORDER);
-	s_hash_to_keys(&keys_out, Z_ARRVAL_P(keys), preserve_order, return_value);
-
-	context.extended = (flags & MEMC_GET_EXTENDED);
-	context.return_value = return_value;
-
-	retval = php_memc_mget_apply(intern, server_key, &keys_out, s_get_multi_apply_fn, context.extended, &context);
-
-	s_clear_keys(&keys_out);
-
-	if (!retval && (s_memc_status_has_result_code(intern, MEMCACHED_NOTFOUND) || s_memc_status_has_result_code(intern, MEMCACHED_SOME_ERRORS))) {
-		return;
-	}
-
-	if (!retval || EG(exception)) {
-		zval_dtor(return_value);
-		RETURN_FROM_GET;
-	}
-}
-/* }}} */
-
-/* {{{ Memcached::getMulti(array keys, long flags = 0 )
-   Returns values for the given keys or false */
-PHP_METHOD(Memcached, getMulti)
-{
-	php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::getMultiByKey(string server_key, array keys, long flags = 0 )
-   Returns values for the given keys from the server identified by the server key or false */
-PHP_METHOD(Memcached, getMultiByKey)
-{
-	php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::getDelayed(array keys , bool with_cas , mixed callback  )
-   Sends a request for the given keys and returns immediately */
-PHP_METHOD(Memcached, getDelayed)
-{
-	php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::getDelayedByKey(string server_key, array keys , bool with_cas , mixed callback  )
-   Sends a request for the given keys from the server identified by the server key and returns immediately */
-PHP_METHOD(Memcached, getDelayedByKey)
-{
-	php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-
-static
-void s_create_result_array(zend_string *key, zval *value, zval *cas, uint32_t flags, zval *return_value)
-{
-	Z_TRY_ADDREF_P(value);
-	Z_TRY_ADDREF_P(cas);
-
-	add_assoc_str_ex(return_value, ZEND_STRL("key"), zend_string_copy(key));
-	add_assoc_zval_ex(return_value, ZEND_STRL("value"), value);
-
-	if (Z_LVAL_P(cas)) {
-		/* BC compatible */
-		add_assoc_zval_ex(return_value, ZEND_STRL("cas"), cas);
-		add_assoc_long_ex(return_value, ZEND_STRL("flags"), MEMC_VAL_GET_USER_FLAGS(flags));
-	}
-}
-
-static
-zend_bool s_result_callback_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
-{
-	zend_bool status = 1;
-	zval params2;
-	zval retval;
-	php_memc_result_callback_ctx_t *context = (php_memc_result_callback_ctx_t *) in_context;
-
-	ZVAL_COPY(&params0, context->object);
-	array_init(&params1);
-
-	s_create_result_array(key, value, cas, flags, &params1);
-
-	context->fci.retval = &retval;
-	context->fci.params = params;
-	context->fci.param_count = 2;
-	
-	if (zend_call_function(&context->fci, &context->fcc) == FAILURE) {
-		php_error_docref(NULL, E_WARNING, "could not invoke result callback");
-		status = 0;
-	}
-
-	zval_ptr_dtor(&retval);
-
-	zval_ptr_dtor(&params0);
-	zval_ptr_dtor(&params1);
-
-	return status;
-}
-
-/* {{{ -- php_memc_getDelayed_impl */
-static void php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	php_memc_keys_t keys_out = {0};
-
-	zval *keys = NULL;
-	zend_string *server_key = NULL;
-	zend_bool with_cas = 0;
-
-	zend_fcall_info fci = empty_fcall_info;
-	zend_fcall_info_cache fcc = empty_fcall_info_cache;
-	memcached_return status = MEMCACHED_SUCCESS;
-	MEMC_METHOD_INIT_VARS;
-
-
-	if (by_key) {
-		/* "Sa/|bf!" */
-		ZEND_PARSE_PARAMETERS_START(2, 4)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_ARRAY_EX(keys, 0, 1)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_BOOL(with_cas)
-		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "a/|bf!" */
-		ZEND_PARSE_PARAMETERS_START(1, 3)
-		        Z_PARAM_ARRAY_EX(keys, 0, 1)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_BOOL(with_cas)
-		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	s_hash_to_keys(&keys_out, Z_ARRVAL_P(keys), 0, NULL);
-
-	if (fci.size > 0) {
-		php_memc_result_callback_ctx_t context = {
-			getThis(), fci, fcc
-		};
-		status = php_memc_mget_apply(intern, server_key, &keys_out, &s_result_callback_apply, with_cas, (void *) &context);
-	}
-	else {
-		status = php_memc_mget_apply(intern, server_key, &keys_out, NULL, with_cas, NULL);
-	}
-
-	s_clear_keys(&keys_out);
-	RETURN_BOOL(status);
-}
-/* }}} */
-
-static
-zend_bool s_fetch_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
-{
-	zval *return_value = (zval *) in_context;
-	s_create_result_array(key, value, cas, flags, return_value);
-
-	return 0; // stop iterating after one
-}
-
-/* {{{ Memcached::fetch()
-   Returns the next result from a previous delayed request */
-PHP_METHOD(Memcached, fetch)
-{
-	memcached_return status = MEMCACHED_SUCCESS;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	array_init(return_value);
-	status = php_memc_result_apply(intern, s_fetch_apply, 1, return_value);
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		zval_ptr_dtor(return_value);
-		RETURN_FROM_GET;
-	}
-}
-/* }}} */
-
-static
-zend_bool s_fetch_all_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
-{
-	zval zv;
-	zval *return_value = (zval *) in_context;
-
-	array_init (&zv);
-	s_create_result_array(key, value, cas, flags, &zv);
-
-	add_next_index_zval(return_value, &zv);
-	return 1;
-}
-
-/* {{{ Memcached::fetchAll()
-   Returns all the results from a previous delayed request */
-PHP_METHOD(Memcached, fetchAll)
-{
-	memcached_return status = MEMCACHED_SUCCESS;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	array_init(return_value);
-	status = php_memc_result_apply(intern, s_fetch_all_apply, 0, return_value);
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		zval_dtor(return_value);
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ Memcached::set(string key, mixed value , int expiration )
-   Sets the value for the given key */
-PHP_METHOD(Memcached, set)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_SET, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::setByKey(string server_key, string key, mixed value , int expiration )
-   Sets the value for the given key on the server identified by the server key */
-PHP_METHOD(Memcached, setByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_SET, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::touch(string key, , int expiration )
-   Sets a new expiration for the given key */
-PHP_METHOD(Memcached, touch)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_TOUCH, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::touchbyKey(string key, , int expiration )
-   Sets a new expiration for the given key */
-PHP_METHOD(Memcached, touchByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_TOUCH, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::setMulti(array items , int expiration  )
-   Sets the keys/values specified in the items array */
-PHP_METHOD(Memcached, setMulti)
-{
-	php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::setMultiByKey(string server_key, array items , int expiration )
-   Sets the keys/values specified in the items array on the server identified by the given server key */
-PHP_METHOD(Memcached, setMultiByKey)
-{
-	php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-/* {{{ -- php_memc_setMulti_impl */
-static void php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	zval *entries;
-	zend_string *server_key = NULL;
-	zend_long expiration = 0;
-	zval *value;
-	zend_string *skey;
-	zend_ulong num_key;
-	int tmp_len = 0;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		/* "Sa|ll" */
-		ZEND_PARSE_PARAMETERS_START(2, 3)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_ARRAY(entries)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "a|ll" */
-		ZEND_PARSE_PARAMETERS_START(1, 2)
-		        Z_PARAM_ARRAY(entries)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	ZEND_HASH_FOREACH_KEY_VAL (Z_ARRVAL_P(entries), num_key, skey, value) {
-		zend_string *str_key = NULL;
-
-		if (skey) {
-			str_key = skey;
-		}
-		else {
-			char tmp_key64;
-
-			tmp_len = snprintf(tmp_key, sizeof(tmp_key) - 1, "%ld", (long)num_key);
-			str_key = zend_string_init(tmp_key, tmp_len, 0);
-		}
-
-		/* If this failed to write a value, intern stores the error for the return value */
-		s_memc_write_zval (intern, MEMC_OP_SET, server_key, str_key, value, expiration);
-
-		if (!skey) {
-			zend_string_release (str_key);
-		}
-
-	} ZEND_HASH_FOREACH_END();
-
-	RETURN_BOOL(!s_memc_status_has_error(intern));
-}
-/* }}} */
-
-/* {{{ Memcached::add(string key, mixed value , int expiration )
-   Sets the value for the given key, failing if the key already exists */
-PHP_METHOD(Memcached, add)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_ADD, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::addByKey(string server_key, string key, mixed value , int expiration )
-   Sets the value for the given key on the server identified by the sever key, failing if the key already exists */
-PHP_METHOD(Memcached, addByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_ADD, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::append(string key, mixed value)
-   Appends the value to existing one for the key */
-PHP_METHOD(Memcached, append)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_APPEND, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::appendByKey(string server_key, string key, mixed value)
-   Appends the value to existing one for the key on the server identified by the server key */
-PHP_METHOD(Memcached, appendByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_APPEND, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::prepend(string key, mixed value)
-   Prepends the value to existing one for the key */
-PHP_METHOD(Memcached, prepend)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_PREPEND, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::prependByKey(string server_key, string key, mixed value)
-   Prepends the value to existing one for the key on the server identified by the server key */
-PHP_METHOD(Memcached, prependByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_PREPEND, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::replace(string key, mixed value , int expiration )
-   Replaces the value for the given key, failing if the key doesn't exist */
-PHP_METHOD(Memcached, replace)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_REPLACE, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::replaceByKey(string server_key, string key, mixed value , int expiration )
-   Replaces the value for the given key on the server identified by the server key, failing if the key doesn't exist */
-PHP_METHOD(Memcached, replaceByKey)
-{
-	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_REPLACE, 1);
-}
-/* }}} */
-
-/* {{{ -- php_memc_store_impl */
-static void php_memc_store_impl(INTERNAL_FUNCTION_PARAMETERS, int op, zend_bool by_key)
-{
-	zend_string *key;
-	zend_string *server_key = NULL;
-	zend_string *s_value;
-	zval s_zvalue;
-	zval *value = NULL;
-	zend_long expiration = 0;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
-			/* "SSS" */
-			ZEND_PARSE_PARAMETERS_START(3, 3)
-			        Z_PARAM_STR(server_key)
-			        Z_PARAM_STR(key)
-			        Z_PARAM_STR(s_value)
-			ZEND_PARSE_PARAMETERS_END();
-			value = &s_zvalue;
-			ZVAL_STR(value, s_value);
-		} else if (op == MEMC_OP_TOUCH) {
-			/* "SS|l" */
-			ZEND_PARSE_PARAMETERS_START(2, 3)
-			        Z_PARAM_STR(server_key)
-			        Z_PARAM_STR(key)
-				Z_PARAM_OPTIONAL
-				Z_PARAM_LONG(expiration)
-			ZEND_PARSE_PARAMETERS_END();
-		} else {
-			/* "SSz|l" */
-			ZEND_PARSE_PARAMETERS_START(3, 4)
-			        Z_PARAM_STR(server_key)
-			        Z_PARAM_STR(key)
-			        Z_PARAM_ZVAL(value)
-				Z_PARAM_OPTIONAL
-				Z_PARAM_LONG(expiration)
-			ZEND_PARSE_PARAMETERS_END();
-		}
-	} else {
-		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
-			/* "SS" */
-			ZEND_PARSE_PARAMETERS_START(2, 2)
-			        Z_PARAM_STR(key)
-			        Z_PARAM_STR(s_value)
-			ZEND_PARSE_PARAMETERS_END();
-			value = &s_zvalue;
-			ZVAL_STR(value, s_value);
-		} else if (op == MEMC_OP_TOUCH) {
-			/* "S|l */
-			ZEND_PARSE_PARAMETERS_START(1, 2)
-			        Z_PARAM_STR(key)
-			        Z_PARAM_OPTIONAL
-			        Z_PARAM_LONG(expiration)
-			ZEND_PARSE_PARAMETERS_END();
-		} else {
-			/* "Sz|l" */
-			ZEND_PARSE_PARAMETERS_START(2, 3)
-			        Z_PARAM_STR(key)
-			        Z_PARAM_ZVAL(value)
-			        Z_PARAM_OPTIONAL
-			        Z_PARAM_LONG(expiration)
-			ZEND_PARSE_PARAMETERS_END();
-		}
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-
-	if (memc_user_data->compression_enabled) {
-		/*
-		 * When compression is enabled, we cannot do appends/prepends because that would
-		 * corrupt the compressed values. It is up to the user to fetch the value,
-		 * append/prepend new data, and store it again.
-		 */
-		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
-			php_error_docref(NULL, E_WARNING, "cannot append/prepend with compression turned on");
-			RETURN_NULL();
-		}
-	}
-
-	if (!s_memc_write_zval (intern, op, server_key, key, value, expiration)) {
-		RETURN_FALSE;
-	}
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ -- php_memc_cas_impl */
-static void php_memc_cas_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	zval *zv_cas;
-	uint64_t cas;
-	zend_string *key;
-	zend_string *server_key = NULL;
-	zval *value;
-	zend_long expiration = 0;
-	zend_string *payload;
-	uint32_t flags = 0;
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		/* "zSSz|l" */
-		ZEND_PARSE_PARAMETERS_START(4, 5)
-		        Z_PARAM_ZVAL(zv_cas)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_ZVAL(value)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "zSz|l" */
-		ZEND_PARSE_PARAMETERS_START(3, 4)
-		        Z_PARAM_ZVAL(zv_cas)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_ZVAL(value)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-
-	cas = s_zval_to_uint64(zv_cas);
-
-	payload = s_zval_to_payload(intern, value, &flags);
-	if (payload == NULL) {
-		intern->rescode = MEMC_RES_PAYLOAD_FAILURE;
-		RETURN_FALSE;
-	}
-
-	if (by_key) {
-		status = memcached_cas_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags, cas);
-	} else {
-		status = memcached_cas(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags, cas);
-	}
-
-	zend_string_release(payload);
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::cas(double cas_token, string key, mixed value , int expiration )
-   Sets the value for the given key, failing if the cas_token doesn't match the one in memcache */
-PHP_METHOD(Memcached, cas)
-{
-	php_memc_cas_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::casByKey(double cas_token, string server_key, string key, mixed value , int expiration )
-   Sets the value for the given key on the server identified by the server_key, failing if the cas_token doesn't match the one in memcache */
-PHP_METHOD(Memcached, casByKey)
-{
-	php_memc_cas_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::delete(string key , int time )
-   Deletes the given key */
-PHP_METHOD(Memcached, delete)
-{
-	php_memc_delete_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::deleteMulti(array keys , int time )
-   Deletes the given keys */
-PHP_METHOD(Memcached, deleteMulti)
-{
-	php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::deleteByKey(string server_key, string key , int time )
-   Deletes the given key from the server identified by the server key */
-PHP_METHOD(Memcached, deleteByKey)
-{
-	php_memc_delete_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::deleteMultiByKey(array keys , int time )
-   Deletes the given key from the server identified by the server key */
-PHP_METHOD(Memcached, deleteMultiByKey)
-{
-	php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
-}
-/* }}} */
-
-/* {{{ -- php_memc_delete_impl */
-static void php_memc_delete_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	zend_string *key, *server_key;
-	zend_long expiration = 0;
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		/* "SS|l" */
-		ZEND_PARSE_PARAMETERS_START(2, 3)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "S|l" */
-		ZEND_PARSE_PARAMETERS_START(1, 2)
-		        Z_PARAM_STR(key)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-		server_key = key;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-
-	if (by_key) {
-		status = memcached_delete_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key),
-									 ZSTR_LEN(key), expiration);
-	} else {
-		status = memcached_delete(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), expiration);
-	}
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ -- php_memc_deleteMulti_impl */
-static void php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
-{
-	zval *entries, *zv, ret;
-	zend_string *server_key = NULL;
-	zend_long expiration = 0;
-	zend_string *entry;
-
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	if (by_key) {
-		/* "Sa/|l" */
-		ZEND_PARSE_PARAMETERS_START(2, 3)
-		        Z_PARAM_STR(server_key)
-		        Z_PARAM_ARRAY_EX(entries, 0, 1)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "a/|l" */
-		ZEND_PARSE_PARAMETERS_START(1, 2)
-		        Z_PARAM_ARRAY_EX(entries, 0, 1)
-		        Z_PARAM_OPTIONAL
-		        Z_PARAM_LONG(expiration)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	array_init(return_value);
-	ZEND_HASH_FOREACH_VAL (Z_ARRVAL_P(entries), zv) {
-		entry = zval_get_string(zv);
-
-		if (ZSTR_LEN(entry) == 0) {
-			zend_string_release(entry);
-			continue;
-		}
-
-		if (by_key) {
-			status = memcached_delete_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(entry), ZSTR_LEN(entry), expiration);
-		} else {
-			status = memcached_delete_by_key(intern->memc, ZSTR_VAL(entry), ZSTR_LEN(entry), ZSTR_VAL(entry), ZSTR_LEN(entry), expiration);
-		}
-
-		if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-			ZVAL_LONG(&ret, status);
-		} else {
-			ZVAL_TRUE(&ret);
-		}
-		zend_symtable_update(Z_ARRVAL_P(return_value), entry, &ret);
-		zend_string_release(entry);
-	} ZEND_HASH_FOREACH_END();
-
-	return;
-}
-/* }}} */
-
-/* {{{ -- php_memc_incdec_impl */
-static void php_memc_incdec_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key, zend_bool incr)
-{
-	zend_string *key, *server_key = NULL;
-	zend_long offset = 1;
-	zend_long expiry = 0;
-	zend_long initial = 0;
-	uint64_t value = UINT64_MAX;
-	memcached_return status;
-	int n_args = ZEND_NUM_ARGS();
-
-	MEMC_METHOD_INIT_VARS;
-
-	if (!by_key) {
-		/* "S|lll" */
-		ZEND_PARSE_PARAMETERS_START(1, 4)
-			Z_PARAM_STR(key)
-			Z_PARAM_OPTIONAL
-			Z_PARAM_LONG(offset)
-			Z_PARAM_LONG(initial)
-			Z_PARAM_LONG(expiry)
-		ZEND_PARSE_PARAMETERS_END();
-	} else {
-		/* "SS|lll" */
-		ZEND_PARSE_PARAMETERS_START(2, 5)
-			Z_PARAM_STR(server_key)
-			Z_PARAM_STR(key)
-			Z_PARAM_OPTIONAL
-			Z_PARAM_LONG(offset)
-			Z_PARAM_LONG(initial)
-			Z_PARAM_LONG(expiry)
-		ZEND_PARSE_PARAMETERS_END();
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-
-	if (offset < 0) {
-		php_error_docref(NULL, E_WARNING, "offset cannot be a negative value");
-		RETURN_FALSE;
-	}
-
-	if ((!by_key && n_args < 3) || (by_key && n_args < 4)) {
-		if (by_key) {
-			if (incr) {
-				status = memcached_increment_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
-			} else {
-				status = memcached_decrement_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
-			}
-		} else {
-			/* The libmemcached API has a quirk that memcached_increment() takes only a 32-bit
-			 * offset, but memcached_increment_by_key() and all other increment and decrement
-			 * functions take a 64-bit offset. The memcached protocol allows increment/decrement
-			 * greater than UINT_MAX, so we just work around memcached_increment() here.
-			 */
-			if (incr) {
-				status = memcached_increment_by_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
-			} else {
-				status = memcached_decrement_by_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
-			}
-		}
-
-	} else {
-		zend_long retries = memc_user_data->store_retry_count;
-
-retry_inc_dec:
-		if (!memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) {
-			php_error_docref(NULL, E_WARNING, "Initial value is only supported with binary protocol");
-			RETURN_FALSE;
-		}
-		if (by_key) {
-			if (incr) {
-				status = memcached_increment_with_initial_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
-			} else {
-				status = memcached_decrement_with_initial_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
-			}
-		} else {
-			if (incr) {
-				status = memcached_increment_with_initial(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
-			} else {
-				status = memcached_decrement_with_initial(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
-			}
-		}
-		if (s_should_retry_write(intern, status) && retries-- > 0) {
-			goto retry_inc_dec;
-		}
-	}
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	if (value == UINT64_MAX) {
-		RETURN_FALSE;
-	}
-
-	RETURN_LONG((long)value);
-}
-/* }}} */
-
-/* {{{ Memcached::increment(string key , int delta , initial_value , expiry time   )
-   Increments the value for the given key by delta, defaulting to 1 */
-PHP_METHOD(Memcached, increment)
-{
-	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::decrement(string key , int delta , initial_value , expiry time   )
-   Decrements the value for the given key by delta, defaulting to 1 */
-PHP_METHOD(Memcached, decrement)
-{
-	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::decrementByKey(string server_key, string key , int delta , initial_value , expiry time   )
-   Decrements by server the value for the given key by delta, defaulting to 1 */
-PHP_METHOD(Memcached, decrementByKey)
-{
-	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
-}
-/* }}} */
-
-/* {{{ Memcached::increment(string server_key, string key , int delta , initial_value , expiry time   )
-   Increments by server the value for the given key by delta, defaulting to 1 */
-PHP_METHOD(Memcached, incrementByKey)
-{
-	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::addServer(string hostname, int port , int weight )
-   Adds the given memcache server to the list */
-PHP_METHOD(Memcached, addServer)
-{
-	zend_string *host;
-	zend_long port, weight = 0;
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "Sa/|l" */
-	ZEND_PARSE_PARAMETERS_START(2, 3)
-	        Z_PARAM_STR(host)
-	        Z_PARAM_LONG(port)
-	        Z_PARAM_OPTIONAL
-	        Z_PARAM_LONG(weight)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	status = memcached_server_add_with_weight(intern->memc, ZSTR_VAL(host), port, weight);
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::addServers(array servers)
-   Adds the given memcache servers to the server list */
-PHP_METHOD(Memcached, addServers)
-{
-	zval *servers;
-	zval *entry;
-	zval *z_host, *z_port, *z_weight = NULL;
-	HashPosition	pos;
-	int   entry_size, i = 0;
-	memcached_server_st *list = NULL;
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "a/" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_ARRAY_EX(servers, 0, 1)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	ZEND_HASH_FOREACH_VAL (Z_ARRVAL_P(servers), entry) {
-		if (Z_TYPE_P(entry) != IS_ARRAY) {
-			php_error_docref(NULL, E_WARNING, "server list entry #%d is not an array", i+1);
-			i++;
-			continue;
-		}
-
-		entry_size = zend_hash_num_elements(Z_ARRVAL_P(entry));
-
-		if (entry_size > 1) {
-			zend_string *host;
-			zend_long port;
-			uint32_t weight;
-
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(entry), &pos);
-
-			/* Check that we have a host */
-			if ((z_host = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
-				php_error_docref(NULL, E_WARNING, "could not get server host for entry #%d", i+1);
-				i++;
-				continue;
-			}
-
-			/* Check that we have a port */
-			if (zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos) == FAILURE ||
-			    (z_port = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
-				php_error_docref(NULL, E_WARNING, "could not get server port for entry #%d", i+1);
-				i++;
-				continue;
-			}
-
-			host = zval_get_string(z_host);
-			port = zval_get_long(z_port);
-
-			weight = 0;
-			if (entry_size > 2) {
-				/* Try to get weight */
-				if (zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos) == FAILURE ||
-					(z_weight = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
-					php_error_docref(NULL, E_WARNING, "could not get server weight for entry #%d", i+1);
-				}
-
-				weight = zval_get_long(z_weight);
-			}
-
-			list = memcached_server_list_append_with_weight(list, ZSTR_VAL(host), port, weight, &status);
-
-			zend_string_release(host);
-
-			if (s_memc_status_handle_result_code(intern, status) == SUCCESS) {
-				i++;
-				continue;
-			}
-		}
-		i++;
-		/* catch-all for all errors */
-		php_error_docref(NULL, E_WARNING, "could not add entry #%d to the server list", i + 1);
-	} ZEND_HASH_FOREACH_END();
-
-	status = memcached_server_push(intern->memc, list);
-	memcached_server_list_free(list);
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::getServerList()
-   Returns the list of the memcache servers in use */
-PHP_METHOD(Memcached, getServerList)
-{
-	memcached_server_function callbacks1;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	callbacks0 = s_server_cursor_list_servers_cb;
-	array_init(return_value);
-	memcached_server_cursor(intern->memc, callbacks, return_value, 1);
-}
-/* }}} */
-
-/* {{{ Memcached::getServerByKey(string server_key)
-   Returns the server identified by the given server key */
-PHP_METHOD(Memcached, getServerByKey)
-{
-	zend_string *server_key;
-	php_memcached_instance_st server_instance;
-	memcached_return error;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "S" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_STR(server_key)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	server_instance = memcached_server_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), &error);
-	if (server_instance == NULL) {
-		s_memc_status_handle_result_code(intern, error);
-		RETURN_FALSE;
-	}
-
-	array_init(return_value);
-	add_assoc_string(return_value, "host", (char*) memcached_server_name(server_instance));
-	add_assoc_long(return_value, "port", memcached_server_port(server_instance));
-	add_assoc_long(return_value, "weight", 0);
-}
-/* }}} */
-
-/* {{{ Memcached::resetServerList()
-   Reset the server list in use */
-PHP_METHOD(Memcached, resetServerList)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	memcached_servers_reset(intern->memc);
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::quit()
-   Close any open connections */
-PHP_METHOD(Memcached, quit)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	memcached_quit(intern->memc);
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::flushBuffers()
-   Flush and senf buffered commands */
-PHP_METHOD(Memcached, flushBuffers)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-	RETURN_BOOL(memcached_flush_buffers(intern->memc) == MEMCACHED_SUCCESS);
-}
-/* }}} */
-
-/* {{{ Memcached::getLastErrorMessage()
-   Returns the last error message that occurred */
-PHP_METHOD(Memcached, getLastErrorMessage)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_STRING(memcached_last_error_message(intern->memc));
-}
-/* }}} */
-
-/* {{{ Memcached::getLastErrorCode()
-   Returns the last error code that occurred */
-PHP_METHOD(Memcached, getLastErrorCode)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_LONG(memcached_last_error(intern->memc));
-}
-/* }}} */
-
-/* {{{ Memcached::getLastErrorErrno()
-   Returns the last error errno that occurred */
-PHP_METHOD(Memcached, getLastErrorErrno)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_LONG(memcached_last_error_errno(intern->memc));
-}
-/* }}} */
-
-/* {{{ Memcached::getLastDisconnectedServer()
-   Returns the last disconnected server
-   Was added in 0.34 according to libmemcached's Changelog */
-PHP_METHOD(Memcached, getLastDisconnectedServer)
-{
-	php_memcached_instance_st server_instance;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	server_instance = memcached_server_get_last_disconnect(intern->memc);
-	if (server_instance == NULL) {
-		RETURN_FALSE;
-	}
-
-	array_init(return_value);
-	add_assoc_string(return_value, "host", (char*) memcached_server_name(server_instance));
-	add_assoc_long(return_value, "port", memcached_server_port(server_instance));
-}
-/* }}} */
-
-
-
-static
-zend_bool s_long_value(const char *str, zend_long *value)
-{
-	char *end = (char *) str;
-
-	errno = 0;
-	*value = strtol(str, &end, 10);
-
-	if (errno || str == end || *end != '\0') {
-		return 0;
-	}
-	return 1;
-}
-
-static
-zend_bool s_double_value(const char *str, double *value)
-{
-	char *end = (char *) str;
-
-	errno = 0;
-	*value = strtod(str, &end);
-
-	if (errno || str == end || *end != '\0') {
-		return 0;
-	}
-	return 1;
-}
-
-static
-memcached_return s_stat_execute_cb (php_memcached_instance_st instance, const char *key, size_t key_length, const char *value, size_t value_length, void *context)
-{
-	zend_string *server_key;
-	zend_long long_val;
-	double d_val;
-	char *buffer;
-
-	zval *return_value = (zval *) context;
-	zval *server_values;
-
-	server_key = strpprintf(0, "%s:%d", memcached_server_name(instance), memcached_server_port(instance));
-	server_values = zend_hash_find(Z_ARRVAL_P(return_value), server_key);
-
-	if (!server_values) {
-		zval zv;
-		array_init(&zv);
-
-		server_values = zend_hash_add(Z_ARRVAL_P(return_value), server_key, &zv);
-	}
-
-	spprintf (&buffer, 0, "%.*s", (int)value_length, value);
-
-	/* Check type */
-	if (s_long_value (buffer, &long_val)) {
-		add_assoc_long(server_values, key, long_val);
-	}
-	else if (s_double_value (buffer, &d_val)) {
-		add_assoc_double(server_values, key, d_val);
-	}
-	else {
-		add_assoc_stringl_ex(server_values, key, key_length, (char*)value, value_length);
-	}
-	efree (buffer);
-	zend_string_release(server_key);
-
-	return MEMCACHED_SUCCESS;
-}
-
-/* {{{ Memcached::getStats()
-   Returns statistics for the memcache servers */
-PHP_METHOD(Memcached, getStats)
-{
-	memcached_return status;
-	char *args = NULL;
-	zend_string *args_string = NULL;
-	uint64_t orig_no_block, orig_protocol;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "|S!" */
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-	        Z_PARAM_OPTIONAL
-	        Z_PARAM_STR_EX(args_string, 1, 0)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	if (args_string)
-		args = ZSTR_VAL(args_string);
-
-	/* stats hangs in nonblocking mode, turn off during the call. Only change the
-	 * value if needed, because libmemcached reconnects for this behavior_set. */
-	orig_no_block = memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-	orig_protocol = memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL);
-	if (orig_no_block && orig_protocol)
-		memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
-
-	array_init(return_value);
-	status = memcached_stat_execute(intern->memc, args, s_stat_execute_cb, return_value);
-
-	if (orig_no_block && orig_protocol)
-		memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK, orig_no_block);
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		zval_ptr_dtor(return_value);
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ Memcached::getVersion()
-   Returns the version of each memcached server in the pool */
-PHP_METHOD(Memcached, getVersion)
-{
-	memcached_return status;
-	memcached_server_function callbacks1;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	status = memcached_version(intern->memc);
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	callbacks0 = s_server_cursor_version_cb;
-
-	array_init(return_value);
-	status = memcached_server_cursor(intern->memc, callbacks, return_value, 1);
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		zval_dtor(return_value);
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ Memcached::getAllKeys()
-	Returns the keys stored on all the servers */
-static
-memcached_return s_dump_keys_cb(const memcached_st *ptr, const char *key, size_t key_length, void *in_context)
-{
-	zval *return_value = (zval*) in_context;
-	add_next_index_stringl(return_value, key, key_length);
-
-	return MEMCACHED_SUCCESS;
-}
-
-PHP_METHOD(Memcached, getAllKeys)
-{
-	memcached_return rc;
-	memcached_dump_func callback1;
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	callback0 = s_dump_keys_cb;
-	MEMC_METHOD_FETCH_OBJECT;
-
-	array_init(return_value);
-
-	rc = memcached_dump(intern->memc, callback, return_value, 1);
-
-	/* Ignore two errors. libmemcached has a hardcoded loop of 200 slab
-	 * classes that matches memcached < 1.4.24, at which version the server
-	 * has only 63 slabs and throws an error when requesting the 64th slab.
-	 *
-	 * In multi-server some non-deterministic number of elements will be dropped.
-	 */
-	if (rc != MEMCACHED_CLIENT_ERROR && rc != MEMCACHED_SERVER_ERROR
-	    && s_memc_status_handle_result_code(intern, rc) == FAILURE) {
-		zval_dtor(return_value);
-		RETURN_FALSE;
-	}
-}
-/* }}} */
-
-/* {{{ Memcached::flush( int delay )
-   Flushes the data on all the servers */
-static PHP_METHOD(Memcached, flush)
-{
-	zend_long delay = 0;
-	memcached_return status;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "|l" */
-	ZEND_PARSE_PARAMETERS_START(0, 1)
-	        Z_PARAM_OPTIONAL
-	        Z_PARAM_LONG(delay)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-
-	status = memcached_flush(intern->memc, delay);
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETURN_TRUE;
-}
-/* }}} */
-
-/* {{{ Memcached::getOption(int option)
-   Returns the value for the given option constant */
-static PHP_METHOD(Memcached, getOption)
-{
-	zend_long option;
-	uint64_t result;
-	memcached_behavior flag;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "l" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_LONG(option)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	switch (option) {
-		case MEMC_OPT_COMPRESSION_TYPE:
-			RETURN_LONG(memc_user_data->compression_type);
-
-		case MEMC_OPT_COMPRESSION:
-			RETURN_BOOL(memc_user_data->compression_enabled);
-
-		case MEMC_OPT_PREFIX_KEY:
-		{
-			memcached_return retval;
-			char *result;
-
-			result = memcached_callback_get(intern->memc, MEMCACHED_CALLBACK_PREFIX_KEY, &retval);
-			if (retval == MEMCACHED_SUCCESS && result) {
-				RETURN_STRING(result);
-			} else {
-				RETURN_EMPTY_STRING();
-			}
-		}
-
-		case MEMC_OPT_SERIALIZER:
-			RETURN_LONG((long)memc_user_data->serializer);
-			break;
-
-		case MEMC_OPT_USER_FLAGS:
-			RETURN_LONG(memc_user_data->set_udf_flags);
-			break;
-
-		case MEMC_OPT_STORE_RETRY_COUNT:
-			RETURN_LONG((long)memc_user_data->store_retry_count);
-			break;
-
-		case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
-		case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
-			if (memcached_server_count(intern->memc) == 0) {
-				php_error_docref(NULL, E_WARNING, "no servers defined");
-				return;
-			}
-
-		default:
-			/*
-			 * Assume that it's a libmemcached behavior option.
-			 */
-			flag = (memcached_behavior) option;
-			result = memcached_behavior_get(intern->memc, flag);
-			RETURN_LONG((long)result);
-	}
-}
-/* }}} */
-
-static
-int php_memc_set_option(php_memc_object_t *intern, long option, zval *value)
-{
-	zend_long lval;
-	memcached_return rc = MEMCACHED_FAILURE;
-	memcached_behavior flag;
-	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
-
-	switch (option) {
-		case MEMC_OPT_COMPRESSION:
-			memc_user_data->compression_enabled = zval_get_long(value) ? 1 : 0;
-			break;
-
-		case MEMC_OPT_COMPRESSION_TYPE:
-			lval = zval_get_long(value);
-			if (lval == COMPRESSION_TYPE_FASTLZ ||
-				lval == COMPRESSION_TYPE_ZLIB) {
-				memc_user_data->compression_type = lval;
-			} else {
-				/* invalid compression type */
-				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
-				return 0;
-			}
-			break;
-
-		case MEMC_OPT_PREFIX_KEY:
-		{
-			zend_string *str;
-			char *key;
-			str = zval_get_string(value);
-			if (ZSTR_LEN(str) == 0) {
-				key = NULL;
-			} else {
-				key = ZSTR_VAL(str);
-			}
-			if (memcached_callback_set(intern->memc, MEMCACHED_CALLBACK_PREFIX_KEY, key) == MEMCACHED_BAD_KEY_PROVIDED) {
-				zend_string_release(str);
-				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
-				php_error_docref(NULL, E_WARNING, "bad key provided");
-				return 0;
-			}
-			zend_string_release(str);
-		}
-			break;
-
-		case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
-			flag = (memcached_behavior) option;
-
-			lval = zval_get_long(value);
-			rc = memcached_behavior_set(intern->memc, flag, (uint64_t)lval);
-
-			if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
-				php_error_docref(NULL, E_WARNING, "error setting memcached option: %s", memcached_strerror (intern->memc, rc));
-				return 0;
-			}
-
-			/*
-			 * This is necessary because libmemcached does not reset hash/distribution
-			 * options on false case, like it does for MEMCACHED_BEHAVIOR_KETAMA
-			 * (non-weighted) case. We have to clean up ourselves.
-			 */
-			if (!lval) {
-				(void)memcached_behavior_set_key_hash(intern->memc, MEMCACHED_HASH_DEFAULT);
-				(void)memcached_behavior_set_distribution_hash(intern->memc, MEMCACHED_HASH_DEFAULT);
-				(void)memcached_behavior_set_distribution(intern->memc, MEMCACHED_DISTRIBUTION_MODULA);
-			}
-			break;
-
-		case MEMC_OPT_SERIALIZER:
-		{
-			lval = zval_get_long(value);
-			/* igbinary serializer */
-#ifdef HAVE_MEMCACHED_IGBINARY
-			if (lval == SERIALIZER_IGBINARY) {
-				memc_user_data->serializer = SERIALIZER_IGBINARY;
-			} else
-#endif
-#ifdef HAVE_JSON_API
-			if (lval == SERIALIZER_JSON) {
-				memc_user_data->serializer = SERIALIZER_JSON;
-			} else if (lval == SERIALIZER_JSON_ARRAY) {
-				memc_user_data->serializer = SERIALIZER_JSON_ARRAY;
-			} else
-#endif
-			/* msgpack serializer */
-#ifdef HAVE_MEMCACHED_MSGPACK
-			if (lval == SERIALIZER_MSGPACK) {
-				memc_user_data->serializer = SERIALIZER_MSGPACK;
-			} else
-#endif
-			/* php serializer */
-			if (lval == SERIALIZER_PHP) {
-				memc_user_data->serializer = SERIALIZER_PHP;
-			} else {
-				memc_user_data->serializer = SERIALIZER_PHP;
-				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
-				php_error_docref(NULL, E_WARNING, "invalid serializer provided");
-				return 0;
-			}
-			break;
-		}
-
-		case MEMC_OPT_USER_FLAGS:
-			lval = zval_get_long(value);
-
-			if (lval < 0) {
-				memc_user_data->set_udf_flags = -1;
-				return 1;
-			}
-
-			if (lval > MEMC_VAL_USER_FLAGS_MAX) {
-				php_error_docref(NULL, E_WARNING, "MEMC_OPT_USER_FLAGS must be < %u", MEMC_VAL_USER_FLAGS_MAX);
-				return 0;
-			}
-			memc_user_data->set_udf_flags = lval;
-			break;
-
-		case MEMC_OPT_STORE_RETRY_COUNT:
-			lval = zval_get_long(value);
-			memc_user_data->store_retry_count = lval;
-			break;
-
-		default:
-			/*
-			 * Assume that it's a libmemcached behavior option.
-			 */
-			if (option < 0) {
-				rc = MEMCACHED_INVALID_ARGUMENTS;
-			}
-			else {
-				flag = (memcached_behavior) option;
-				lval = zval_get_long(value);
-
-				if (flag < MEMCACHED_BEHAVIOR_MAX) {
-					// don't reset the option when the option value wasn't modified,
-					// while the libmemcached may shutdown all connections.
-					if (memcached_behavior_get(intern->memc, flag) == (uint64_t)lval) {
-						return 1;
-					}
-					rc = memcached_behavior_set(intern->memc, flag, (uint64_t)lval);
-				}
-				else {
-					rc = MEMCACHED_INVALID_ARGUMENTS;
-				}
-			}
-
-			if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
-				php_error_docref(NULL, E_WARNING, "error setting memcached option: %s", memcached_strerror (intern->memc, rc));
-				return 0;
-			}
-			break;
-	}
-	return 1;
-}
-
-static
-uint32_t *s_zval_to_uint32_array (zval *input, size_t *num_elements)
-{
-	zval *pzval;
-	uint32_t *retval;
-	size_t i = 0;
-
-	*num_elements = zend_hash_num_elements(Z_ARRVAL_P(input));
-
-	if (!*num_elements) {
-		return NULL;
-	}
-
-	retval = ecalloc(*num_elements, sizeof(uint32_t));
-
-	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), pzval) {
-		zend_long value = 0;
-
-		value = zval_get_long(pzval);
-		if (value < 0) {
-			php_error_docref(NULL, E_WARNING, "the map must contain positive integers");
-			efree (retval);
-			*num_elements = 0;
-			return NULL;
-		}
-		retval i = (uint32_t) value;
-		i++;
-	} ZEND_HASH_FOREACH_END();
-	return retval;
-}
-
-/* {{{ Memcached::setBucket(array host_map, array forward_map, integer replicas)
-   Sets the memcached virtual buckets */
-
-PHP_METHOD(Memcached, setBucket)
-{
-	zval *zserver_map;
-	zval *zforward_map = NULL;
-	zend_long replicas = 0;
-	zend_bool retval = 1;
-
-	uint32_t *server_map = NULL, *forward_map = NULL;
-	size_t server_map_len = 0, forward_map_len = 0;
-	memcached_return rc;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "aa!l" */
-	ZEND_PARSE_PARAMETERS_START(3, 3)
-	        Z_PARAM_ARRAY(zserver_map)
-	        Z_PARAM_ARRAY_EX(zforward_map, 1, 0)
-	        Z_PARAM_LONG(replicas)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	if (zend_hash_num_elements (Z_ARRVAL_P(zserver_map)) == 0) {
-		php_error_docref(NULL, E_WARNING, "server map cannot be empty");
-		RETURN_FALSE;
-	}
-
-	if (zforward_map && zend_hash_num_elements (Z_ARRVAL_P(zserver_map)) != zend_hash_num_elements (Z_ARRVAL_P(zforward_map))) {
-		php_error_docref(NULL, E_WARNING, "forward_map length must match the server_map length");
-		RETURN_FALSE;
-	}
-
-	if (replicas < 0) {
-		php_error_docref(NULL, E_WARNING, "replicas must be larger than zero");
-		RETURN_FALSE;
-	}
-
-	server_map = s_zval_to_uint32_array (zserver_map, &server_map_len);
-
-	if (!server_map) {
-		RETURN_FALSE;
-	}
-
-	if (zforward_map) {
-		forward_map = s_zval_to_uint32_array (zforward_map, &forward_map_len);
-
-		if (!forward_map) {
-			efree (server_map);
-			RETURN_FALSE;
-		}
-	}
-
-	rc = memcached_bucket_set (intern->memc, server_map, forward_map, (uint32_t) server_map_len, replicas);
-
-	if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
-		retval = 0;
-	}
-
-	efree(server_map);
-
-	if (forward_map) {
-		efree(forward_map);
-	}
-	RETURN_BOOL(retval);
-}
-/* }}} */
-
-/* {{{ Memcached::setOptions(array options)
-   Sets the value for the given option constant */
-static PHP_METHOD(Memcached, setOptions)
-{
-	zval *options;
-	zend_bool ok = 1;
-	zend_string *key;
-	zend_ulong key_index;
-	zval *value;
-
-	MEMC_METHOD_INIT_VARS;
-
-	/* "a" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_ARRAY(options)
-	ZEND_PARSE_PARAMETERS_END();
-
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(options), key_index, key, value) {
-		if (key) {
-			php_error_docref(NULL, E_WARNING, "invalid configuration option");
-			ok = 0;
-		} else {
-			if (!php_memc_set_option(intern, (long) key_index, value)) {
-				ok = 0;
-			}
-		}
-	} ZEND_HASH_FOREACH_END();
-
-	RETURN_BOOL(ok);
-}
-/* }}} */
-
-/* {{{ Memcached::setOption(int option, mixed value)
-   Sets the value for the given option constant */
-static PHP_METHOD(Memcached, setOption)
-{
-	zend_long option;
-	zval *value;
-	MEMC_METHOD_INIT_VARS;
-
-	/* "lz/" */
-	ZEND_PARSE_PARAMETERS_START(2, 2)
-	        Z_PARAM_LONG(option)
-	        Z_PARAM_ZVAL_EX(value, 0, 1)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_BOOL(php_memc_set_option(intern, option, value));
-}
-/* }}} */
-
-#ifdef HAVE_MEMCACHED_SASL
-/* {{{ Memcached::setSaslAuthData(string user, string pass)
-   Sets sasl credentials */
-static PHP_METHOD(Memcached, setSaslAuthData)
-{
-	MEMC_METHOD_INIT_VARS;
-	memcached_return status;
-	zend_string *user, *pass;
-
-	/* "SS/" */
-	ZEND_PARSE_PARAMETERS_START(2, 2)
-	        Z_PARAM_STR(user)
-	        Z_PARAM_STR(pass)
-	ZEND_PARSE_PARAMETERS_END();
-
-	if (!php_memc_init_sasl_if_needed()) {
-		RETURN_FALSE;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	if (!memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) {
-		php_error_docref(NULL, E_WARNING, "SASL is only supported with binary protocol");
-		RETURN_FALSE;
-	}
-	memc_user_data->has_sasl_data = 1;
-	status = memcached_set_sasl_auth_data(intern->memc, ZSTR_VAL(user), ZSTR_VAL(pass));
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-	RETURN_TRUE;
-}
-/* }}} */
-#endif /* HAVE_MEMCACHED_SASL */
-
-#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
-/* {{{ Memcached::setEncodingKey(string key)
-   Sets AES encryption key (libmemcached 1.0.6 and higher) */
-static PHP_METHOD(Memcached, setEncodingKey)
-{
-	MEMC_METHOD_INIT_VARS;
-	memcached_return status;
-	zend_string *key;
-
-	/* "S" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_STR(key)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	// libmemcached < 1.0.18 cannot handle a change of encoding key. Warn about this and return false.
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX < 0x01000018
-	if (memc_user_data->encoding_enabled) {
-		php_error_docref(NULL, E_WARNING, "libmemcached versions less than 1.0.18 cannot change encoding key");
-		RETURN_FALSE;
-	}
-#endif
-
-	status = memcached_set_encoding_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key));
-
-	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	memc_user_data->encoding_enabled = 1;
-	RETURN_TRUE;
-}
-/* }}} */
-#endif /* HAVE_MEMCACHED_SET_ENCODING_KEY */
-
-/* {{{ Memcached::getResultCode()
-   Returns the result code from the last operation */
-static PHP_METHOD(Memcached, getResultCode)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_LONG(intern->rescode);
-}
-/* }}} */
-
-/* {{{ Memcached::getResultMessage()
-   Returns the result message from the last operation */
-static PHP_METHOD(Memcached, getResultMessage)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	switch (intern->rescode) {
-		case MEMC_RES_PAYLOAD_FAILURE:
-			RETURN_STRING("PAYLOAD FAILURE");
-			break;
-
-		case MEMCACHED_ERRNO:
-		case MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE:
-		case MEMCACHED_UNKNOWN_READ_FAILURE:
-			if (intern->memc_errno) {
-				zend_string *str = strpprintf(0, "%s: %s",
-						memcached_strerror(intern->memc, (memcached_return)intern->rescode), strerror(intern->memc_errno));
-				RETURN_STR(str);
-			}
-			/* Fall through */
-		default:
-			RETURN_STRING(memcached_strerror(intern->memc, (memcached_return)intern->rescode));
-			break;
-	}
-
-}
-/* }}} */
-
-/* {{{ Memcached::isPersistent()
-   Returns the true if instance uses a persistent connection */
-static PHP_METHOD(Memcached, isPersistent)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_BOOL(memc_user_data->is_persistent);
-}
-/* }}} */
-
-/* {{{ Memcached::isPristine()
-   Returns the true if instance is recently created */
-static PHP_METHOD(Memcached, isPristine)
-{
-	MEMC_METHOD_INIT_VARS;
-
-	if (zend_parse_parameters_none() == FAILURE) {
-		return;
-	}
-
-	MEMC_METHOD_FETCH_OBJECT;
-
-	RETURN_BOOL(intern->is_pristine);
-}
-/* }}} */
-
-/* {{{ bool Memcached::checkKey(string key)
-   Checks if a key is valid */
-PHP_METHOD(Memcached, checkKey)
-{
-	zend_string *key;
-	MEMC_METHOD_INIT_VARS;
-
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-		Z_PARAM_STR(key)
-	ZEND_PARSE_PARAMETERS_END();
-
-	MEMC_METHOD_FETCH_OBJECT;
-	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
-	MEMC_CHECK_KEY(intern, key);
-	RETURN_TRUE;
-}
-/* }}} */
-
-/****************************************
-  Internal support code
-****************************************/
-
-/* {{{ constructor/destructor */
-static
-void php_memc_destroy(memcached_st *memc, php_memc_user_data_t *memc_user_data)
-{
-#ifdef HAVE_MEMCACHED_SASL
-	if (memc_user_data->has_sasl_data) {
-		memcached_destroy_sasl_auth_data(memc);
-	}
-#endif
-
-	memcached_free(memc);
-	pefree(memc_user_data, memc_user_data->is_persistent);
-}
-
-static
-void php_memc_object_free_storage(zend_object *object)
-{
-	php_memc_object_t *intern = php_memc_fetch_object(object);
-
-	if (intern->memc) {
-		php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
-
-		if (!memc_user_data->is_persistent) {
-			php_memc_destroy(intern->memc, memc_user_data);
-		}
-	}
-
-	intern->memc = NULL;
-	zend_object_std_dtor(&intern->zo);
-}
-
-static
-zend_object *php_memc_object_new(zend_class_entry *ce)
-{
-	php_memc_object_t *intern = ecalloc(1, sizeof(php_memc_object_t) + zend_object_properties_size(ce));
-
-	zend_object_std_init(&intern->zo, ce);
-	object_properties_init(&intern->zo, ce);
-
-	intern->zo.handlers = &memcached_object_handlers;
-	return &intern->zo;
-}
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-static
-void php_memc_server_free_storage(zend_object *object)
-{
-	php_memc_server_t *intern = php_memc_server_fetch_object(object);
-
-	php_memc_proto_handler_destroy(&intern->handler);
-	zend_object_std_dtor(&intern->zo);
-}
-
-zend_object *php_memc_server_new(zend_class_entry *ce)
-{
-	php_memc_server_t *intern;
-
-	intern = ecalloc(1, sizeof(php_memc_server_t) + zend_object_properties_size(ce));
-
-	zend_object_std_init(&intern->zo, ce);
-	object_properties_init(&intern->zo, ce);
-
-	intern->zo.handlers = &memcached_server_object_handlers;
-	intern->handler = php_memc_proto_handler_new();
-
-	return &intern->zo;
-}
-#endif
-
-ZEND_RSRC_DTOR_FUNC(php_memc_dtor)
-{
-	if (res->ptr) {
-		memcached_st *memc = (memcached_st *) res->ptr;
-		php_memc_destroy(memc, memcached_get_user_data(memc));
-		res->ptr = NULL;
-	}
-}
-
-/* }}} */
-
-/* {{{ internal API functions */
-static
-memcached_return s_server_cursor_list_servers_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context)
-{
-	zval array;
-	zval *return_value = (zval *) in_context;
-
-	array_init(&array);
-	add_assoc_string(&array, "host", (char*)memcached_server_name(instance));
-	add_assoc_long(&array,   "port", memcached_server_port(instance));
-	add_assoc_string(&array, "type", (char*)memcached_server_type(instance));
-	/*
-	 * API does not allow to get at this field.
-	add_assoc_long(array, "weight", instance->weight);
-	*/
-
-	add_next_index_zval(return_value, &array);
-	return MEMCACHED_SUCCESS;
-}
-
-static
-memcached_return s_server_cursor_version_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context)
-{
-	zend_string *address, *version;
-	zval rv, *return_value = (zval *)in_context;
-
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000009
-	version = strpprintf(0, "%d.%d.%d",
-				memcached_server_major_version(instance),
-				memcached_server_minor_version(instance),
-				memcached_server_micro_version(instance));
-#else
-	version = strpprintf(0, "%d.%d.%d",
-				instance->major_version,
-				instance->minor_version,
-				instance->micro_version);
-#endif
-
-	address = strpprintf(0, "%s:%d", memcached_server_name(instance), memcached_server_port(instance));
-
-	ZVAL_STR(&rv, version);
-	zend_hash_add(Z_ARRVAL_P(return_value), address, &rv);
-
-	zend_string_release(address);
-
-	return MEMCACHED_SUCCESS;
-}
-
-
-static
-zend_string *s_decompress_value (const char *payload, size_t payload_len, uint32_t flags)
-{
-	zend_string *buffer;
-
-	uint32_t stored_length;
-	unsigned long length;
-	zend_bool decompress_status = 0;
-	zend_bool is_fastlz = 0, is_zlib = 0;
-
-	if (payload_len < sizeof (uint32_t)) {
-		return NULL;
-	}
-
-	is_fastlz = MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSION_FASTLZ);
-	is_zlib   = MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSION_ZLIB);
-
-	if (!is_fastlz && !is_zlib) {
-		php_error_docref(NULL, E_WARNING, "could not decompress value: unrecognised compression type");
-		return NULL;
-	}
-
-	memcpy(&stored_length, payload, sizeof (uint32_t));
-
-	payload     += sizeof (uint32_t);
-	payload_len -= sizeof (uint32_t);
-
-	buffer = zend_string_alloc (stored_length, 0);
-
-	if (is_fastlz) {
-		decompress_status = ((length = fastlz_decompress(payload, payload_len, &buffer->val, buffer->len)) > 0);
-	}
-	else if (is_zlib) {
-		decompress_status = (uncompress((Bytef *) buffer->val, &buffer->len, (Bytef *)payload, payload_len) == Z_OK);
-	}
-
-	ZSTR_VAL(buffer)stored_length = '\0';
-
-	if (!decompress_status) {
-		php_error_docref(NULL, E_WARNING, "could not decompress value");
-		zend_string_release (buffer);
-		return NULL;
-	}
-
-	zend_string_forget_hash_val(buffer);
-	return buffer;
-}
-
-static
-zend_bool s_unserialize_value (memcached_st *memc, int val_type, zend_string *payload, zval *return_value)
-{
-	switch (val_type) {
-		case MEMC_VAL_IS_SERIALIZED:
-		{
-			php_unserialize_data_t var_hash;
-			const unsigned char *p, *max;
-
-			p   = (const unsigned char *) ZSTR_VAL(payload);
-			max = p + ZSTR_LEN(payload);
-
-			PHP_VAR_UNSERIALIZE_INIT(var_hash);
-			if (!php_var_unserialize(return_value, &p, max, &var_hash)) {
-				zval_ptr_dtor(return_value);
-				ZVAL_FALSE(return_value);
-				PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-				php_error_docref(NULL, E_WARNING, "could not unserialize value");
-				return 0;
-			}
-			PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-		}
-			break;
-
-		case MEMC_VAL_IS_IGBINARY:
-#ifdef HAVE_MEMCACHED_IGBINARY
-			if (igbinary_unserialize((uint8_t *) ZSTR_VAL(payload), ZSTR_LEN(payload), return_value)) {
-				ZVAL_FALSE(return_value);
-				php_error_docref(NULL, E_WARNING, "could not unserialize value with igbinary");
-				return 0;
-			}
-#else
-			ZVAL_FALSE(return_value);
-			php_error_docref(NULL, E_WARNING, "could not unserialize value, no igbinary support");
-			return 0;
-#endif
-			break;
-
-		case MEMC_VAL_IS_JSON:
-#ifdef HAVE_JSON_API
-		{
-			php_memc_user_data_t *memc_user_data = memcached_get_user_data(memc);
-			php_json_decode(return_value, ZSTR_VAL(payload), ZSTR_LEN(payload), (memc_user_data->serializer == SERIALIZER_JSON_ARRAY), PHP_JSON_PARSER_DEFAULT_DEPTH);
-		}
-#else
-			ZVAL_FALSE(return_value);
-			php_error_docref(NULL, E_WARNING, "could not unserialize value, no json support");
-			return 0;
-#endif
-			break;
-
-		case MEMC_VAL_IS_MSGPACK:
-#ifdef HAVE_MEMCACHED_MSGPACK
-			php_msgpack_unserialize(return_value, ZSTR_VAL(payload), ZSTR_LEN(payload));
-#else
-			ZVAL_FALSE(return_value);
-			php_error_docref(NULL, E_WARNING, "could not unserialize value, no msgpack support");
-			return 0;
-#endif
- 			break;
-	}
-	return 1;
-}
-
-static
-zend_bool s_memcached_result_to_zval(memcached_st *memc, memcached_result_st *result, zval *return_value)
-{
-	zend_string *data;
-	const char *payload;
-	size_t payload_len;
-	uint32_t flags;
-	zend_bool retval = 1;
-
-	payload     = memcached_result_value(result);
-	payload_len = memcached_result_length(result);
-	flags       = memcached_result_flags(result);
-
-	if (!payload && payload_len > 0) {
-		php_error_docref(NULL, E_WARNING, "Could not handle non-existing value of length %zu", payload_len);
-		return 0;
-	}
-
-	if (MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSED)) {
-		data = s_decompress_value (payload, payload_len, flags);
-		if (!data) {
-			return 0;
-		}
-	} else {
-		data = zend_string_init(payload, payload_len, 0);
-	}
-
-	switch (MEMC_VAL_GET_TYPE(flags)) {
-
-		case MEMC_VAL_IS_STRING:
-			ZVAL_STR_COPY(return_value, data);
-			break;
-
-		case MEMC_VAL_IS_LONG:
-			ZVAL_LONG(return_value, strtol(ZSTR_VAL(data), NULL, 10));
-			break;
-
-		case MEMC_VAL_IS_DOUBLE:
-		{
-			if (zend_string_equals_literal(data, "Infinity")) {
-				ZVAL_DOUBLE(return_value, php_get_inf());
-			}
-			else if (zend_string_equals_literal(data, "-Infinity")) {
-				ZVAL_DOUBLE(return_value, -php_get_inf());
-			}
-			else if (zend_string_equals_literal(data, "NaN")) {
-				ZVAL_DOUBLE(return_value, php_get_nan());
-			}
-			else {
-				ZVAL_DOUBLE(return_value, zend_strtod(ZSTR_VAL(data), NULL));
-			}
-		}
-			break;
-
-		case MEMC_VAL_IS_BOOL:
-			ZVAL_BOOL(return_value, payload_len > 0 && ZSTR_VAL(data)0 == '1');
-			break;
-
-		case MEMC_VAL_IS_SERIALIZED:
-		case MEMC_VAL_IS_IGBINARY:
-		case MEMC_VAL_IS_JSON:
-		case MEMC_VAL_IS_MSGPACK:
-			retval = s_unserialize_value (memc, MEMC_VAL_GET_TYPE(flags), data, return_value);
-			break;
-
-		default:
-			php_error_docref(NULL, E_WARNING, "unknown payload type");
-			retval = 0;
-			break;
-	}
-	zend_string_release(data);
-
-	return retval;
-}
-
-
-PHP_MEMCACHED_API
-zend_class_entry *php_memc_get_ce(void)
-{
-	return memcached_ce;
-}
-
-PHP_MEMCACHED_API
-zend_class_entry *php_memc_get_exception(void)
-{
-	return memcached_exception_ce;
-}
-
-PHP_MEMCACHED_API
-zend_class_entry *php_memc_get_exception_base(int root)
-{
-	if (!root) {
-		if (!spl_ce_RuntimeException) {
-			zend_class_entry *pce;
-			zval *pce_z;
-
-			if ((pce_z = zend_hash_str_find(CG(class_table),
-							"runtimeexception",
-							sizeof("RuntimeException") - 1)) != NULL) {
-				pce = Z_CE_P(pce_z);
-				spl_ce_RuntimeException = pce;
-				return pce;
-			}
-		} else {
-			return spl_ce_RuntimeException;
-		}
-	}
-
-	return zend_exception_get_default();
-}
-
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-
-static
-void s_destroy_cb (zend_fcall_info *fci)
-{
-	if (fci->size > 0) {
-		zval_ptr_dtor(&fci->function_name);
-		if (fci->object) {
-			OBJ_RELEASE(fci->object);
-		}
-	}
-}
-
-static
-PHP_METHOD(MemcachedServer, run)
-{
-	int i;
-	zend_bool rc;
-	zend_string *address;
-
-	php_memc_server_t *intern;
-	intern = Z_MEMC_SERVER_P(getThis());
-
-	/* "S" */
-	ZEND_PARSE_PARAMETERS_START(1, 1)
-	        Z_PARAM_STR(address)
-	ZEND_PARSE_PARAMETERS_END();
-
-	rc = php_memc_proto_handler_run(intern->handler, address);
-
-	for (i = MEMC_SERVER_ON_MIN + 1; i < MEMC_SERVER_ON_MAX; i++) {
-		s_destroy_cb(&MEMC_SERVER_G(callbacks) i.fci);
-	}
-
-	RETURN_BOOL(rc);
-}
-
-static
-PHP_METHOD(MemcachedServer, on)
-{
-	zend_long event;
-	zend_fcall_info fci;
-	zend_fcall_info_cache fci_cache;
-	zend_bool rc = 0;
-
-	/* "lf!" */
-	ZEND_PARSE_PARAMETERS_START(2, 2)
-	        Z_PARAM_LONG(event)
-	        Z_PARAM_FUNC_EX(fci, fci_cache, 1, 0)
-	ZEND_PARSE_PARAMETERS_END();
-
-	if (event <= MEMC_SERVER_ON_MIN || event >= MEMC_SERVER_ON_MAX) {
-		RETURN_FALSE;
-	}
-
-	if (fci.size > 0) {
-		s_destroy_cb (&MEMC_SERVER_G(callbacks) event.fci);
-
-		MEMC_SERVER_G(callbacks) event.fci       = fci;
-		MEMC_SERVER_G(callbacks) event.fci_cache = fci_cache;
-
-		Z_TRY_ADDREF(fci.function_name);
-		if (fci.object) {
-			GC_ADDREF(fci.object);
-		}
-	}
-	RETURN_BOOL(rc);
-}
-
-#endif
-
-#if PHP_VERSION_ID < 80000
-#include "php_memcached_legacy_arginfo.h"
-#else
-#include "php_memcached_arginfo.h"
-#endif
-
-/* {{{ memcached_module_entry
- */
-
-#if ZEND_MODULE_API_NO >= 20050922
-static const zend_module_dep memcached_deps = {
-#ifdef HAVE_MEMCACHED_SESSION
-	ZEND_MOD_REQUIRED("session")
-#endif
-#ifdef HAVE_MEMCACHED_IGBINARY
-	ZEND_MOD_REQUIRED("igbinary")
-#endif
-#ifdef HAVE_MEMCACHED_MSGPACK
-	ZEND_MOD_REQUIRED("msgpack")
-#endif
-	ZEND_MOD_REQUIRED("spl")
-	ZEND_MOD_END
-};
-#endif
-
-static
-PHP_GINIT_FUNCTION(php_memcached)
-{
-#ifdef HAVE_MEMCACHED_SESSION
-	php_memcached_globals->session.lock_enabled = 0;
-	php_memcached_globals->session.lock_wait_max = 150;
-	php_memcached_globals->session.lock_wait_min = 150;
-	php_memcached_globals->session.lock_retries = 200;
-	php_memcached_globals->session.lock_expiration = 30;
-	php_memcached_globals->session.binary_protocol_enabled = 1;
-	php_memcached_globals->session.consistent_hash_enabled = 1;
-	php_memcached_globals->session.consistent_hash_type = MEMCACHED_BEHAVIOR_KETAMA;
-	php_memcached_globals->session.consistent_hash_name = NULL;
-	php_memcached_globals->session.number_of_replicas = 0;
-	php_memcached_globals->session.server_failure_limit = 1;
-	php_memcached_globals->session.randomize_replica_read_enabled = 1;
-	php_memcached_globals->session.remove_failed_servers_enabled = 1;
-	php_memcached_globals->session.connect_timeout = 1000;
-	php_memcached_globals->session.prefix = NULL;
-	php_memcached_globals->session.persistent_enabled = 0;
-	php_memcached_globals->session.sasl_username = NULL;
-	php_memcached_globals->session.sasl_password = NULL;
-#endif
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-	memset(&php_memcached_globals->server, 0, sizeof(php_memcached_globals->server));
-#endif
-
-	php_memcached_globals->memc.serializer_name = NULL;
-	php_memcached_globals->memc.serializer_type = SERIALIZER_DEFAULT;
-	php_memcached_globals->memc.compression_name = NULL;
-	php_memcached_globals->memc.compression_threshold = 2000;
-	php_memcached_globals->memc.compression_type = COMPRESSION_TYPE_FASTLZ;
-	php_memcached_globals->memc.compression_factor = 1.30;
-	php_memcached_globals->memc.store_retry_count = 2;
-
-	php_memcached_globals->memc.sasl_initialised = 0;
-	php_memcached_globals->no_effect = 0;
-
-	/* Defaults for certain options */
-	php_memcached_globals->memc.default_behavior.consistent_hash_enabled = 0;
-	php_memcached_globals->memc.default_behavior.binary_protocol_enabled = 0;
-	php_memcached_globals->memc.default_behavior.connect_timeout         = 0;
-}
-
-zend_module_entry memcached_module_entry = {
-	STANDARD_MODULE_HEADER_EX, NULL,
-	memcached_deps,
-	"memcached",
-	NULL,
-	PHP_MINIT(memcached),
-	PHP_MSHUTDOWN(memcached),
-	NULL,
-	NULL,
-	PHP_MINFO(memcached),
-	PHP_MEMCACHED_VERSION,
-	PHP_MODULE_GLOBALS(php_memcached),
-	PHP_GINIT(php_memcached),
-	NULL,
-	NULL,
-	STANDARD_MODULE_PROPERTIES_EX
-};
-/* }}} */
-
-
-/* {{{ php_memc_register_constants */
-static void php_memc_register_constants(INIT_FUNC_ARGS)
-{
-	#define REGISTER_MEMC_CLASS_CONST_LONG(name, value) zend_declare_class_constant_long(php_memc_get_ce() , ZEND_STRS( #name ) - 1, value)
-	#define REGISTER_MEMC_CLASS_CONST_BOOL(name, value) zend_declare_class_constant_bool(php_memc_get_ce() , ZEND_STRS( #name ) - 1, value)
-	#define REGISTER_MEMC_CLASS_CONST_NULL(name) zend_declare_class_constant_null(php_memc_get_ce() , ZEND_STRS( #name ) - 1)
-
-	/*
-	 * Class options
-	 */
-	REGISTER_MEMC_CLASS_CONST_LONG(LIBMEMCACHED_VERSION_HEX, LIBMEMCACHED_VERSION_HEX);
-
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_COMPRESSION, MEMC_OPT_COMPRESSION);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_COMPRESSION_TYPE, MEMC_OPT_COMPRESSION_TYPE);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_PREFIX_KEY,  MEMC_OPT_PREFIX_KEY);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERIALIZER,  MEMC_OPT_SERIALIZER);
-
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_USER_FLAGS,  MEMC_OPT_USER_FLAGS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_STORE_RETRY_COUNT,  MEMC_OPT_STORE_RETRY_COUNT);
-
-	/*
-	 * Indicate whether igbinary serializer is available
-	 */
-#ifdef HAVE_MEMCACHED_IGBINARY
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_IGBINARY, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_IGBINARY, 0);
-#endif
-
-	/*
-	 * Indicate whether json serializer is available
-	 */
-#ifdef HAVE_JSON_API
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_JSON, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_JSON, 0);
-#endif
-
-	/*
-	 * Indicate whether msgpack serializer is available
-	 */
-#ifdef HAVE_MEMCACHED_MSGPACK
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_MSGPACK, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_MSGPACK, 0);
-#endif
-
-	/*
-	 * Indicate whether set_encoding_key is available
-	 */
-#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ENCODING, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ENCODING, 0);
-#endif
-
-#ifdef HAVE_MEMCACHED_SESSION
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SESSION, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SESSION, 0);
-#endif
-
-#ifdef HAVE_MEMCACHED_SASL
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SASL, 1);
-#else
-	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SASL, 0);
-#endif
-
-	/*
-	 * libmemcached behavior options
-	 */
-
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_HASH, MEMCACHED_BEHAVIOR_HASH);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_DEFAULT, MEMCACHED_HASH_DEFAULT);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_MD5, MEMCACHED_HASH_MD5);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_CRC, MEMCACHED_HASH_CRC);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1_64, MEMCACHED_HASH_FNV1_64);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1A_64, MEMCACHED_HASH_FNV1A_64);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1_32, MEMCACHED_HASH_FNV1_32);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1A_32, MEMCACHED_HASH_FNV1A_32);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_HSIEH, MEMCACHED_HASH_HSIEH);
-	REGISTER_MEMC_CLASS_CONST_LONG(HASH_MURMUR, MEMCACHED_HASH_MURMUR);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_DISTRIBUTION, MEMCACHED_BEHAVIOR_DISTRIBUTION);
-	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_MODULA, MEMCACHED_DISTRIBUTION_MODULA);
-	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_CONSISTENT, MEMCACHED_DISTRIBUTION_CONSISTENT);
-	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_VIRTUAL_BUCKET, MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_LIBKETAMA_COMPATIBLE, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_LIBKETAMA_HASH, MEMCACHED_BEHAVIOR_KETAMA_HASH);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_TCP_KEEPALIVE, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_BUFFER_WRITES, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_BINARY_PROTOCOL, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NO_BLOCK, MEMCACHED_BEHAVIOR_NO_BLOCK);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_TCP_NODELAY, MEMCACHED_BEHAVIOR_TCP_NODELAY);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SOCKET_SEND_SIZE, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SOCKET_RECV_SIZE, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_CONNECT_TIMEOUT, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RETRY_TIMEOUT, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT);
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000003
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_DEAD_TIMEOUT, MEMCACHED_BEHAVIOR_DEAD_TIMEOUT);
-#endif
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SEND_TIMEOUT, MEMCACHED_BEHAVIOR_SND_TIMEOUT);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RECV_TIMEOUT, MEMCACHED_BEHAVIOR_RCV_TIMEOUT);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_POLL_TIMEOUT, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_CACHE_LOOKUPS, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERVER_FAILURE_LIMIT, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_AUTO_EJECT_HOSTS, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_HASH_WITH_PREFIX_KEY, MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NOREPLY, MEMCACHED_BEHAVIOR_NOREPLY);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SORT_HOSTS, MEMCACHED_BEHAVIOR_SORT_HOSTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_VERIFY_KEY, MEMCACHED_BEHAVIOR_VERIFY_KEY);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_USE_UDP, MEMCACHED_BEHAVIOR_USE_UDP);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NUMBER_OF_REPLICAS, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RANDOMIZE_REPLICA_READ, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_REMOVE_FAILED_SERVERS, MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS);
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000018
-	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERVER_TIMEOUT_LIMIT, MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT);
-#endif
-
-	/*
-	 * libmemcached result codes
-	 */
-
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SUCCESS,                   MEMCACHED_SUCCESS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_FAILURE,                   MEMCACHED_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_HOST_LOOKUP_FAILURE,       MEMCACHED_HOST_LOOKUP_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_FAILURE,        MEMCACHED_CONNECTION_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_BIND_FAILURE,   MEMCACHED_CONNECTION_BIND_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_WRITE_FAILURE,             MEMCACHED_WRITE_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_READ_FAILURE,              MEMCACHED_READ_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_UNKNOWN_READ_FAILURE,      MEMCACHED_UNKNOWN_READ_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_PROTOCOL_ERROR,            MEMCACHED_PROTOCOL_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_CLIENT_ERROR,              MEMCACHED_CLIENT_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_ERROR,              MEMCACHED_SERVER_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_DATA_EXISTS,               MEMCACHED_DATA_EXISTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_DATA_DOES_NOT_EXIST,       MEMCACHED_DATA_DOES_NOT_EXIST);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOTSTORED,                 MEMCACHED_NOTSTORED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_STORED,                    MEMCACHED_STORED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOTFOUND,                  MEMCACHED_NOTFOUND);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARTIAL_READ,              MEMCACHED_PARTIAL_READ);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SOME_ERRORS,               MEMCACHED_SOME_ERRORS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_NO_SERVERS,                MEMCACHED_NO_SERVERS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_END,                       MEMCACHED_END);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_DELETED,                   MEMCACHED_DELETED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_VALUE,                     MEMCACHED_VALUE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_STAT,                      MEMCACHED_STAT);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_ITEM,                      MEMCACHED_ITEM);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_ERRNO,                     MEMCACHED_ERRNO);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_FAIL_UNIX_SOCKET,          MEMCACHED_FAIL_UNIX_SOCKET);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOT_SUPPORTED,             MEMCACHED_NOT_SUPPORTED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_NO_KEY_PROVIDED,           MEMCACHED_NO_KEY_PROVIDED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_FETCH_NOTFINISHED,         MEMCACHED_FETCH_NOTFINISHED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_TIMEOUT,                   MEMCACHED_TIMEOUT);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_BUFFERED,                  MEMCACHED_BUFFERED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_BAD_KEY_PROVIDED,          MEMCACHED_BAD_KEY_PROVIDED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_INVALID_HOST_PROTOCOL,     MEMCACHED_INVALID_HOST_PROTOCOL);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_MARKED_DEAD,        MEMCACHED_SERVER_MARKED_DEAD);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_UNKNOWN_STAT_KEY,          MEMCACHED_UNKNOWN_STAT_KEY);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_INVALID_ARGUMENTS,         MEMCACHED_INVALID_ARGUMENTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARSE_ERROR,               MEMCACHED_PARSE_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARSE_USER_ERROR,          MEMCACHED_PARSE_USER_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_DEPRECATED,                MEMCACHED_DEPRECATED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_IN_PROGRESS,               MEMCACHED_IN_PROGRESS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_MAXIMUM_RETURN,            MEMCACHED_MAXIMUM_RETURN);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_MEMORY_ALLOCATION_FAILURE, MEMCACHED_MEMORY_ALLOCATION_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_SOCKET_CREATE_FAILURE, MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE);
-
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_E2BIG,                            MEMCACHED_E2BIG);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_KEY_TOO_BIG,                      MEMCACHED_KEY_TOO_BIG);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_TEMPORARILY_DISABLED,      MEMCACHED_SERVER_TEMPORARILY_DISABLED);
-
-#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000008
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_MEMORY_ALLOCATION_FAILURE, MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE);
-#endif
-
-#ifdef HAVE_MEMCACHED_SASL
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_PROBLEM,  MEMCACHED_AUTH_PROBLEM);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_FAILURE,  MEMCACHED_AUTH_FAILURE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_CONTINUE, MEMCACHED_AUTH_CONTINUE);
-#endif
-
-	/*
-	 * Our result codes.
-	 */
-
-	REGISTER_MEMC_CLASS_CONST_LONG(RES_PAYLOAD_FAILURE, MEMC_RES_PAYLOAD_FAILURE);
-
-	/*
-	 * Serializer types.
-	 */
-	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_PHP,        SERIALIZER_PHP);
-	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_IGBINARY,   SERIALIZER_IGBINARY);
-	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_JSON,       SERIALIZER_JSON);
-	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_JSON_ARRAY, SERIALIZER_JSON_ARRAY);
-	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_MSGPACK,    SERIALIZER_MSGPACK);
-
-	/*
-	 * Compression types
-	 */
-	REGISTER_MEMC_CLASS_CONST_LONG(COMPRESSION_FASTLZ, COMPRESSION_TYPE_FASTLZ);
-	REGISTER_MEMC_CLASS_CONST_LONG(COMPRESSION_ZLIB,   COMPRESSION_TYPE_ZLIB);
-
-	/*
-	 * Flags.
-	 */
-	REGISTER_MEMC_CLASS_CONST_LONG(GET_PRESERVE_ORDER, MEMC_GET_PRESERVE_ORDER);
-	REGISTER_MEMC_CLASS_CONST_LONG(GET_EXTENDED,       MEMC_GET_EXTENDED);
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-	/*
-	 * Server callbacks
-	 */
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_CONNECT,   MEMC_SERVER_ON_CONNECT);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_ADD,       MEMC_SERVER_ON_ADD);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_APPEND,    MEMC_SERVER_ON_APPEND);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_DECREMENT, MEMC_SERVER_ON_DECREMENT);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_DELETE,    MEMC_SERVER_ON_DELETE);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_FLUSH,     MEMC_SERVER_ON_FLUSH);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_GET,       MEMC_SERVER_ON_GET);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_INCREMENT, MEMC_SERVER_ON_INCREMENT);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_NOOP,      MEMC_SERVER_ON_NOOP);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_PREPEND,   MEMC_SERVER_ON_PREPEND);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_QUIT,      MEMC_SERVER_ON_QUIT);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_REPLACE,   MEMC_SERVER_ON_REPLACE);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_SET,       MEMC_SERVER_ON_SET);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_STAT,      MEMC_SERVER_ON_STAT);
-	REGISTER_MEMC_CLASS_CONST_LONG(ON_VERSION,   MEMC_SERVER_ON_VERSION);
-
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_SUCCESS,         PROTOCOL_BINARY_RESPONSE_SUCCESS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_KEY_ENOENT,      PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_KEY_EEXISTS,     PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_E2BIG,           PROTOCOL_BINARY_RESPONSE_E2BIG);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EINVAL,          PROTOCOL_BINARY_RESPONSE_EINVAL);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_STORED,      PROTOCOL_BINARY_RESPONSE_NOT_STORED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_DELTA_BADVAL,    PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_MY_VBUCKET,  PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_AUTH_ERROR,      PROTOCOL_BINARY_RESPONSE_AUTH_ERROR);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_AUTH_CONTINUE,   PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_UNKNOWN_COMMAND, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_ENOMEM,          PROTOCOL_BINARY_RESPONSE_ENOMEM);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_SUPPORTED,   PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EINTERNAL,       PROTOCOL_BINARY_RESPONSE_EINTERNAL);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EBUSY,           PROTOCOL_BINARY_RESPONSE_EBUSY);
-	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_ETMPFAIL,        PROTOCOL_BINARY_RESPONSE_ETMPFAIL);
-#endif
-
-	/*
-	 * Return value from simple get errors
-	 */
-	REGISTER_MEMC_CLASS_CONST_BOOL(GET_ERROR_RETURN_VALUE, 0);
-
-	#undef REGISTER_MEMC_CLASS_CONST_LONG
-	#undef REGISTER_MEMC_CLASS_CONST_BOOL
-	#undef REGISTER_MEMC_CLASS_CONST_NULL
-
-}
-/* }}} */
-
-/* {{{ PHP_MINIT_FUNCTION */
-PHP_MINIT_FUNCTION(memcached)
-{
-	zend_class_entry ce;
-
-	memcpy(&memcached_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	memcached_object_handlers.offset    = XtOffsetOf(php_memc_object_t, zo);
-	memcached_object_handlers.clone_obj = NULL;
-	memcached_object_handlers.free_obj  = php_memc_object_free_storage;
-
-	le_memc = zend_register_list_destructors_ex(NULL, php_memc_dtor, "Memcached persistent connection", module_number);
-
-	INIT_CLASS_ENTRY(ce, "Memcached", class_Memcached_methods);
-	memcached_ce = zend_register_internal_class(&ce);
-	memcached_ce->create_object = php_memc_object_new;
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-	memcpy(&memcached_server_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	memcached_server_object_handlers.offset = XtOffsetOf(php_memc_server_t, zo);
-	memcached_server_object_handlers.clone_obj = NULL;
-	memcached_server_object_handlers.free_obj = php_memc_server_free_storage;
-
-	INIT_CLASS_ENTRY(ce, "MemcachedServer", class_MemcachedServer_methods);
-	memcached_server_ce = zend_register_internal_class(&ce);
-	memcached_server_ce->create_object = php_memc_server_new;
-#endif
-
-	INIT_CLASS_ENTRY(ce, "MemcachedException", NULL);
-	memcached_exception_ce = zend_register_internal_class_ex(&ce, php_memc_get_exception_base(0));
-	/* TODO
-	 * possibly declare custom exception property here
-	 */
-
-	php_memc_register_constants(INIT_FUNC_ARGS_PASSTHRU);
-	REGISTER_INI_ENTRIES();
-
-#ifdef HAVE_MEMCACHED_SESSION
-	php_memc_session_minit(module_number);
-#endif
-	return SUCCESS;
-}
-/* }}} */
-
-/* {{{ PHP_MSHUTDOWN_FUNCTION */
-PHP_MSHUTDOWN_FUNCTION(memcached)
-{
-#ifdef HAVE_MEMCACHED_SASL
-	if (MEMC_G(sasl_initialised)) {
-		sasl_done();
-	}
-#endif
-
-	UNREGISTER_INI_ENTRIES();
-	return SUCCESS;
-}
-/* }}} */
-
-/* {{{ PHP_MINFO_FUNCTION */
-PHP_MINFO_FUNCTION(memcached)
-{
-	php_info_print_table_start();
-	php_info_print_table_header(2, "memcached support", "enabled");
-	php_info_print_table_row(2, "Version", PHP_MEMCACHED_VERSION);
-
-#ifdef LIBMEMCACHED_AWESOME
-	if (strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version())) {
-		php_info_print_table_row(2, "libmemcached-awesome headers version", LIBMEMCACHED_VERSION_STRING);
-		php_info_print_table_row(2, "libmemcached-awesome library version", memcached_lib_version());
-	} else {
-		php_info_print_table_row(2, "libmemcached-awesome version", memcached_lib_version());
-	}
-#else
-	if (strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version())) {
-		php_info_print_table_row(2, "libmemcached headers version", LIBMEMCACHED_VERSION_STRING);
-		php_info_print_table_row(2, "libmemcached library version", memcached_lib_version());
-	} else {
-		php_info_print_table_row(2, "libmemcached version", memcached_lib_version());
-	}
-#endif
-
-#ifdef HAVE_MEMCACHED_SASL
-	php_info_print_table_row(2, "SASL support", "yes");
-#else
-	php_info_print_table_row(2, "SASL support", "no");
-#endif
-
-#ifdef HAVE_MEMCACHED_SESSION
-	php_info_print_table_row(2, "Session support", "yes");
-#else
-	php_info_print_table_row(2, "Session support ", "no");
-#endif
-
-#ifdef HAVE_MEMCACHED_IGBINARY
-	php_info_print_table_row(2, "igbinary support", "yes");
-#else
-	php_info_print_table_row(2, "igbinary support", "no");
-#endif
-
-#ifdef HAVE_JSON_API
-	php_info_print_table_row(2, "json support", "yes");
-#else
-	php_info_print_table_row(2, "json support", "no");
-#endif
-
-#ifdef HAVE_MEMCACHED_MSGPACK
-	php_info_print_table_row(2, "msgpack support", "yes");
-#else
-	php_info_print_table_row(2, "msgpack support", "no");
-#endif
-
-	php_info_print_table_end();
-
-	DISPLAY_INI_ENTRIES();
-}
-/* }}} */
-
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim: noet sw=4 ts=4 fdm=marker:
- */

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached.h Deleted

@@ -1,57 +0,0 @@
-/*
-  +----------------------------------------------------------------------+
-  | Copyright (c) 2009 The PHP Group                                     |
-  +----------------------------------------------------------------------+
-  | This source file is subject to version 3.0 of the PHP license,       |
-  | that is bundled with this package in the file LICENSE, and is        |
-  | available through the world-wide-web at the following url:           |
-  | http://www.php.net/license/3_0.txt.                                  |
-  | If you did not receive a copy of the PHP license and are unable to   |
-  | obtain it through the world-wide-web, please send a note to          |
-  | license@php.net so we can mail you a copy immediately.               |
-  +----------------------------------------------------------------------+
-  | Authors: Andrei Zmievski <andrei@php.net>                            |
-  +----------------------------------------------------------------------+
-*/
-
-#ifndef PHP_MEMCACHED_H
-#define PHP_MEMCACHED_H
-
-#include "php.h"
-#include "Zend/zend_smart_str.h"
-
-#ifdef PHP_WIN32
-#include "main/config.w32.h"
-#else
-#include "main/php_config.h"
-#endif
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#define PHP_MEMCACHED_VERSION "3.2.0"
-
-#if defined(PHP_WIN32) && defined(MEMCACHED_EXPORTS)
-#define PHP_MEMCACHED_API __declspec(dllexport)
-#else
-#define PHP_MEMCACHED_API PHPAPI
-#endif
-
-PHP_MEMCACHED_API zend_class_entry *php_memc_get_ce(void);
-PHP_MEMCACHED_API zend_class_entry *php_memc_get_exception(void);
-PHP_MEMCACHED_API zend_class_entry *php_memc_get_exception_base(int root);
-
-extern zend_module_entry memcached_module_entry;
-#define phpext_memcached_ptr &memcached_module_entry
-
-#endif /* PHP_MEMCACHED_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: noet sw=4 ts=4 fdm=marker
- * vim<600: noet sw=4 ts=4
- */

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached.stub.php Deleted

@@ -1,95 +0,0 @@
-<?php
-
-/**
- * @generate-function-entries
- * @generate-legacy-arginfo
- */
-
-
-class Memcached {
-
-	public function __construct(?string $persistent_id=null, ?callable $callback=null, ?string $connection_str=null) {}
-
-	public function getResultCode(): int {}
-	public function getResultMessage(): string {}
-
-	public function get(string $key, ?callable $cache_cb=null, int $get_flags=0): mixed {}
-	public function getByKey(string $server_key, string $key, ?callable $cache_cb=null, int $get_flags=0): mixed {}
-	public function getMulti(array $keys, int $get_flags=0): false|array {}
-	public function getMultiByKey(string $server_key, array $keys, int $get_flags=0): false|array {}
-	public function getDelayed(array $keys, bool $with_cas=false, ?callable $value_cb=null): bool {}
-	public function getDelayedByKey(string $server_key, array $keys, bool $with_cas=false, ?callable $value_cb=null): bool {}
-	public function fetch(): false|array {}
-	public function fetchAll(): false|array {}
-
-	public function set(string $key, mixed $value, int $expiration=0): bool {}
-	public function setByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
-
-	public function touch(string $key, int $expiration=0): bool {}
-	public function touchByKey(string $server_key, string $key, int $expiration=0): bool {}
-
-	public function setMulti(array $items, int $expiration=0): bool {}
-	public function setMultiByKey(string $server_key, array $items, int $expiration=0): bool {}
-
-	public function cas(string $cas_token, string $key, mixed $value, int $expiration=0): bool {}
-	public function casByKey(string $cas_token, string $server_key, string $key, mixed $value, int $expiration=0): bool {}
-	public function add(string $key, mixed $value, int $expiration=0): bool {}
-	public function addByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
-	public function append(string $key, string $value): ?bool {}
-	public function appendByKey(string $server_key, string $key, string $value): ?bool {}
-	public function prepend(string $key, string $value): ?bool {}
-	public function prependByKey(string $server_key, string $key, string $value): ?bool {}
-	public function replace(string $key, mixed $value, int $expiration=0): bool {}
-	public function replaceByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
-	public function delete(string $key, int $time=0): bool {}
-	public function deleteMulti(array $keys, int $time=0): array {}
-	public function deleteByKey(string $server_key, string $key, int $time=0): bool {}
-	public function deleteMultiByKey(string $server_key, array $keys, int $time=0): array {}
-
-	public function increment(string $key, int $offset=1, int $initial_value=0, int $expiry=0): false|int {}
-	public function decrement(string $key, int $offset=1, int $initial_value=0, int $expiry=0): false|int {}
-	public function incrementByKey(string $server_key, string $key, int $offset=1, int $initial_value=0, int $expiry=0): false|int {}
-	public function decrementByKey(string $server_key, string $key, int $offset=1, int $initial_value=0, int $expiry=0): false|int {}
-
-	public function addServer(string $host, int $port, int $weight=0): bool {}
-	public function addServers(array $servers): bool {}
-	public function getServerList(): array {}
-	public function getServerByKey(string $server_key): false|array {}
-	public function resetServerList(): bool {}
-	public function quit(): bool {}
-	public function flushBuffers(): bool {}
-
-	public function getLastErrorMessage(): string {}
-	public function getLastErrorCode(): int {}
-	public function getLastErrorErrno(): int {}
-	public function getLastDisconnectedServer(): false|array {}
-
-	public function getStats(?string $type=null): false|array {}
-	public function getVersion(): false|array {}
-	public function getAllKeys(): false|array {}
-
-	public function flush(int $delay=0): bool {}
-
-	public function getOption(int $option): mixed {}
-	public function setOption(int $option, mixed $value): bool {}
-	public function setOptions(array $options): bool {}
-	public function setBucket(array $host_map, ?array $forward_map, int $replicas): bool {}
-#ifdef HAVE_MEMCACHED_SASL
-	public function setSaslAuthData(string $username, string $password): bool {}
-#endif
-
-#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
-	public function setEncodingKey(string $key): bool {}
-#endif
-	public function isPersistent(): bool {}
-	public function isPristine(): bool {}
-	public function checkKey(string $key): bool {}
-}
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-class MemcachedServer {
-
-	public function run(string $address): bool {}
-	public function on(int $event, callable $callback): bool {}
-}
-#endif

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached_arginfo.h Deleted

@@ -1,417 +0,0 @@
-/* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 3f4694d4e1f3d1647a832acd8539b056b2ab5e7a */
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached___construct, 0, 0, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, persistent_id, IS_STRING, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, callback, IS_CALLABLE, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, connection_str, IS_STRING, 1, "null")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getResultCode, 0, 0, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getResultMessage, 0, 0, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_get, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cache_cb, IS_CALLABLE, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getByKey, 0, 2, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cache_cb, IS_CALLABLE, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getMulti, 0, 1, MAY_BE_FALSE|MAY_BE_ARRAY)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getMultiByKey, 0, 2, MAY_BE_FALSE|MAY_BE_ARRAY)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getDelayed, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, with_cas, _IS_BOOL, 0, "false")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, value_cb, IS_CALLABLE, 1, "null")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getDelayedByKey, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, with_cas, _IS_BOOL, 0, "false")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, value_cb, IS_CALLABLE, 1, "null")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_fetch, 0, 0, MAY_BE_FALSE|MAY_BE_ARRAY)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_fetchAll arginfo_class_Memcached_fetch
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_set, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setByKey, 0, 3, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_touch, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_touchByKey, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setMulti, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, items, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setMultiByKey, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, items, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_cas, 0, 3, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, cas_token, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_casByKey, 0, 4, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, cas_token, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_add arginfo_class_Memcached_set
-
-#define arginfo_class_Memcached_addByKey arginfo_class_Memcached_setByKey
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_append, 0, 2, _IS_BOOL, 1)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_appendByKey, 0, 3, _IS_BOOL, 1)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_prepend arginfo_class_Memcached_append
-
-#define arginfo_class_Memcached_prependByKey arginfo_class_Memcached_appendByKey
-
-#define arginfo_class_Memcached_replace arginfo_class_Memcached_set
-
-#define arginfo_class_Memcached_replaceByKey arginfo_class_Memcached_setByKey
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_delete, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteMulti, 0, 1, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteByKey, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteMultiByKey, 0, 2, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_increment, 0, 1, MAY_BE_FALSE|MAY_BE_LONG)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "1")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, initial_value, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiry, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_decrement arginfo_class_Memcached_increment
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_incrementByKey, 0, 2, MAY_BE_FALSE|MAY_BE_LONG)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "1")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, initial_value, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiry, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_decrementByKey arginfo_class_Memcached_incrementByKey
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_addServer, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, host, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, port, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, weight, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_addServers, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, servers, IS_ARRAY, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getServerList, 0, 0, IS_ARRAY, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getServerByKey, 0, 1, MAY_BE_FALSE|MAY_BE_ARRAY)
-	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_resetServerList, 0, 0, _IS_BOOL, 0)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_quit arginfo_class_Memcached_resetServerList
-
-#define arginfo_class_Memcached_flushBuffers arginfo_class_Memcached_resetServerList
-
-#define arginfo_class_Memcached_getLastErrorMessage arginfo_class_Memcached_getResultMessage
-
-#define arginfo_class_Memcached_getLastErrorCode arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastErrorErrno arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastDisconnectedServer arginfo_class_Memcached_fetch
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getStats, 0, 0, MAY_BE_FALSE|MAY_BE_ARRAY)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, type, IS_STRING, 1, "null")
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_getVersion arginfo_class_Memcached_fetch
-
-#define arginfo_class_Memcached_getAllKeys arginfo_class_Memcached_fetch
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_flush, 0, 0, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delay, IS_LONG, 0, "0")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getOption, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setOption, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setOptions, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, options, IS_ARRAY, 0)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setBucket, 0, 3, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, host_map, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, forward_map, IS_ARRAY, 1)
-	ZEND_ARG_TYPE_INFO(0, replicas, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
-#if defined(HAVE_MEMCACHED_SASL)
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setSaslAuthData, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, username, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, password, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-#endif
-
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setEncodingKey, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-#endif
-
-#define arginfo_class_Memcached_isPersistent arginfo_class_Memcached_resetServerList
-
-#define arginfo_class_Memcached_isPristine arginfo_class_Memcached_resetServerList
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_checkKey, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_MemcachedServer_run, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
-ZEND_END_ARG_INFO()
-#endif
-
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_MemcachedServer_on, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, event, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
-ZEND_END_ARG_INFO()
-#endif
-
-
-ZEND_METHOD(Memcached, __construct);
-ZEND_METHOD(Memcached, getResultCode);
-ZEND_METHOD(Memcached, getResultMessage);
-ZEND_METHOD(Memcached, get);
-ZEND_METHOD(Memcached, getByKey);
-ZEND_METHOD(Memcached, getMulti);
-ZEND_METHOD(Memcached, getMultiByKey);
-ZEND_METHOD(Memcached, getDelayed);
-ZEND_METHOD(Memcached, getDelayedByKey);
-ZEND_METHOD(Memcached, fetch);
-ZEND_METHOD(Memcached, fetchAll);
-ZEND_METHOD(Memcached, set);
-ZEND_METHOD(Memcached, setByKey);
-ZEND_METHOD(Memcached, touch);
-ZEND_METHOD(Memcached, touchByKey);
-ZEND_METHOD(Memcached, setMulti);
-ZEND_METHOD(Memcached, setMultiByKey);
-ZEND_METHOD(Memcached, cas);
-ZEND_METHOD(Memcached, casByKey);
-ZEND_METHOD(Memcached, add);
-ZEND_METHOD(Memcached, addByKey);
-ZEND_METHOD(Memcached, append);
-ZEND_METHOD(Memcached, appendByKey);
-ZEND_METHOD(Memcached, prepend);
-ZEND_METHOD(Memcached, prependByKey);
-ZEND_METHOD(Memcached, replace);
-ZEND_METHOD(Memcached, replaceByKey);
-ZEND_METHOD(Memcached, delete);
-ZEND_METHOD(Memcached, deleteMulti);
-ZEND_METHOD(Memcached, deleteByKey);
-ZEND_METHOD(Memcached, deleteMultiByKey);
-ZEND_METHOD(Memcached, increment);
-ZEND_METHOD(Memcached, decrement);
-ZEND_METHOD(Memcached, incrementByKey);
-ZEND_METHOD(Memcached, decrementByKey);
-ZEND_METHOD(Memcached, addServer);
-ZEND_METHOD(Memcached, addServers);
-ZEND_METHOD(Memcached, getServerList);
-ZEND_METHOD(Memcached, getServerByKey);
-ZEND_METHOD(Memcached, resetServerList);
-ZEND_METHOD(Memcached, quit);
-ZEND_METHOD(Memcached, flushBuffers);
-ZEND_METHOD(Memcached, getLastErrorMessage);
-ZEND_METHOD(Memcached, getLastErrorCode);
-ZEND_METHOD(Memcached, getLastErrorErrno);
-ZEND_METHOD(Memcached, getLastDisconnectedServer);
-ZEND_METHOD(Memcached, getStats);
-ZEND_METHOD(Memcached, getVersion);
-ZEND_METHOD(Memcached, getAllKeys);
-ZEND_METHOD(Memcached, flush);
-ZEND_METHOD(Memcached, getOption);
-ZEND_METHOD(Memcached, setOption);
-ZEND_METHOD(Memcached, setOptions);
-ZEND_METHOD(Memcached, setBucket);
-#if defined(HAVE_MEMCACHED_SASL)
-ZEND_METHOD(Memcached, setSaslAuthData);
-#endif
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-ZEND_METHOD(Memcached, setEncodingKey);
-#endif
-ZEND_METHOD(Memcached, isPersistent);
-ZEND_METHOD(Memcached, isPristine);
-ZEND_METHOD(Memcached, checkKey);
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_METHOD(MemcachedServer, run);
-#endif
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_METHOD(MemcachedServer, on);
-#endif
-
-
-static const zend_function_entry class_Memcached_methods = {
-	ZEND_ME(Memcached, __construct, arginfo_class_Memcached___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getResultCode, arginfo_class_Memcached_getResultCode, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getResultMessage, arginfo_class_Memcached_getResultMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, get, arginfo_class_Memcached_get, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getByKey, arginfo_class_Memcached_getByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getMulti, arginfo_class_Memcached_getMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getMultiByKey, arginfo_class_Memcached_getMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getDelayed, arginfo_class_Memcached_getDelayed, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getDelayedByKey, arginfo_class_Memcached_getDelayedByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, fetch, arginfo_class_Memcached_fetch, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, fetchAll, arginfo_class_Memcached_fetchAll, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, set, arginfo_class_Memcached_set, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setByKey, arginfo_class_Memcached_setByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, touch, arginfo_class_Memcached_touch, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, touchByKey, arginfo_class_Memcached_touchByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setMulti, arginfo_class_Memcached_setMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setMultiByKey, arginfo_class_Memcached_setMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, cas, arginfo_class_Memcached_cas, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, casByKey, arginfo_class_Memcached_casByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, add, arginfo_class_Memcached_add, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addByKey, arginfo_class_Memcached_addByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, append, arginfo_class_Memcached_append, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, appendByKey, arginfo_class_Memcached_appendByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, prepend, arginfo_class_Memcached_prepend, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, prependByKey, arginfo_class_Memcached_prependByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, replace, arginfo_class_Memcached_replace, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, replaceByKey, arginfo_class_Memcached_replaceByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, delete, arginfo_class_Memcached_delete, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteMulti, arginfo_class_Memcached_deleteMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteByKey, arginfo_class_Memcached_deleteByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteMultiByKey, arginfo_class_Memcached_deleteMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, increment, arginfo_class_Memcached_increment, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, decrement, arginfo_class_Memcached_decrement, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, incrementByKey, arginfo_class_Memcached_incrementByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, decrementByKey, arginfo_class_Memcached_decrementByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addServer, arginfo_class_Memcached_addServer, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addServers, arginfo_class_Memcached_addServers, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getServerList, arginfo_class_Memcached_getServerList, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getServerByKey, arginfo_class_Memcached_getServerByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, resetServerList, arginfo_class_Memcached_resetServerList, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, quit, arginfo_class_Memcached_quit, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, flushBuffers, arginfo_class_Memcached_flushBuffers, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorMessage, arginfo_class_Memcached_getLastErrorMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorCode, arginfo_class_Memcached_getLastErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorErrno, arginfo_class_Memcached_getLastErrorErrno, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastDisconnectedServer, arginfo_class_Memcached_getLastDisconnectedServer, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getStats, arginfo_class_Memcached_getStats, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getVersion, arginfo_class_Memcached_getVersion, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getAllKeys, arginfo_class_Memcached_getAllKeys, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, flush, arginfo_class_Memcached_flush, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getOption, arginfo_class_Memcached_getOption, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setOption, arginfo_class_Memcached_setOption, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setOptions, arginfo_class_Memcached_setOptions, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setBucket, arginfo_class_Memcached_setBucket, ZEND_ACC_PUBLIC)
-#if defined(HAVE_MEMCACHED_SASL)
-	ZEND_ME(Memcached, setSaslAuthData, arginfo_class_Memcached_setSaslAuthData, ZEND_ACC_PUBLIC)
-#endif
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-	ZEND_ME(Memcached, setEncodingKey, arginfo_class_Memcached_setEncodingKey, ZEND_ACC_PUBLIC)
-#endif
-	ZEND_ME(Memcached, isPersistent, arginfo_class_Memcached_isPersistent, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, isPristine, arginfo_class_Memcached_isPristine, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, checkKey, arginfo_class_Memcached_checkKey, ZEND_ACC_PUBLIC)
-	ZEND_FE_END
-};
-
-
-static const zend_function_entry class_MemcachedServer_methods = {
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-	ZEND_ME(MemcachedServer, run, arginfo_class_MemcachedServer_run, ZEND_ACC_PUBLIC)
-#endif
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-	ZEND_ME(MemcachedServer, on, arginfo_class_MemcachedServer_on, ZEND_ACC_PUBLIC)
-#endif
-	ZEND_FE_END
-};

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached_legacy_arginfo.h Deleted

@@ -1,413 +0,0 @@
-/* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 3f4694d4e1f3d1647a832acd8539b056b2ab5e7a */
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached___construct, 0, 0, 0)
-	ZEND_ARG_INFO(0, persistent_id)
-	ZEND_ARG_INFO(0, callback)
-	ZEND_ARG_INFO(0, connection_str)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getResultCode, 0, 0, 0)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_getResultMessage arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_get, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, cache_cb)
-	ZEND_ARG_INFO(0, get_flags)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, cache_cb)
-	ZEND_ARG_INFO(0, get_flags)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getMulti, 0, 0, 1)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, get_flags)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getMultiByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, get_flags)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getDelayed, 0, 0, 1)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, with_cas)
-	ZEND_ARG_INFO(0, value_cb)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getDelayedByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, with_cas)
-	ZEND_ARG_INFO(0, value_cb)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_fetch arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_fetchAll arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_set, 0, 0, 2)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setByKey, 0, 0, 3)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_touch, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_touchByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setMulti, 0, 0, 1)
-	ZEND_ARG_INFO(0, items)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setMultiByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, items)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_cas, 0, 0, 3)
-	ZEND_ARG_INFO(0, cas_token)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_casByKey, 0, 0, 4)
-	ZEND_ARG_INFO(0, cas_token)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-	ZEND_ARG_INFO(0, expiration)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_add arginfo_class_Memcached_set
-
-#define arginfo_class_Memcached_addByKey arginfo_class_Memcached_setByKey
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_append, 0, 0, 2)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_appendByKey, 0, 0, 3)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, value)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_prepend arginfo_class_Memcached_append
-
-#define arginfo_class_Memcached_prependByKey arginfo_class_Memcached_appendByKey
-
-#define arginfo_class_Memcached_replace arginfo_class_Memcached_set
-
-#define arginfo_class_Memcached_replaceByKey arginfo_class_Memcached_setByKey
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_delete, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, time)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteMulti, 0, 0, 1)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, time)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, time)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteMultiByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, keys)
-	ZEND_ARG_INFO(0, time)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_increment, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, offset)
-	ZEND_ARG_INFO(0, initial_value)
-	ZEND_ARG_INFO(0, expiry)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_decrement arginfo_class_Memcached_increment
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_incrementByKey, 0, 0, 2)
-	ZEND_ARG_INFO(0, server_key)
-	ZEND_ARG_INFO(0, key)
-	ZEND_ARG_INFO(0, offset)
-	ZEND_ARG_INFO(0, initial_value)
-	ZEND_ARG_INFO(0, expiry)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_decrementByKey arginfo_class_Memcached_incrementByKey
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_addServer, 0, 0, 2)
-	ZEND_ARG_INFO(0, host)
-	ZEND_ARG_INFO(0, port)
-	ZEND_ARG_INFO(0, weight)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_addServers, 0, 0, 1)
-	ZEND_ARG_INFO(0, servers)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_getServerList arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getServerByKey, 0, 0, 1)
-	ZEND_ARG_INFO(0, server_key)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_resetServerList arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_quit arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_flushBuffers arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastErrorMessage arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastErrorCode arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastErrorErrno arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getLastDisconnectedServer arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getStats, 0, 0, 0)
-	ZEND_ARG_INFO(0, type)
-ZEND_END_ARG_INFO()
-
-#define arginfo_class_Memcached_getVersion arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_getAllKeys arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_flush, 0, 0, 0)
-	ZEND_ARG_INFO(0, delay)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getOption, 0, 0, 1)
-	ZEND_ARG_INFO(0, option)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setOption, 0, 0, 2)
-	ZEND_ARG_INFO(0, option)
-	ZEND_ARG_INFO(0, value)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setOptions, 0, 0, 1)
-	ZEND_ARG_INFO(0, options)
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setBucket, 0, 0, 3)
-	ZEND_ARG_INFO(0, host_map)
-	ZEND_ARG_INFO(0, forward_map)
-	ZEND_ARG_INFO(0, replicas)
-ZEND_END_ARG_INFO()
-
-#if defined(HAVE_MEMCACHED_SASL)
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setSaslAuthData, 0, 0, 2)
-	ZEND_ARG_INFO(0, username)
-	ZEND_ARG_INFO(0, password)
-ZEND_END_ARG_INFO()
-#endif
-
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setEncodingKey, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-ZEND_END_ARG_INFO()
-#endif
-
-#define arginfo_class_Memcached_isPersistent arginfo_class_Memcached_getResultCode
-
-#define arginfo_class_Memcached_isPristine arginfo_class_Memcached_getResultCode
-
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_checkKey, 0, 0, 1)
-	ZEND_ARG_INFO(0, key)
-ZEND_END_ARG_INFO()
-
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_MemcachedServer_run, 0, 0, 1)
-	ZEND_ARG_INFO(0, address)
-ZEND_END_ARG_INFO()
-#endif
-
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_MemcachedServer_on, 0, 0, 2)
-	ZEND_ARG_INFO(0, event)
-	ZEND_ARG_INFO(0, callback)
-ZEND_END_ARG_INFO()
-#endif
-
-
-ZEND_METHOD(Memcached, __construct);
-ZEND_METHOD(Memcached, getResultCode);
-ZEND_METHOD(Memcached, getResultMessage);
-ZEND_METHOD(Memcached, get);
-ZEND_METHOD(Memcached, getByKey);
-ZEND_METHOD(Memcached, getMulti);
-ZEND_METHOD(Memcached, getMultiByKey);
-ZEND_METHOD(Memcached, getDelayed);
-ZEND_METHOD(Memcached, getDelayedByKey);
-ZEND_METHOD(Memcached, fetch);
-ZEND_METHOD(Memcached, fetchAll);
-ZEND_METHOD(Memcached, set);
-ZEND_METHOD(Memcached, setByKey);
-ZEND_METHOD(Memcached, touch);
-ZEND_METHOD(Memcached, touchByKey);
-ZEND_METHOD(Memcached, setMulti);
-ZEND_METHOD(Memcached, setMultiByKey);
-ZEND_METHOD(Memcached, cas);
-ZEND_METHOD(Memcached, casByKey);
-ZEND_METHOD(Memcached, add);
-ZEND_METHOD(Memcached, addByKey);
-ZEND_METHOD(Memcached, append);
-ZEND_METHOD(Memcached, appendByKey);
-ZEND_METHOD(Memcached, prepend);
-ZEND_METHOD(Memcached, prependByKey);
-ZEND_METHOD(Memcached, replace);
-ZEND_METHOD(Memcached, replaceByKey);
-ZEND_METHOD(Memcached, delete);
-ZEND_METHOD(Memcached, deleteMulti);
-ZEND_METHOD(Memcached, deleteByKey);
-ZEND_METHOD(Memcached, deleteMultiByKey);
-ZEND_METHOD(Memcached, increment);
-ZEND_METHOD(Memcached, decrement);
-ZEND_METHOD(Memcached, incrementByKey);
-ZEND_METHOD(Memcached, decrementByKey);
-ZEND_METHOD(Memcached, addServer);
-ZEND_METHOD(Memcached, addServers);
-ZEND_METHOD(Memcached, getServerList);
-ZEND_METHOD(Memcached, getServerByKey);
-ZEND_METHOD(Memcached, resetServerList);
-ZEND_METHOD(Memcached, quit);
-ZEND_METHOD(Memcached, flushBuffers);
-ZEND_METHOD(Memcached, getLastErrorMessage);
-ZEND_METHOD(Memcached, getLastErrorCode);
-ZEND_METHOD(Memcached, getLastErrorErrno);
-ZEND_METHOD(Memcached, getLastDisconnectedServer);
-ZEND_METHOD(Memcached, getStats);
-ZEND_METHOD(Memcached, getVersion);
-ZEND_METHOD(Memcached, getAllKeys);
-ZEND_METHOD(Memcached, flush);
-ZEND_METHOD(Memcached, getOption);
-ZEND_METHOD(Memcached, setOption);
-ZEND_METHOD(Memcached, setOptions);
-ZEND_METHOD(Memcached, setBucket);
-#if defined(HAVE_MEMCACHED_SASL)
-ZEND_METHOD(Memcached, setSaslAuthData);
-#endif
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-ZEND_METHOD(Memcached, setEncodingKey);
-#endif
-ZEND_METHOD(Memcached, isPersistent);
-ZEND_METHOD(Memcached, isPristine);
-ZEND_METHOD(Memcached, checkKey);
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_METHOD(MemcachedServer, run);
-#endif
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-ZEND_METHOD(MemcachedServer, on);
-#endif
-
-
-static const zend_function_entry class_Memcached_methods = {
-	ZEND_ME(Memcached, __construct, arginfo_class_Memcached___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getResultCode, arginfo_class_Memcached_getResultCode, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getResultMessage, arginfo_class_Memcached_getResultMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, get, arginfo_class_Memcached_get, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getByKey, arginfo_class_Memcached_getByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getMulti, arginfo_class_Memcached_getMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getMultiByKey, arginfo_class_Memcached_getMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getDelayed, arginfo_class_Memcached_getDelayed, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getDelayedByKey, arginfo_class_Memcached_getDelayedByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, fetch, arginfo_class_Memcached_fetch, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, fetchAll, arginfo_class_Memcached_fetchAll, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, set, arginfo_class_Memcached_set, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setByKey, arginfo_class_Memcached_setByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, touch, arginfo_class_Memcached_touch, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, touchByKey, arginfo_class_Memcached_touchByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setMulti, arginfo_class_Memcached_setMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setMultiByKey, arginfo_class_Memcached_setMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, cas, arginfo_class_Memcached_cas, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, casByKey, arginfo_class_Memcached_casByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, add, arginfo_class_Memcached_add, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addByKey, arginfo_class_Memcached_addByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, append, arginfo_class_Memcached_append, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, appendByKey, arginfo_class_Memcached_appendByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, prepend, arginfo_class_Memcached_prepend, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, prependByKey, arginfo_class_Memcached_prependByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, replace, arginfo_class_Memcached_replace, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, replaceByKey, arginfo_class_Memcached_replaceByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, delete, arginfo_class_Memcached_delete, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteMulti, arginfo_class_Memcached_deleteMulti, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteByKey, arginfo_class_Memcached_deleteByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, deleteMultiByKey, arginfo_class_Memcached_deleteMultiByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, increment, arginfo_class_Memcached_increment, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, decrement, arginfo_class_Memcached_decrement, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, incrementByKey, arginfo_class_Memcached_incrementByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, decrementByKey, arginfo_class_Memcached_decrementByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addServer, arginfo_class_Memcached_addServer, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, addServers, arginfo_class_Memcached_addServers, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getServerList, arginfo_class_Memcached_getServerList, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getServerByKey, arginfo_class_Memcached_getServerByKey, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, resetServerList, arginfo_class_Memcached_resetServerList, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, quit, arginfo_class_Memcached_quit, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, flushBuffers, arginfo_class_Memcached_flushBuffers, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorMessage, arginfo_class_Memcached_getLastErrorMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorCode, arginfo_class_Memcached_getLastErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastErrorErrno, arginfo_class_Memcached_getLastErrorErrno, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getLastDisconnectedServer, arginfo_class_Memcached_getLastDisconnectedServer, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getStats, arginfo_class_Memcached_getStats, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getVersion, arginfo_class_Memcached_getVersion, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getAllKeys, arginfo_class_Memcached_getAllKeys, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, flush, arginfo_class_Memcached_flush, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, getOption, arginfo_class_Memcached_getOption, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setOption, arginfo_class_Memcached_setOption, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setOptions, arginfo_class_Memcached_setOptions, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, setBucket, arginfo_class_Memcached_setBucket, ZEND_ACC_PUBLIC)
-#if defined(HAVE_MEMCACHED_SASL)
-	ZEND_ME(Memcached, setSaslAuthData, arginfo_class_Memcached_setSaslAuthData, ZEND_ACC_PUBLIC)
-#endif
-#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
-	ZEND_ME(Memcached, setEncodingKey, arginfo_class_Memcached_setEncodingKey, ZEND_ACC_PUBLIC)
-#endif
-	ZEND_ME(Memcached, isPersistent, arginfo_class_Memcached_isPersistent, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, isPristine, arginfo_class_Memcached_isPristine, ZEND_ACC_PUBLIC)
-	ZEND_ME(Memcached, checkKey, arginfo_class_Memcached_checkKey, ZEND_ACC_PUBLIC)
-	ZEND_FE_END
-};
-
-
-static const zend_function_entry class_MemcachedServer_methods = {
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-	ZEND_ME(MemcachedServer, run, arginfo_class_MemcachedServer_run, ZEND_ACC_PUBLIC)
-#endif
-#if defined(HAVE_MEMCACHED_PROTOCOL)
-	ZEND_ME(MemcachedServer, on, arginfo_class_MemcachedServer_on, ZEND_ACC_PUBLIC)
-#endif
-	ZEND_FE_END
-};

memcached-3.2.0.tgz/memcached-3.2.0/php_memcached_private.h Deleted

@@ -1,252 +0,0 @@
-/*
-  +----------------------------------------------------------------------+
-  | Copyright (c) 2009 The PHP Group                                     |
-  +----------------------------------------------------------------------+
-  | This source file is subject to version 3.0 of the PHP license,       |
-  | that is bundled with this package in the file LICENSE, and is        |
-  | available through the world-wide-web at the following url:           |
-  | http://www.php.net/license/3_0.txt.                                  |
-  | If you did not receive a copy of the PHP license and are unable to   |
-  | obtain it through the world-wide-web, please send a note to          |
-  | license@php.net so we can mail you a copy immediately.               |
-  +----------------------------------------------------------------------+
-  | Authors: Andrei Zmievski <andrei@php.net>                            |
-  +----------------------------------------------------------------------+
-*/
-
-#ifndef PHP_MEMCACHED_PRIVATE_H
-#define PHP_MEMCACHED_PRIVATE_H
-
-#ifdef PHP_WIN32
-#include "main/config.w32.h"
-#else
-#include "main/php_config.h"
-#endif
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include "php_libmemcached_compat.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <php.h>
-#include <php_main.h>
-
-#ifdef ZTS
-#  include "TSRM.h"
-#endif
-
-#include <php_ini.h>
-#include <SAPI.h>
-#include <ext/standard/info.h>
-#include <zend_extensions.h>
-#include <zend_exceptions.h>
-#include <ext/standard/php_smart_string.h>
-#include <ext/standard/php_var.h>
-#include <ext/standard/basic_functions.h>
-
-#ifdef PHP_WIN32
-  #  if PHP_VERSION_ID >= 80000
-  #  include "php_stdint.h"
-#else
-# include "win32/php_stdint.h"
-#endif
-#else
-/* Used to store the size of the block */
-#  if defined(HAVE_INTTYPES_H)
-#    include <inttypes.h>
-#  elif defined(HAVE_STDINT_H)
-#    include <stdint.h>
-#  endif
-#endif
-
-#ifndef HAVE_INT32_T
-#  if SIZEOF_INT == 4
-typedef int int32_t;
-#  elif SIZEOF_LONG == 4
-typedef long int int32_t;
-#  endif
-#endif
-
-#ifndef HAVE_UINT32_T
-#  if SIZEOF_INT == 4
-typedef unsigned int uint32_t;
-#  elif SIZEOF_LONG == 4
-typedef unsigned long int uint32_t;
-#  endif
-#endif
-
-/* Backwards compatibility for GC API change in PHP 7.3 */
-#if PHP_VERSION_ID < 70300
-#  define GC_ADDREF(p)            ++GC_REFCOUNT(p)
-#  define GC_DELREF(p)            --GC_REFCOUNT(p)
-#  define GC_SET_REFCOUNT(p, rc)  GC_REFCOUNT(p) = rc
-#endif
-
-/****************************************
-  Structures and definitions
-****************************************/
-typedef enum {
-	SERIALIZER_PHP        = 1,
-	SERIALIZER_IGBINARY   = 2,
-	SERIALIZER_JSON       = 3,
-	SERIALIZER_JSON_ARRAY = 4,
-	SERIALIZER_MSGPACK    = 5
-} php_memc_serializer_type;
-
-typedef enum {
-	COMPRESSION_TYPE_ZLIB   = 1,
-	COMPRESSION_TYPE_FASTLZ = 2
-} php_memc_compression_type;
-
-typedef struct {
-	const char *name;
-	php_memc_serializer_type type;
-} php_memc_serializer;
-
-#if defined(HAVE_MEMCACHED_IGBINARY)
-# define SERIALIZER_DEFAULT SERIALIZER_IGBINARY
-# define SERIALIZER_DEFAULT_NAME "igbinary"
-#elif defined(HAVE_MEMCACHED_MSGPACK)
-# define SERIALIZER_DEFAULT SERIALIZER_MSGPACK
-# define SERIALIZER_DEFAULT_NAME "msgpack"
-#else
-# define SERIALIZER_DEFAULT SERIALIZER_PHP
-# define SERIALIZER_DEFAULT_NAME "php"
-#endif /* HAVE_MEMCACHED_IGBINARY / HAVE_MEMCACHED_MSGPACK */
-
-#ifdef HAVE_MEMCACHED_SASL
-# include <sasl/sasl.h>
-#endif
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-typedef enum {
-	MEMC_SERVER_ON_MIN       = -1,
-	MEMC_SERVER_ON_CONNECT   = 0,
-	MEMC_SERVER_ON_ADD       = 1,
-	MEMC_SERVER_ON_APPEND    = 2,
-	MEMC_SERVER_ON_DECREMENT = 3,
-	MEMC_SERVER_ON_DELETE    = 4,
-	MEMC_SERVER_ON_FLUSH     = 5,
-	MEMC_SERVER_ON_GET       = 6,
-	MEMC_SERVER_ON_INCREMENT = 7,
-	MEMC_SERVER_ON_NOOP      = 8,
-	MEMC_SERVER_ON_PREPEND   = 9,
-	MEMC_SERVER_ON_QUIT      = 10,
-	MEMC_SERVER_ON_REPLACE   = 11,
-	MEMC_SERVER_ON_SET       = 12,
-	MEMC_SERVER_ON_STAT      = 13,
-	MEMC_SERVER_ON_VERSION   = 14,
-	MEMC_SERVER_ON_MAX
-} php_memc_event_t;
-
-
-typedef struct {
-	zend_fcall_info fci;
-	zend_fcall_info_cache fci_cache;
-} php_memc_server_cb_t;
-#endif
-
-ZEND_BEGIN_MODULE_GLOBALS(php_memcached)
-
-#ifdef HAVE_MEMCACHED_SESSION
-	/* Session related variables */
-	struct {
-		zend_bool lock_enabled;
-		zend_long lock_wait_max;
-		zend_long lock_wait_min;
-		zend_long lock_retries;
-		zend_long lock_expiration;
-
-		zend_bool binary_protocol_enabled;
-		zend_bool consistent_hash_enabled;
-		char     *consistent_hash_name;
-		int       consistent_hash_type;
-
-		zend_long server_failure_limit;
-		zend_long number_of_replicas;
-		zend_bool randomize_replica_read_enabled;
-		zend_bool remove_failed_servers_enabled;
-
-		zend_long connect_timeout;
-
-		char *prefix;
-		zend_bool persistent_enabled;
-
-		char *sasl_username;
-		char *sasl_password;
-	} session;
-#endif
-
-	struct {
-		char     *serializer_name;
-		char     *compression_name;
-		zend_long compression_threshold;
-		double    compression_factor;
-		zend_long store_retry_count;
-
-		/* Converted values*/
-		php_memc_serializer_type  serializer_type;
-		php_memc_compression_type compression_type;
-
-		/* Whether we have initialised sasl for this process */
-		zend_bool sasl_initialised;
-
-		struct {
-
-			zend_bool consistent_hash_enabled;
-			zend_bool binary_protocol_enabled;
-			zend_long connect_timeout;
-
-		} default_behavior;
-
-	} memc;
-
-	/* For deprecated values */
-	zend_long no_effect;
-
-#ifdef HAVE_MEMCACHED_PROTOCOL
-	struct {
-		php_memc_server_cb_t callbacks MEMC_SERVER_ON_MAX;
-	} server;
-#endif
-
-ZEND_END_MODULE_GLOBALS(php_memcached)
-
-/* Globals accessor macros */
-#ifdef ZTS
-#  define MEMC_G(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, memc.v)
-#  define MEMC_SERVER_G(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, server.v)
-#  define MEMC_SESS_INI(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, session.v)
-#else
-#  define MEMC_G(v) (php_memcached_globals.memc.v)
-#  define MEMC_SERVER_G(v) (php_memcached_globals.server.v)
-#  define MEMC_SESS_INI(v) (php_memcached_globals.session.v)
-#endif
-
-#define MEMC_SESS_STR_INI(vv) ((MEMC_SESS_INI(vv) && *MEMC_SESS_INI(vv)) ? MEMC_SESS_INI(vv) : NULL)
-
-PHP_RINIT_FUNCTION(memcached);
-PHP_RSHUTDOWN_FUNCTION(memcached);
-PHP_MINIT_FUNCTION(memcached);
-PHP_MSHUTDOWN_FUNCTION(memcached);
-PHP_MINFO_FUNCTION(memcached);
-
-char *php_memc_printable_func (zend_fcall_info *fci, zend_fcall_info_cache *fci_cache);
-
-memcached_return php_memcached_exist (memcached_st *memc, zend_string *key);
-
-zend_bool php_memc_init_sasl_if_needed();
-
-#endif /* PHP_MEMCACHED_PRIVATE_H */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: noet sw=4 ts=4 fdm=marker
- * vim<600: noet sw=4 ts=4
- */

memcached-3.2.0.tgz/memcached-3.2.0/tests/compression_conditions.phpt Deleted

@@ -1,123 +0,0 @@
---TEST--
-Memcached compression test
---SKIPIF--
-<?php if (!extension_loaded("memcached")) print "skip"; ?>
---FILE--
-<?php
-include dirname (__FILE__) . '/config.inc';
-$m = memc_get_instance ();
-
-$short_data = "abcdefg";
-$data = file_get_contents(dirname(__FILE__) . '/testdata.res');
-
-set_error_handler(function($errno, $errstr, $errfile, $errline, array $errcontext) {
-	echo "$errstr\n";
-	return true;
-}, E_WARNING);
-
-function get_compression($name) {
-	switch (strtolower($name)) {
-		case 'zlib':
-			return Memcached::COMPRESSION_ZLIB;
-		case 'fastlz':
-			return Memcached::COMPRESSION_FASTLZ;
-		default:
-			echo "Strange compression type: $name\n";
-			return 0;
-	}
-}
-
-function fetch_with_compression($m, $key, $value, $set_compression = '', $factor = 1.3, $threshold = 2000) {
- 	ini_set("memcached.compression_factor", $factor);
- 	ini_set("memcached.compression_threshold", $threshold);
-	
-	$len=strlen($value);
-	echo "len=$len set=$set_compression factor=$factor threshold=$threshold\n";
-	
-	if (!$set_compression) {
-		$m->setOption(Memcached::OPT_COMPRESSION, false);
-	} else {
-		$m->setOption(Memcached::OPT_COMPRESSION, true);
-		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($set_compression));
-	}
-	
-	$m->set($key, $value, 1800);
-	
-	$value_back = $m->get($key);
-	var_dump($value === $value_back);
-}
-
-fetch_with_compression($m, 'hello01', $data, 'zlib',         1.3, 4);
-fetch_with_compression($m, 'hello02', $data, 'fastlz',       1.3, 4);
-fetch_with_compression($m, 'hello03', $data, '',             1.3, 4);
-fetch_with_compression($m, 'hello04', $short_data, 'zlib',   1.3, 4);
-fetch_with_compression($m, 'hello05', $short_data, 'fastlz', 1.3, 4);
-fetch_with_compression($m, 'hello06', $short_data, '',       1.3, 4);
-fetch_with_compression($m, 'hello11', $data, 'zlib',         0.3, 4);
-fetch_with_compression($m, 'hello12', $data, 'fastlz',       0.3, 4);
-fetch_with_compression($m, 'hello13', $data, '',             0.3, 4);
-fetch_with_compression($m, 'hello14', $short_data, 'zlib',   0.3, 4);
-fetch_with_compression($m, 'hello15', $short_data, 'fastlz', 0.3, 4);
-fetch_with_compression($m, 'hello16', $short_data, '',       0.3, 4);
-fetch_with_compression($m, 'hello21', $data, 'zlib',         1.3, 2000);
-fetch_with_compression($m, 'hello22', $data, 'fastlz',       1.3, 2000);
-fetch_with_compression($m, 'hello23', $data, '',             1.3, 2000);
-fetch_with_compression($m, 'hello24', $short_data, 'zlib',   1.3, 2000);
-fetch_with_compression($m, 'hello25', $short_data, 'fastlz', 1.3, 2000);
-fetch_with_compression($m, 'hello26', $short_data, '',       1.3, 2000);
-fetch_with_compression($m, 'hello31', $data, 'zlib',         0.3, 2000);
-fetch_with_compression($m, 'hello32', $data, 'fastlz',       0.3, 2000);
-fetch_with_compression($m, 'hello33', $data, '',             0.3, 2000);
-fetch_with_compression($m, 'hello34', $short_data, 'zlib',   0.3, 2000);
-fetch_with_compression($m, 'hello35', $short_data, 'fastlz', 0.3, 2000);
-fetch_with_compression($m, 'hello36', $short_data, '',       0.3, 2000);
-?>
---EXPECT--
-len=4877 set=zlib factor=1.3 threshold=4
-bool(true)
-len=4877 set=fastlz factor=1.3 threshold=4
-bool(true)
-len=4877 set= factor=1.3 threshold=4
-bool(true)
-len=7 set=zlib factor=1.3 threshold=4
-bool(true)
-len=7 set=fastlz factor=1.3 threshold=4
-bool(true)
-len=7 set= factor=1.3 threshold=4
-bool(true)
-len=4877 set=zlib factor=0.3 threshold=4
-bool(true)
-len=4877 set=fastlz factor=0.3 threshold=4
-bool(true)
-len=4877 set= factor=0.3 threshold=4
-bool(true)
-len=7 set=zlib factor=0.3 threshold=4
-bool(true)
-len=7 set=fastlz factor=0.3 threshold=4
-bool(true)
-len=7 set= factor=0.3 threshold=4
-bool(true)
-len=4877 set=zlib factor=1.3 threshold=2000
-bool(true)
-len=4877 set=fastlz factor=1.3 threshold=2000
-bool(true)
-len=4877 set= factor=1.3 threshold=2000
-bool(true)
-len=7 set=zlib factor=1.3 threshold=2000
-bool(true)
-len=7 set=fastlz factor=1.3 threshold=2000
-bool(true)
-len=7 set= factor=1.3 threshold=2000
-bool(true)
-len=4877 set=zlib factor=0.3 threshold=2000
-bool(true)
-len=4877 set=fastlz factor=0.3 threshold=2000
-bool(true)
-len=4877 set= factor=0.3 threshold=2000
-bool(true)
-len=7 set=zlib factor=0.3 threshold=2000
-bool(true)
-len=7 set=fastlz factor=0.3 threshold=2000
-bool(true)
-len=7 set= factor=0.3 threshold=2000
-bool(true)

memcached-3.2.0.tgz/memcached-3.2.0/tests/compression_types.phpt Deleted

@@ -1,76 +0,0 @@
---TEST--
-Memcached compression test
---SKIPIF--
-<?php include "skipif.inc";?>
---FILE--
-<?php
-include dirname (__FILE__) . '/config.inc';
-$m = memc_get_instance ();
-
-$data = file_get_contents(dirname(__FILE__) . '/testdata.res');
-
-function get_compression($name) {
-	switch (strtolower($name)) {
-		case 'zlib':
-			return Memcached::COMPRESSION_ZLIB;
-		case 'fastlz':
-			return Memcached::COMPRESSION_FASTLZ;
-		default:
-			echo "Strange compression type: $name\n";
-			return 0;
-	}
-}
-
-function fetch_with_compression($m, $key, $value, $set_compression = '', $get_compression = '') {
-	
-	echo "set=$set_compression get=$get_compression\n";
-	
-	if (!$set_compression) {
-		$m->setOption(Memcached::OPT_COMPRESSION, false);
-	} else {
-		$m->setOption(Memcached::OPT_COMPRESSION, true);
-		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($set_compression));
-	}
-	
-	$m->set($key, $value, 1800);
-	
-	if (!$get_compression) {
-		$m->setOption(Memcached::OPT_COMPRESSION, true);
-	} else {
-		$m->setOption(Memcached::OPT_COMPRESSION, true);
-		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($get_compression));
-	}
-
-	$value_back = $m->get($key);
-	var_dump($value === $value_back);
-}
-
-fetch_with_compression($m, 'hello1', $data, 'zlib', 'zlib');
-fetch_with_compression($m, 'hello2', $data, 'zlib', 'fastlz');
-fetch_with_compression($m, 'hello3', $data, 'fastlz', 'fastlz');
-fetch_with_compression($m, 'hello4', $data, 'fastlz', 'zlib');
-fetch_with_compression($m, 'hello5', $data, '', 'zlib');
-fetch_with_compression($m, 'hello6', $data, '', 'fastlz');
-fetch_with_compression($m, 'hello7', $data, 'zlib', '');
-fetch_with_compression($m, 'hello8', $data, 'fastlz', '');
-fetch_with_compression($m, 'hello9', $data, '', '');
-?>
---EXPECT--
-set=zlib get=zlib
-bool(true)
-set=zlib get=fastlz
-bool(true)
-set=fastlz get=fastlz
-bool(true)
-set=fastlz get=zlib
-bool(true)
-set= get=zlib
-bool(true)
-set= get=fastlz
-bool(true)
-set=zlib get=
-bool(true)
-set=fastlz get=
-bool(true)
-set= get=
-bool(true)

memcached-3.2.0.tgz/memcached-3.2.0/tests/keys_ascii.phpt Deleted

@@ -1,190 +0,0 @@
---TEST--
-Test valid and invalid keys - ascii
---SKIPIF--
-<?php include "skipif.inc";?>
---FILE--
-<?php
-
-include dirname (__FILE__) . '/config.inc';
-$ascii = memc_get_instance (array (
-				Memcached::OPT_BINARY_PROTOCOL => false,
-				Memcached::OPT_VERIFY_KEY => false
-		));
-// libmemcached can verify keys, but these are tests are for our own
-// function s_memc_valid_key_ascii, so explicitly disable the checks
-// that libmemcached can perform.
-
-echo 'ASCII: SPACES' . PHP_EOL;
-var_dump ($ascii->set ('ascii key with spaces', 'this is a test'));
-var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-
-echo 'ASCII: NEWLINE' . PHP_EOL;
-var_dump ($ascii->set ('asciikeywithnewline' . PHP_EOL, 'this is a test'));
-var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-
-echo 'ASCII: EMPTY' . PHP_EOL;
-var_dump ($ascii->set (''/*empty key*/, 'this is a test'));
-var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-
-echo 'ASCII: TOO LONG' . PHP_EOL;
-var_dump ($ascii->set (str_repeat ('1234567890', 512), 'this is a test'));
-var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-
-echo 'ASCII: GET' . PHP_EOL;
-for ($i=0;$i<32;$i++) {
-	var_dump ($ascii->get ('asciikeywithnonprintablechar-' . chr($i) . '-here'));
-	var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-}
-
-echo 'ASCII: SET' . PHP_EOL;
-for ($i=0;$i<32;$i++) {
-	var_dump ($ascii->set ('asciikeywithnonprintablechar-' . chr($i) . '-here', 'this is a test'));
-	var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
-}
-
-echo 'OK' . PHP_EOL;
-
---EXPECT--
-ASCII: SPACES
-bool(false)
-bool(true)
-ASCII: NEWLINE
-bool(false)
-bool(true)
-ASCII: EMPTY
-bool(false)
-bool(true)
-ASCII: TOO LONG
-bool(false)
-bool(true)
-ASCII: GET
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-ASCII: SET
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-bool(false)
-bool(true)
-OK

memcached-3.2.0.tgz/memcached-3.2.0/tests/memcachedserver.phpt Deleted

@@ -1,119 +0,0 @@
---TEST--
-MemcachedServer
---SKIPIF--
-<?php
-if (!extension_loaded("memcached")) {
-	die("skip memcached is not loaded\n");
-}
-if (!class_exists("MemcachedServer")) {
-	die("skip memcached not built with libmemcachedprotocol support\n");
-}
-
-if (Memcached::LIBMEMCACHED_VERSION_HEX < 0x1001000) {
-       die("skip needs at least libmemcached 1.1.0\n");
-}
-?>
---FILE--
-<?php
-include __DIR__ . '/server.inc';
-$server = memcached_server_start();
-
-$cache = new Memcached();
-$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
-$cache->setOption(Memcached::OPT_COMPRESSION, false);
-$cache->addServer('127.0.0.1', 3434);
-
-$cache->add("add_key", "hello", 500);
-$cache->append("append_key", "world");
-$cache->prepend("prepend_key", "world");
-
-$cache->increment("incr", 2, 1, 500);
-$cache->decrement("decr", 2, 1, 500);
-
-$cache->delete("delete_k");
-$cache->flush(1);
-
-var_dump($cache->get('get_this'));
-
-$cache->set ('set_key', 'value 1', 100);
-$cache->replace ('replace_key', 'value 2', 200);
-
-var_dump($cache->getVersion());
-var_dump($cache->getStats());
-var_dump($cache->getStats("empty"));
-var_dump($cache->getStats("foobar"));
-var_dump($cache->getStats("scalar"));
-var_dump($cache->getStats("numeric array"));
-
-$cache->quit();
-usleep(50000);
-
-memcached_server_stop($server);
-?>
-Done
---EXPECTF--
-Listening on 127.0.0.1:3434
-Incoming connection from 127.0.0.1:%s
-Incoming connection from 127.0.0.1:%s
-client_id=%s: Add key=add_key, value=hello, flags=0, expiration=500
-client_id=%s: Append key=append_key, value=world, cas=0
-client_id=%s: Prepend key=prepend_key, value=world, cas=0
-client_id=%s: Incrementing key=incr, delta=2, initial=1, expiration=500
-client_id=%s: Decrementing key=decr, delta=2, initial=1, expiration=500
-client_id=%s: Delete key=delete_k, cas=0
-client_id=%s: Flush when=1
-client_id=%s: Get key=get_this
-client_id=%s: Noop
-string(20) "Hello to you client!"
-client_id=%s: Set key=set_key, value=value 1, flags=0, expiration=100, cas=0
-client_id=%s: Replace key=replace_key, value=value 2, flags=0, expiration=200, cas=0
-client_id=%s: Version
-array(1) {
-  "127.0.0.1:3434"=>
-  string(5) "1.1.1"
-}
-client_id=%s: Stat key=
-array(1) {
-  "127.0.0.1:3434"=>
-  array(2) {
-    "key"=>
-    string(0) ""
-    "foo"=>
-    string(3) "bar"
-  }
-}
-client_id=%s: Stat key=empty
-array(0) {
-}
-client_id=%s: Stat key=foobar
-array(1) {
-  "127.0.0.1:3434"=>
-  array(2) {
-    "key"=>
-    string(6) "foobar"
-    "foo"=>
-    string(3) "bar"
-  }
-}
-client_id=%s: Stat key=scalar
-array(1) {
-  "127.0.0.1:3434"=>
-  array(1) {
-    0=>
-    string(%d) "you want it, you get it"
-  }
-}
-client_id=%s: Stat key=numeric array
-array(1) {
-  "127.0.0.1:3434"=>
-  array(3) {
-    -1=>
-    string(3) "one"
-    0=>
-    string(3) "two"
-    1=>
-    string(5) "three"
-  }
-}
-client_id=%s: Client quit
-Done

memcached-3.2.0.tgz/memcached-3.2.0/tests/memcachedserver6.phpt Deleted

@@ -1,115 +0,0 @@
---TEST--
-MemcachedServer
---SKIPIF--
-<?php
-if (!extension_loaded("memcached")) {
-	die("skip memcached is not loaded\n");
-}
-if (!class_exists("MemcachedServer")) {
-	die("skip memcached not built with libmemcachedprotocol support\n");
-}
-?>
---FILE--
-<?php
-include __DIR__ . '/server.inc';
-$server = memcached_server_start('server.php', '::1', 3434);
-
-$cache = new Memcached();
-$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
-$cache->setOption(Memcached::OPT_COMPRESSION, false);
-$cache->addServer('::1', 3434);
-
-$cache->add("add_key", "hello", 500);
-$cache->append("append_key", "world");
-$cache->prepend("prepend_key", "world");
-
-$cache->increment("incr", 2, 1, 500);
-$cache->decrement("decr", 2, 1, 500);
-
-$cache->delete("delete_k");
-$cache->flush(1);
-
-var_dump($cache->get('get_this'));
-
-$cache->set ('set_key', 'value 1', 100);
-$cache->replace ('replace_key', 'value 2', 200);
-
-var_dump($cache->getVersion());
-var_dump($cache->getStats());
-var_dump($cache->getStats("empty"));
-var_dump($cache->getStats("foobar"));
-var_dump($cache->getStats("scalar"));
-var_dump($cache->getStats("numeric array"));
-
-$cache->quit();
-usleep(50000);
-
-memcached_server_stop($server);
-?>
-Done
---EXPECTF--
-Listening on ::1:3434
-Incoming connection from ::1:%s
-Incoming connection from ::1:%s
-client_id=%s: Add key=add_key, value=hello, flags=0, expiration=500
-client_id=%s: Append key=append_key, value=world, cas=0
-client_id=%s: Prepend key=prepend_key, value=world, cas=0
-client_id=%s: Incrementing key=incr, delta=2, initial=1, expiration=500
-client_id=%s: Decrementing key=decr, delta=2, initial=1, expiration=500
-client_id=%s: Delete key=delete_k, cas=0
-client_id=%s: Flush when=1
-client_id=%s: Get key=get_this
-client_id=%s: Noop
-string(20) "Hello to you client!"
-client_id=%s: Set key=set_key, value=value 1, flags=0, expiration=100, cas=0
-client_id=%s: Replace key=replace_key, value=value 2, flags=0, expiration=200, cas=0
-client_id=%s: Version
-array(1) {
-  "::1:3434"=>
-  string(5) "1.1.1"
-}
-client_id=%s: Stat key=
-array(1) {
-  "::1:3434"=>
-  array(2) {
-    "key"=>
-    string(0) ""
-    "foo"=>
-    string(3) "bar"
-  }
-}
-client_id=%s: Stat key=empty
-array(0) {
-}
-client_id=%s: Stat key=foobar
-array(1) {
-  "::1:3434"=>
-  array(2) {
-    "key"=>
-    string(6) "foobar"
-    "foo"=>
-    string(3) "bar"
-  }
-}
-client_id=%s: Stat key=scalar
-array(1) {
-  "::1:3434"=>
-  array(1) {
-    0=>
-    string(%d) "you want it, you get it"
-  }
-}
-client_id=%s: Stat key=numeric array
-array(1) {
-  "::1:3434"=>
-  array(3) {
-    -1=>
-    string(3) "one"
-    0=>
-    string(3) "two"
-    1=>
-    string(5) "three"
-  }
-}
-client_id=%s: Client quit
-Done

memcached-3.2.0.tgz/memcached-3.2.0/tests/options.phpt Deleted

@@ -1,43 +0,0 @@
---TEST--
-Memcached options
---SKIPIF--
-<?php include "skipif.inc";?>
---FILE--
-<?php 
-$m = new Memcached();
-$m->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP);
-
-var_dump($m->getOption(Memcached::OPT_COMPRESSION));
-var_dump($m->getOption(Memcached::OPT_SERIALIZER));
-var_dump($m->getOption(Memcached::OPT_SOCKET_SEND_SIZE));
-
-$m->setOption(Memcached::OPT_PREFIX_KEY, "\x01");
-
-var_dump($m->getOption(Memcached::OPT_HASH) == Memcached::HASH_DEFAULT);
-$m->setOption(Memcached::OPT_HASH, Memcached::HASH_MURMUR);
-var_dump($m->getOption(Memcached::OPT_HASH) == Memcached::HASH_MURMUR);
-
-
-$m->setOption(Memcached::OPT_COMPRESSION_TYPE, Memcached::COMPRESSION_ZLIB);
-var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_ZLIB);
-
-$m->setOption(Memcached::OPT_COMPRESSION_TYPE, Memcached::COMPRESSION_FASTLZ);
-var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_FASTLZ);
-
-var_dump($m->setOption(Memcached::OPT_COMPRESSION_TYPE, 0));
-var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_FASTLZ);
-?>
---EXPECTF--
-bool(true)
-int(1)
-
-Warning: Memcached::getOption(): no servers defined in %s on line %d
-NULL
-
-Warning: Memcached::setOption(): bad key provided in %s on line %d
-bool(true)
-bool(true)
-bool(true)
-bool(true)
-bool(false)
-bool(true)

memcached-3.2.0.tgz/memcached-3.2.0/tests/set_large.phpt Deleted

memcached-3.2.0.tgz/memcached-3.2.0/tests/setoptions.phpt Deleted

@@ -1,45 +0,0 @@
---TEST--
-Set options using setOptions
---SKIPIF--
-<?php include "skipif.inc";?>
---FILE--
-<?php
-$m = new Memcached();
-
-/* existing options */
-var_dump($m->setOptions(array(
-	Memcached::OPT_PREFIX_KEY => 'a_prefix',
-	Memcached::OPT_SERIALIZER => Memcached::SERIALIZER_PHP,
-	Memcached::OPT_COMPRESSION => 0,
-	Memcached::OPT_LIBKETAMA_COMPATIBLE => 1,
-	Memcached::OPT_CONNECT_TIMEOUT => 5000,
-)));
-
-var_dump($m->getOption(Memcached::OPT_PREFIX_KEY) == 'a_prefix');
-var_dump($m->getOption(Memcached::OPT_SERIALIZER) == Memcached::SERIALIZER_PHP);
-var_dump($m->getOption(Memcached::OPT_COMPRESSION) == 0);
-var_dump($m->getOption(Memcached::OPT_LIBKETAMA_COMPATIBLE) == 1);
-
-echo "test invalid options\n";
-
-var_dump($m->setOptions(array(
-	"asdf" => 123
-)));
-
-var_dump($m->setOptions(array(
-	-1 => 123
-)));
-
---EXPECTF--
-bool(true)
-bool(true)
-bool(true)
-bool(true)
-bool(true)
-test invalid options
-
-Warning: Memcached::setOptions(): invalid configuration option in %s on line %d
-bool(false)
-
-Warning: Memcached::setOptions(): error setting memcached option: %s in %s on line %d
-bool(false)

memcached-3.2.0.tgz/memcached-3.2.0/tests/touch_binary.phpt Deleted

@@ -1,73 +0,0 @@
---TEST--
-Touch in binary mode
---SKIPIF--
-<?php
-$min_version = "1.4.8"; //TOUCH is added since 1.4.8
-include dirname(__FILE__) . "/skipif.inc";
-// The touch command in binary mode will work in libmemcached 1.0.16, but runs out the timeout clock
-// See https://github.com/php-memcached-dev/php-memcached/issues/310 for further explanation
-// The problem is fixed fully in libmemcached 1.0.18, so we'll focus tests on that version
-if (Memcached::LIBMEMCACHED_VERSION_HEX < 0x01000018) die ('skip too old libmemcached');
-?>
---FILE--
-<?php
-
-function resolve_to_constant ($code)
-{
-	$refl = new ReflectionClass ('memcached');
-	$c = $refl->getConstants ();
-	
-	foreach ($c as $name => $value) {
-		if (strpos ($name, 'RES_') === 0 && $value == $code)
-			return $name;
-	}
-}
-
-function status_print ($op, $mem, $expected)
-{
-	$code = $mem->getResultcode();
-
-	if ($code == $expected)
-		echo "${op} status code as expected" . PHP_EOL;
-	else {
-		$expected = resolve_to_constant ($expected);
-		$code = resolve_to_constant ($code);
-		
-		echo "${op} status code mismatch, expected ${expected} but got ${code}" . PHP_EOL;
-	}
-}
-
-include dirname (__FILE__) . '/config.inc';
-$mem = memc_get_instance (array (Memcached::OPT_BINARY_PROTOCOL => true));
-
-$key = uniqid ('touch_t_');
-
-$mem->get($key);
-status_print ('get', $mem, Memcached::RES_NOTFOUND);
-
-$mem->set ($key, 1);
-status_print ('set', $mem, Memcached::RES_SUCCESS);
-
-$mem->get($key);
-status_print ('get', $mem, Memcached::RES_SUCCESS);
-
-$mem->touch ($key, 10);
-status_print ('touch', $mem, Memcached::RES_SUCCESS);
-
-$mem->get($key);
-status_print ('get', $mem, Memcached::RES_SUCCESS);
-
-$mem->get($key);
-status_print ('get', $mem, Memcached::RES_SUCCESS);
-
-echo "OK\n";
-
-?>
---EXPECT--
-get status code as expected
-set status code as expected
-get status code as expected
-touch status code as expected
-get status code as expected
-get status code as expected
-OK

memcached-3.3.0.tgz/memcached-3.3.0/CREDITS Changed

memcached-3.3.0.tgz/memcached-3.3.0/ChangeLog Changed

memcached-3.3.0.tgz/memcached-3.3.0/LICENSE Changed

memcached-3.3.0.tgz/memcached-3.3.0/README.markdown Added

@@ -0,0 +1,52 @@
+Build Status
+------------
+!Build Status(https://github.com/php-memcached-dev/php-memcached/actions/workflows/build-and-test.yml/badge.svg?branch=master)
+
+Description
+-----------
+This is the PECL memcached(https://pecl.php.net/package/memcached) extension,
+using the libmemcached library to connect to memcached servers.
+
+memcached(https://memcached.org) is a high-performance, distributed memory
+object caching system, generic in nature, but intended for use in speeding up
+dynamic web applications by alleviating database load.
+
+Building
+--------
+
+    $ phpize
+    $ ./configure
+    $ make
+    $ make test
+
+Dependencies
+------------
+
+php-memcached 3.x:
+* Supports PHP 7.0 - 8.3 or higher.
+* Requires libmemcached 1.x or higher.
+* Optionally supports igbinary 2.0 or higher.
+* Optionally supports msgpack 2.0 or higher.
+
+php-memcached 2.x:
+* Supports PHP 5.2 - 5.6.
+* Requires libmemcached 0.44 or higher.
+* Optionally supports igbinary 1.0 or higher.
+* Optionally supports msgpack 0.5 or higher.
+
+libmemcached(http://libmemcached.org/libMemcached.html) or the new
+libmemcached-awesome(https://github.com/awesomized/libmemcached) version
+1.0.18 or higher is recommended for best performance and compatibility with
+memcached servers.
+
+igbinary(https://github.com/igbinary/igbinary) is a faster and more compact
+binary serializer for PHP data structures. When installing php-memcached from
+source code, the igbinary module must be installed first so that php-memcached
+can access its C header files. Load both modules in your `php.ini` at runtime
+to begin using igbinary.
+
+msgpack(https://msgpack.org) is a faster and more compact data structure
+representation that is interoperable with msgpack implementations for other
+languages. When installing php-memcached from source code, the msgpack module
+must be installed first so that php-memcached can access its C header files.
+Load both modules in your `php.ini` at runtime to begin using msgpack.

memcached-3.3.0.tgz/memcached-3.3.0/config.m4 Added

@@ -0,0 +1,419 @@
+dnl vim:se ts=2 sw=2 et:
+
+PHP_ARG_ENABLE(memcached, whether to enable memcached support,
+  --enable-memcached              Enable memcached support)
+
+PHP_ARG_WITH(libmemcached-dir,  for libmemcached,
+  --with-libmemcached-dir=DIR     Set the path to libmemcached install prefix., yes)
+
+PHP_ARG_ENABLE(memcached-session, whether to enable memcached session handler support,
+  --enable-memcached-session      Enable memcached session handler support, yes, no)
+
+PHP_ARG_ENABLE(memcached-igbinary, whether to enable memcached igbinary serializer support,
+  --enable-memcached-igbinary     Enable memcached igbinary serializer support, no, no)
+
+PHP_ARG_ENABLE(memcached-json, whether to enable memcached json serializer support,
+  --enable-memcached-json         Enable memcached json serializer support, no, no)
+
+PHP_ARG_ENABLE(memcached-msgpack, whether to enable memcached msgpack serializer support,
+  --enable-memcached-msgpack      Enable memcached msgpack serializer support, no, no)
+
+PHP_ARG_ENABLE(memcached-sasl, whether to enable memcached sasl support,
+  --enable-memcached-sasl         Enable memcached sasl support, yes, no)
+
+PHP_ARG_ENABLE(memcached-protocol, whether to enable memcached protocol support,
+  --enable-memcached-protocol     Enable memcached protocol support, no, no)
+
+PHP_ARG_WITH(system-fastlz, whether to use system FastLZ library,
+  --with-system-fastlz            Use system FastLZ library, no, no)
+
+PHP_ARG_WITH(zstd, whether to use system zstd library,
+  --with-zstd           Use system zstd library, no, no)
+
+if test -z "$PHP_ZLIB_DIR"; then
+PHP_ARG_WITH(zlib-dir, for ZLIB,
+  --with-zlib-dir=DIR             Set the path to ZLIB install prefix., no)
+fi
+
+if test -z "$PHP_DEBUG"; then
+  AC_ARG_ENABLE(debug,
+    --enable-debug          Compile with debugging symbols,
+    PHP_DEBUG=$enableval
+  ,    PHP_DEBUG=no
+  )
+fi
+
+if test "$PHP_MEMCACHED" != "no"; then
+
+  AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
+  if test "x$PKG_CONFIG" = "xno"; then
+    AC_MSG_RESULT(pkg-config not found)
+    AC_MSG_ERROR(Please reinstall the pkg-config distribution)
+  fi
+
+  dnl # zlib
+  if test "$PHP_ZLIB_DIR" != "no" && test "$PHP_ZLIB_DIR" != "yes"; then
+    if test -f "$PHP_ZLIB_DIR/include/zlib/zlib.h"; then
+      PHP_ZLIB_DIR="$PHP_ZLIB_DIR"
+      PHP_ZLIB_INCDIR="$PHP_ZLIB_DIR/include/zlib"
+    elif test -f "$PHP_ZLIB_DIR/include/zlib.h"; then
+      PHP_ZLIB_DIR="$PHP_ZLIB_DIR"
+      PHP_ZLIB_INCDIR="$PHP_ZLIB_DIR/include"
+    else
+      AC_MSG_ERROR(Can't find ZLIB headers under "$PHP_ZLIB_DIR")
+    fi
+  else
+    for i in /usr/local /usr/local/opt/zlib /usr; do
+      if test -f "$i/include/zlib/zlib.h"; then
+        PHP_ZLIB_DIR="$i"
+        PHP_ZLIB_INCDIR="$i/include/zlib"
+      elif test -f "$i/include/zlib.h"; then
+        PHP_ZLIB_DIR="$i"
+        PHP_ZLIB_INCDIR="$i/include"
+      fi
+    done
+  fi
+
+  AC_MSG_CHECKING(for zlib location)
+  if test "$PHP_ZLIB_DIR" != "no" && test "$PHP_ZLIB_DIR" != "yes"; then
+    AC_MSG_RESULT($PHP_ZLIB_DIR)
+    PHP_ADD_LIBRARY_WITH_PATH(z, $PHP_ZLIB_DIR/$PHP_LIBDIR, MEMCACHED_SHARED_LIBADD)
+    PHP_ADD_INCLUDE($PHP_ZLIB_INCDIR)
+  else
+    AC_MSG_ERROR(memcached support requires ZLIB. Use --with-zlib-dir=<DIR> to specify the prefix where ZLIB headers and library are located)
+  fi
+
+  if test "$PHP_MEMCACHED_SESSION" != "no"; then
+    AC_MSG_CHECKING(for session includes)
+    session_inc_path=""
+
+    if test -f "$abs_srcdir/include/php/ext/session/php_session.h"; then
+      session_inc_path="$abs_srcdir/include/php"
+    elif test -f "$abs_srcdir/ext/session/php_session.h"; then
+      session_inc_path="$abs_srcdir"
+    elif test -f "$phpincludedir/ext/session/php_session.h"; then
+      session_inc_path="$phpincludedir"
+    else
+      for i in php php4 php5 php6; do
+        if test -f "$prefix/include/$i/ext/session/php_session.h"; then
+          session_inc_path="$prefix/include/$i"
+        fi
+      done
+    fi
+
+    if test "$session_inc_path" = ""; then
+      AC_MSG_ERROR(Cannot find php_session.h)
+    else
+      AC_MSG_RESULT($session_inc_path)
+    fi
+  fi
+
+  if test "$PHP_MEMCACHED_JSON" != "no"; then
+    AC_MSG_CHECKING(for json includes)
+    json_inc_path=""
+
+    if test -f "$abs_srcdir/include/php/ext/json/php_json.h"; then
+      json_inc_path="$abs_srcdir/include/php"
+    elif test -f "$abs_srcdir/ext/json/php_json.h"; then
+      json_inc_path="$abs_srcdir"
+    elif test -f "$phpincludedir/ext/json/php_json.h"; then
+      json_inc_path="$phpincludedir"
+    else
+      for i in php php4 php5 php6; do
+        if test -f "$prefix/include/$i/ext/json/php_json.h"; then
+          json_inc_path="$prefix/include/$i"
+        fi
+      done
+    fi
+    if test "$json_inc_path" = ""; then
+      AC_MSG_ERROR(Cannot find php_json.h)
+    else
+      AC_DEFINE(HAVE_JSON_API,1,Whether JSON API is available)
+      AC_MSG_RESULT($json_inc_path)
+    fi
+  fi
+
+  if test "$PHP_MEMCACHED_IGBINARY" != "no"; then
+    AC_MSG_CHECKING(for igbinary includes)
+    igbinary_inc_path=""
+
+    if test -f "$abs_srcdir/include/php/ext/igbinary/igbinary.h"; then
+      igbinary_inc_path="$abs_srcdir/include/php"
+    elif test -f "$abs_srcdir/ext/igbinary/igbinary.h"; then
+      igbinary_inc_path="$abs_srcdir"
+    elif test -f "$phpincludedir/ext/session/igbinary.h"; then
+      igbinary_inc_path="$phpincludedir"
+    elif test -f "$phpincludedir/ext/igbinary/igbinary.h"; then
+      igbinary_inc_path="$phpincludedir"
+    else
+      for i in php php4 php5 php6; do
+        if test -f "$prefix/include/$i/ext/igbinary/igbinary.h"; then
+          igbinary_inc_path="$prefix/include/$i"
+        fi
+      done
+    fi
+
+    if test "$igbinary_inc_path" = ""; then
+      AC_MSG_ERROR(Cannot find igbinary.h)
+    else
+      AC_MSG_RESULT($igbinary_inc_path)
+    fi
+  fi
+
+  if test "$PHP_MEMCACHED_MSGPACK" != "no"; then
+    AC_MSG_CHECKING(for msgpack includes)
+    msgpack_inc_path=""
+
+    if test -f "$abs_srcdir/include/php/ext/msgpack/php_msgpack.h"; then
+      msgpack_inc_path="$abs_srcdir/include/php"
+    elif test -f "$abs_srcdir/ext/msgpack/php_msgpack.h"; then
+      msgpack_inc_path="$abs_srcdir"
+    elif test -f "$phpincludedir/ext/session/php_msgpack.h"; then
+      msgpack_inc_path="$phpincludedir"
+    elif test -f "$phpincludedir/ext/msgpack/php_msgpack.h"; then
+      msgpack_inc_path="$phpincludedir"
+    else
+      for i in php php4 php5 php6; do
+        if test -f "$prefix/include/$i/ext/msgpack/php_msgpack.h"; then
+          msgpack_inc_path="$prefix/include/$i"
+        fi
+      done
+    fi
+
+    if test "$msgpack_inc_path" = ""; then
+      AC_MSG_ERROR(Cannot find php_msgpack.h)
+    else
+      AC_MSG_RESULT($msgpack_inc_path)
+    fi
+  fi
+
+  AC_MSG_CHECKING(for memcached session support)
+  if test "$PHP_MEMCACHED_SESSION" != "no"; then
+    AC_MSG_RESULT(enabled)
+    AC_DEFINE(HAVE_MEMCACHED_SESSION,1,Whether memcache session handler is enabled)
+    SESSION_INCLUDES="-I$session_inc_path"
+    ifdef(PHP_ADD_EXTENSION_DEP,
+    
+      PHP_ADD_EXTENSION_DEP(memcached, session)
+    )
+  else
+    SESSION_INCLUDES=""
+    AC_MSG_RESULT(disabled)
+  fi
+
+  AC_MSG_CHECKING(for memcached igbinary support)
+  if test "$PHP_MEMCACHED_IGBINARY" != "no"; then
+    AC_MSG_RESULT(enabled)
+    AC_DEFINE(HAVE_MEMCACHED_IGBINARY,1,Whether memcache igbinary serializer is enabled)
+    IGBINARY_INCLUDES="-I$igbinary_inc_path"
+    ifdef(PHP_ADD_EXTENSION_DEP,
+    
+      PHP_ADD_EXTENSION_DEP(memcached, igbinary)
+    )
+  else
+    IGBINARY_INCLUDES=""
+    AC_MSG_RESULT(disabled)
+  fi
+
+  AC_MSG_CHECKING(for memcached msgpack support)
+  if test "$PHP_MEMCACHED_MSGPACK" != "no"; then
+    AC_MSG_RESULT(enabled)
+    AC_DEFINE(HAVE_MEMCACHED_MSGPACK,1,Whether memcache msgpack serializer is enabled)
+    MSGPACK_INCLUDES="-I$msgpack_inc_path"
+    ifdef(PHP_ADD_EXTENSION_DEP,
+    
+      PHP_ADD_EXTENSION_DEP(memcached, msgpack)
+    )
+  else
+    MSGPACK_INCLUDES=""
+    AC_MSG_RESULT(disabled)
+  fi
+
+  AC_MSG_CHECKING(for libmemcached location)
+  export ORIG_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
+
+  if test "$PHP_LIBMEMCACHED_DIR" != "no" && test "$PHP_LIBMEMCACHED_DIR" != "yes"; then
+    export PKG_CONFIG_PATH="$PHP_LIBMEMCACHED_DIR/$PHP_LIBDIR/pkgconfig"
+
+    if test ! -f "$PHP_LIBMEMCACHED_DIR/include/libmemcached/memcached.h"; then
+      AC_MSG_ERROR(Unable to find memcached.h under $PHP_LIBMEMCACHED_DIR)
+    fi
+  else
+    export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/$PHP_LIBDIR/pkgconfig:/usr/$PHP_LIBDIR/pkgconfig:/opt/$PHP_LIBDIR/pkgconfig"
+  fi
+
+  if ! $PKG_CONFIG --exists libmemcached; then
+    AC_MSG_ERROR(memcached support requires libmemcached. Use --with-libmemcached-dir=<DIR> to specify the prefix where libmemcached headers and library are located)
+  else
+    PHP_LIBMEMCACHED_VERSION=`$PKG_CONFIG libmemcached --modversion`
+    PHP_LIBMEMCACHED_DIR=`$PKG_CONFIG libmemcached --variable=prefix`
+
+    AC_MSG_RESULT(found version $PHP_LIBMEMCACHED_VERSION, under $PHP_LIBMEMCACHED_DIR)
+
+    PHP_LIBMEMCACHED_LIBS=`$PKG_CONFIG libmemcached --libs`
+    PHP_LIBMEMCACHED_INCLUDES=`$PKG_CONFIG libmemcached --cflags`
+
+    PHP_EVAL_LIBLINE($PHP_LIBMEMCACHED_LIBS, MEMCACHED_SHARED_LIBADD)
+    PHP_EVAL_INCLINE($PHP_LIBMEMCACHED_INCLUDES)
+
+    ORIG_CFLAGS="$CFLAGS"
+    CFLAGS="$CFLAGS $INCLUDES"
+
+    dnl # Always check if libmemcached was built with SASL support,
+    dnl # because it will require sasl.h even if not used here.
+    AC_CACHE_CHECK(for libmemcached sasl.h requirement, ac_cv_memc_sasl_support, 
+      AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <libmemcached/memcached.h>, 
+        #if LIBMEMCACHED_WITH_SASL_SUPPORT
+          /* yes */
+        #else
+        #  error "no sasl support"
+        #endif
+        ),
+        ac_cv_memc_sasl_support="yes",
+        ac_cv_memc_sasl_support="no"
+      )
+    )
+
+    if test "$ac_cv_memc_sasl_support" = "yes"; then
+      AC_CHECK_HEADERS(sasl/sasl.h, ac_cv_have_memc_sasl_h="yes", ac_cv_have_memc_sasl_h="no")
+    fi
+
+    dnl # If libmemcached requires sasl.h but we can't find sasl.h, that's a hard error
+    dnl # regardless of the option --enable-memcached-sasl or --disable-memcached-sasl
+    AC_MSG_CHECKING(whether to enable sasl support)
+    if test "$ac_cv_memc_sasl_support" = "yes" && test "$ac_cv_have_memc_sasl_h" = "no"; then
+      AC_MSG_ERROR(no, libmemcached built with sasl required, but sasl.h not found.)
+    fi
+
+    if test "$PHP_MEMCACHED_SASL" != "no"; then
+      AC_MSG_RESULT(yes)
+      if test "$ac_cv_memc_sasl_support" = "yes" && test "$ac_cv_have_memc_sasl_h" = "yes"; then
+        PHP_CHECK_LIBRARY(sasl2, sasl_client_init, PHP_ADD_LIBRARY(sasl2, 1, MEMCACHED_SHARED_LIBADD))
+        AC_DEFINE(HAVE_MEMCACHED_SASL, 1, Have SASL support)
+      else
+        AC_MSG_ERROR(no, libmemcached built with sasl disabled. Run configure with --disable-memcached-sasl or update libmemcached with sasl support)
+      fi
+    else
+      AC_MSG_RESULT(no)
+    fi
+
+    ORIG_CFLAGS="$CFLAGS"
+    ORIG_LIBS="$LIBS"
+
+    CFLAGS="$CFLAGS $PHP_LIBMEMCACHED_INCLUDES"
+    LIBS="$LIBS $PHP_LIBMEMCACHED_LIBS"
+
+    AC_CACHE_CHECK(whether memcached_exist is defined, ac_cv_have_memcached_exist, 
+      AC_LINK_IFELSE(
+        AC_LANG_PROGRAM(#include <libmemcached/memcached.h>,
+          memcached_exist (NULL, NULL, 0);),
+          ac_cv_have_memcached_exist="yes",
+          ac_cv_have_memcached_exist="no")
+    )
+
+    CFLAGS="$ORIG_CFLAGS"
+    LIBS="$ORIG_LIBS"
+
+    CFLAGS="$CFLAGS $PHP_LIBMEMCACHED_INCLUDES"
+    LIBS="$LIBS $PHP_LIBMEMCACHED_LIBS"
+
+    if test "$ac_cv_have_memcached_exist" = "yes"; then
+      AC_DEFINE(HAVE_MEMCACHED_EXIST, 1, Whether memcached_exist is defined)
+    fi
+
+    AC_CACHE_CHECK(whether memcached_set_encoding_key is defined, ac_cv_have_memcached_set_encoding_key, 
+      AC_LINK_IFELSE(
+        AC_LANG_PROGRAM(#include <libmemcached/memcached.h>,
+          memcached_set_encoding_key (NULL, NULL, 0);),
+        ac_cv_have_memcached_set_encoding_key="yes",
+        ac_cv_have_memcached_set_encoding_key="no")
+    )
+
+    CFLAGS="$ORIG_CFLAGS"
+    LIBS="$ORIG_LIBS"
+
+    if test "$ac_cv_have_memcached_set_encoding_key" = "yes"; then
+      AC_DEFINE(HAVE_MEMCACHED_SET_ENCODING_KEY, 1, Whether memcached_set_encoding_key is defined)
+    fi
+
+    PHP_MEMCACHED_FILES="php_memcached.c php_libmemcached_compat.c  g_fmt.c"
+
+    if test "$PHP_SYSTEM_FASTLZ" != "no"; then
+      AC_CHECK_HEADERS(fastlz.h, ac_cv_have_fastlz="yes", ac_cv_have_fastlz="no")
+      PHP_CHECK_LIBRARY(fastlz, fastlz_compress,
+          PHP_ADD_LIBRARY(fastlz, 1, MEMCACHED_SHARED_LIBADD),
+          AC_MSG_ERROR(FastLZ library not found))
+    else
+      ac_cv_have_fastlz="no"
+      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} fastlz/fastlz.c"
+    fi
+
+    if test "$PHP_ZSTD" != "no"; then
+      AC_CHECK_HEADERS(zstd.h, ac_cv_have_zstd="yes", ac_cv_have_zstd="no")
+      PHP_CHECK_LIBRARY(zstd, ZSTD_compress,
+          PHP_ADD_LIBRARY(zstd, 1, MEMCACHED_SHARED_LIBADD),
+          AC_MSG_ERROR(zstd library not found))
+    fi
+
+    if test "$PHP_MEMCACHED_SESSION" != "no"; then
+      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} php_memcached_session.c"
+    fi
+
+    LIBEVENT_INCLUDES=""
+    AC_MSG_CHECKING(for memcached protocol support)
+    if test "$PHP_MEMCACHED_PROTOCOL" != "no"; then
+      AC_MSG_RESULT(enabled)
+
+      AC_CACHE_CHECK(whether libmemcachedprotocol is usable, ac_cv_have_libmemcachedprotocol, 
+        AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <libmemcachedprotocol-0.0/handler.h>,
+          memcached_binary_protocol_callback_st s_test_impl;
+            s_test_impl.interface.v1.delete_object = 0;
+          ),
+          ac_cv_have_libmemcachedprotocol="yes",
+          ac_cv_have_libmemcachedprotocol="no"
+        )
+      )
+
+      if test "$ac_cv_have_libmemcachedprotocol" != "yes"; then
+        AC_MSG_ERROR(Cannot enable libmemcached protocol)
+      fi
+
+      PHP_ADD_LIBRARY_WITH_PATH(memcachedprotocol, $PHP_LIBMEMCACHED_DIR/$PHP_LIBDIR, MEMCACHED_SHARED_LIBADD)
+
+      AC_MSG_CHECKING(for libevent)
+      if $PKG_CONFIG --exists libevent; then
+        PHP_MEMCACHED_LIBEVENT_VERSION=`$PKG_CONFIG libevent --modversion`
+        PHP_MEMCACHED_LIBEVENT_PREFIX=`$PKG_CONFIG libevent --variable=prefix`
+
+        AC_MSG_RESULT(found version $PHP_MEMCACHED_LIBEVENT_VERSION, under $PHP_MEMCACHED_LIBEVENT_PREFIX)
+        LIBEVENT_LIBS=`$PKG_CONFIG libevent --libs`
+        LIBEVENT_INCLUDES=`$PKG_CONFIG libevent --cflags`
+
+        PHP_EVAL_LIBLINE($LIBEVENT_LIBS, MEMCACHED_SHARED_LIBADD)
+        PHP_EVAL_INCLINE($LIBEVENT_INCLUDES)
+      else
+        AC_MSG_ERROR(Unable to find libevent installation)
+      fi
+      PHP_MEMCACHED_FILES="${PHP_MEMCACHED_FILES} php_memcached_server.c"
+      AC_DEFINE(HAVE_MEMCACHED_PROTOCOL,1,Whether memcached protocol is enabled)
+    else
+      AC_MSG_RESULT(disabled)
+    fi
+
+    CFLAGS="$ORIG_CFLAGS"
+
+    export PKG_CONFIG_PATH="$ORIG_PKG_CONFIG_PATH"
+    PHP_SUBST(MEMCACHED_SHARED_LIBADD)
+
+    PHP_NEW_EXTENSION(memcached, $PHP_MEMCACHED_FILES, $ext_shared,,$SESSION_INCLUDES $IGBINARY_INCLUDES $LIBEVENT_INCLUDES $MSGPACK_INCLUDES)
+    if test "ac_cv_have_fastlz" != "yes"; then
+      PHP_ADD_BUILD_DIR($ext_builddir/fastlz, 1)
+    fi
+
+    ifdef(PHP_ADD_EXTENSION_DEP,
+    
+      PHP_ADD_EXTENSION_DEP(memcached, spl, true)
+    )
+  fi
+fi
+

memcached-3.3.0.tgz/memcached-3.3.0/config.w32 Added

@@ -0,0 +1,50 @@
+// vim:ft=javascript
+
+ARG_ENABLE('memcached', 'libmemcached extension', 'no');
+
+ARG_ENABLE('memcached-session', 'whether to enable memcached session handler support', 'no');
+ARG_ENABLE('memcached-igbinary', 'whether to enable memcached igbinary serializer support', 'no');
+ARG_ENABLE('memcached-json', 'whether to enable memcached json serializer support', 'no');
+ARG_ENABLE('memcached-msgpack', 'whether to enable memcached msgpack serializer support', 'no');
+
+if (PHP_MEMCACHED == "yes") {
+
+  if (!CHECK_LIB("memcached.lib;libmemcached.lib", "memcached", PHP_MEMCACHED)) { 
+	ERROR("memcached: library 'memcached' not found");
+  }
+  
+  if (!CHECK_HEADER_ADD_INCLUDE("libmemcached/memcached.h", "CFLAGS_MEMCACHED")) {
+	ERROR("memcached: header 'libmemcached/memcached.h' not found");
+  }
+
+  if (PHP_MEMCACHED_JSON != "no"){
+	AC_DEFINE("HAVE_JSON_API",1);
+  }
+  
+  var memcached_extra_src = "";
+  
+  if (PHP_MEMCACHED_SESSION != "no"){
+	AC_DEFINE("HAVE_MEMCACHED_SESSION",1);
+	ADD_EXTENSION_DEP("memcached", "session", true)
+	memcached_extra_src += " php_memcached_session.c";
+  }
+  
+  if (PHP_MEMCACHED_IGBINARY != "no"){
+	AC_DEFINE("HAVE_MEMCACHED_IGBINARY",1);
+	ADD_EXTENSION_DEP("memcached", "igbinary", true);
+	if (!CHECK_HEADER_ADD_INCLUDE("igbinary.h", "CFLAGS_MEMCACHED")) {
+		ERROR("memcached: header 'igbinary.h' not found");
+	  }
+  }
+  if (PHP_MEMCACHED_MSGPACK != "no"){
+	AC_DEFINE("HAVE_MEMCACHED_MSGPACK",1);
+	ADD_EXTENSION_DEP("memcached", "msgpack", true);
+	if (!CHECK_HEADER_ADD_INCLUDE("php_msgpack.h", "CFLAGS_MEMCACHED")) {
+		ERROR("memcached: header 'php_msgpack.h' not found");
+	  }
+  }
+  EXTENSION("memcached", "php_memcached.c php_libmemcached_compat.c g_fmt.c"+memcached_extra_src, null, " /DHAVE_SSIZE_T");
+  ADD_SOURCES(configure_module_dirname+"\\fastlz", "fastlz.c", "memcached");
+  AC_DEFINE("HAVE_MEMCACHED", 1, "memcached support");
+  AC_DEFINE("MEMCACHED_EXPORTS", 1)
+}

memcached-3.3.0.tgz/memcached-3.3.0/fastlz/LICENSE Changed

memcached-3.3.0.tgz/memcached-3.3.0/fastlz/fastlz.c Changed

memcached-3.3.0.tgz/memcached-3.3.0/fastlz/fastlz.h Changed

memcached-3.3.0.tgz/memcached-3.3.0/g_fmt.c Changed

memcached-3.3.0.tgz/memcached-3.3.0/g_fmt.h Changed

memcached-3.3.0.tgz/memcached-3.3.0/memcached-api.php Changed

memcached-3.3.0.tgz/memcached-3.3.0/memcached.ini Added

@@ -0,0 +1,169 @@
+memcached
+; Use session locking
+; valid values: On, Off
+; the default is On
+;memcached.sess_locking = On
+
+; The minimum time, in milliseconds, to wait between session lock attempts.
+; This value is double on each lock retry until memcached.sess_lock_wait_max
+; is reached, after which any further retries will take sess_lock_wait_max seconds.
+; Default is 150.
+;memcached.sess_lock_wait_min = 150;
+
+; The maximum time, in milliseconds, to wait between session lock attempts.
+; Default is 150.
+;memcached.sess_lock_wait_max = 150;
+
+; The number of times to retry locking the session lock, not including the first attempt.
+; Default is 5.
+;memcached.sess_lock_retries = 5;
+
+; The time, in seconds, before a lock should release itself.
+; Setting to 0 results in the default behaviour, which is to
+; use PHP's max_execution_time.
+;memcached.sess_lock_expire = 0;
+
+; memcached session key prefix
+; valid values are strings less than 219 bytes long
+; the default value is "memc.sess.key."
+;memcached.sess_prefix = "memc.sess.key."
+
+; Whether or not to re-use the memcached connections corresponding to the value(s)
+; of session.save_path after the execution of the script ends.
+; Don't use this if certain settings (e.g. SASL settings, sess_binary_protocol) would
+; be overridden between requests.
+; Default is Off.
+;memcached.sess_persistent = Off
+
+; memcached session consistent hash mode
+; if set to On, consistent hashing (libketama) is used
+; for session handling.
+; When consistent hashing is used, one can add or remove cache
+; node(s) without messing up too much with existing keys
+; default is On
+;memcached.sess_consistent_hash = On
+
+; memcached session consistent hash type
+; if set to 'ketama', consistent hashing (libketama) is used
+; for session handling (default for php-memcached 3.x)
+; if set to 'ketama_weighted', weighted consistent hashing (libketama) is used
+; for session handling (default for php-memcached 2.x)
+;memcached.sess_consistent_hash_type = "ketama"
+
+; Allow failed memcached server to automatically be removed.
+; Default is Off. (In previous versions, this setting was called memcached.sess_remove_failed)
+;memcached.sess_remove_failed_servers = Off
+
+; Set this value to enable the server be removed after
+; configured number of continuous times connection failure.
+;memcached.sess_server_failure_limit = 0
+
+; Write data to a number of additional memcached servers
+; This is "poor man's HA" as libmemcached calls it.
+; If this value is positive and sess_remove_failed_servers is enabled
+; when a memcached server fails the session will continue to be available
+; from a replica. However, if the failed memcache server
+; becomes available again it will read the session from there
+; which could have old data or no data at all
+;memcached.sess_number_of_replicas = 0
+
+; Use the memcached binary protocol for memcached sessions (Instead of the text protocol)
+; libmemcached replicas work only if binary mode is enabled.
+; However, certain proxies (such as twemproxy) will work only if the binary protocol is disabled.
+; In older versions of php-memcached, this setting was Off and was called memcached.sess_binary.
+; Default is On with libmemcached 1.0.18 or newer.
+; Default is Off with older version.
+;memcached.sess_binary_protocol = On
+
+; memcached session replica read randomize
+;memcached.sess_randomize_replica_read = Off
+
+; memcached connect timeout value
+; In non-blocking mode this changes the value of the timeout
+; during socket connection in milliseconds. Specifying -1 means an infinite timeout.
+;memcached.sess_connect_timeout = 1000
+
+; Session SASL username
+; Both username and password need to be set for SASL to be enabled
+;memcached.sess_sasl_username = NULL
+
+; Session SASL password
+;memcached.sess_sasl_password = NULL
+
+; Set the compression type
+; valid values are: fastlz, zlib
+; the default is fastlz
+;memcached.compression_type = "fastlz"
+
+; Compression factor
+; Store compressed value only if the compression
+; factor (saving) exceeds the set limit.
+;
+;  store compressed if:
+;    plain_len > comp_len * factor
+;
+; the default value is 1.3 (23% space saving)
+;memcached.compression_factor = "1.3"
+
+; The compression threshold
+;
+; Do not compress serialized values below this threshold.
+; the default is 2000 bytes
+;memcached.compression_threshold = 2000
+
+; Set the default serializer for new memcached objects.
+; valid values are: php, igbinary, json, json_array, msgpack
+;
+; json - standard php JSON encoding. This serializer
+;        is fast and compact but only works on UTF-8
+;        encoded data and does not fully implement
+;        serializing. See the JSON extension.
+; json_array - as json, but decodes into arrays
+; php - the standard php serializer
+; igbinary - a binary serializer
+; msgpack - a cross-language binary serializer
+;
+; The default is igbinary if available, then msgpack if available, then php otherwise.
+;memcached.serializer = "igbinary"
+
+; The amount of retries for failed store commands.
+; This mechanism allows transparent fail-over to secondary servers when
+; set/increment/decrement/setMulti operations fail on the desired server in a multi-server
+; environment.
+; the default is 0
+;memcached.store_retry_count = 0
+
+; The maximum payload size in bytes that can be written.
+; Writing a payload larger than the limit will result in RES_E2BIG error.
+; Specifying 0 means no limit is enforced, though the server may still reject with RES_E2BIG.
+; Default is 0.
+;memcached.item_size_limit = 1000000
+
+; Sets the default for consistent hashing for new connections.
+; (To configure consistent hashing for session connections,
+; use memcached.sess_consistent_hash instead)
+;
+; If set to On, consistent hashing (libketama) is used
+; for session handling.
+; When consistent hashing is used, one can add or remove cache
+; node(s) without messing up too much with existing keys
+; default is Off
+;memcached.default_consistent_hash = Off
+
+; Sets the default memcached protocol for new connections.
+; (To configure the memcached protocol for connections used by sessions,
+; use memcached.sess_binary_protocol instead)
+;
+; If set to On, the memcached binary protocol is used by default.
+; If set to Off, the memcached text protocol is used.
+; Default is Off
+;memcached.default_binary_protocol = Off
+
+; Sets the default memcached connection timeout for new connections.
+; (To configure the memcached connection timeout for sessions,
+; use memcached.sess_connect_timeout instead)
+; In non-blocking mode this changes the value of the timeout.
+; during socket connection in milliseconds. Specifying -1 means an infinite timeout.
+; Specifying 0 means using the memcached library's default connection timeout.
+; Default is 0.
+;memcached.default_connect_timeout = 0

memcached-3.3.0.tgz/memcached-3.3.0/php_libmemcached_compat.c Changed

memcached-3.3.0.tgz/memcached-3.3.0/php_libmemcached_compat.h Changed

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached.c Added

@@ -0,0 +1,4528 @@
+/*
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2009-2010 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt.                                 |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors: Andrei Zmievski <andrei@php.net>                            |
+  +----------------------------------------------------------------------+
+*/
+
+/* TODO
+ * - set LIBKETAMA_COMPATIBLE as the default?
+ * - fix unserialize(serialize($memc))
+ */
+
+#include "php_memcached.h"
+#include "php_memcached_private.h"
+#include "php_memcached_server.h"
+#include "g_fmt.h"
+
+#include <ctype.h>
+#include <limits.h>
+
+#ifdef HAVE_MEMCACHED_SESSION
+# include "php_memcached_session.h"
+#endif
+#ifdef HAVE_FASTLZ_H
+#include <fastlz.h>
+#else
+#include "fastlz/fastlz.h"
+#endif
+#include <zlib.h>
+
+#ifdef HAVE_ZSTD_H
+#include <zstd.h>
+#endif
+
+#ifdef HAVE_JSON_API
+# include "ext/json/php_json.h"
+#endif
+
+#ifdef HAVE_MEMCACHED_IGBINARY
+#ifdef PHP_WIN32
+//Windows extensions are generally built together,
+//so it wont be in the installed location
+#include "igbinary.h"
+#else
+# include "ext/igbinary/igbinary.h"
+#endif
+#endif
+
+#ifdef HAVE_MEMCACHED_MSGPACK
+# include "ext/msgpack/php_msgpack.h"
+#endif
+
+# include "ext/spl/spl_exceptions.h"
+
+static int le_memc;
+
+static int php_memc_list_entry(void) {
+	return le_memc;
+}
+
+/****************************************
+  Protocol parameters
+****************************************/
+#define MEMC_OBJECT_KEY_MAX_LENGTH 250
+
+/****************************************
+  Custom options
+****************************************/
+#define MEMC_OPT_COMPRESSION        -1001
+#define MEMC_OPT_PREFIX_KEY         -1002
+#define MEMC_OPT_SERIALIZER         -1003
+#define MEMC_OPT_COMPRESSION_TYPE   -1004
+#define MEMC_OPT_STORE_RETRY_COUNT  -1005
+#define MEMC_OPT_USER_FLAGS         -1006
+#define MEMC_OPT_COMPRESSION_LEVEL  -1007
+#define MEMC_OPT_ITEM_SIZE_LIMIT    -1008
+
+/****************************************
+  Custom result codes
+****************************************/
+#define MEMC_RES_PAYLOAD_FAILURE -1001
+
+/****************************************
+  Payload value flags
+****************************************/
+#define MEMC_CREATE_MASK(start, n_bits) (((1U << n_bits) - 1) << start)
+
+#define MEMC_MASK_TYPE     MEMC_CREATE_MASK(0, 4)
+#define MEMC_MASK_INTERNAL MEMC_CREATE_MASK(4, 12)
+#define MEMC_MASK_USER     MEMC_CREATE_MASK(16, 16)
+
+#define MEMC_VAL_GET_TYPE(flags)       ((flags) & MEMC_MASK_TYPE)
+#define MEMC_VAL_SET_TYPE(flags, type) ((flags) |= ((type) & MEMC_MASK_TYPE))
+
+#define MEMC_VAL_IS_STRING     0
+#define MEMC_VAL_IS_LONG       1
+#define MEMC_VAL_IS_DOUBLE     2
+#define MEMC_VAL_IS_BOOL       3
+#define MEMC_VAL_IS_SERIALIZED 4
+#define MEMC_VAL_IS_IGBINARY   5
+#define MEMC_VAL_IS_JSON       6
+#define MEMC_VAL_IS_MSGPACK    7
+
+#define MEMC_VAL_COMPRESSED          (1<<0)
+#define MEMC_VAL_COMPRESSION_ZLIB    (1<<1)
+#define MEMC_VAL_COMPRESSION_FASTLZ  (1<<2)
+#define MEMC_VAL_COMPRESSION_ZSTD    (1<<3)
+
+#define MEMC_VAL_GET_FLAGS(internal_flags)               (((internal_flags) & MEMC_MASK_INTERNAL) >> 4)
+#define MEMC_VAL_SET_FLAG(internal_flags, internal_flag) ((internal_flags) |= (((internal_flag) << 4) & MEMC_MASK_INTERNAL))
+#define MEMC_VAL_HAS_FLAG(internal_flags, internal_flag) ((MEMC_VAL_GET_FLAGS(internal_flags) & (internal_flag)) == (internal_flag))
+#define MEMC_VAL_DEL_FLAG(internal_flags, internal_flag) (internal_flags &= (~(((internal_flag) << 4) & MEMC_MASK_INTERNAL)))
+
+/****************************************
+  User-defined flags
+****************************************/
+#define MEMC_VAL_GET_USER_FLAGS(flags)            ((flags & MEMC_MASK_USER) >> 16)
+#define MEMC_VAL_SET_USER_FLAGS(flags, udf_flags) ((flags) |= ((udf_flags << 16) & MEMC_MASK_USER))
+#define MEMC_VAL_USER_FLAGS_MAX                   ((1 << 16) - 1)
+
+/****************************************
+  "get" operation flags
+****************************************/
+#define MEMC_GET_PRESERVE_ORDER 1
+#define MEMC_GET_EXTENDED       2
+
+/****************************************
+  Helper macros
+****************************************/
+#define RETURN_FROM_GET RETURN_FALSE
+
+/****************************************
+  Structures and definitions
+****************************************/
+
+typedef enum {
+	MEMC_OP_SET,
+	MEMC_OP_TOUCH,
+	MEMC_OP_ADD,
+	MEMC_OP_REPLACE,
+	MEMC_OP_APPEND,
+	MEMC_OP_PREPEND
+} php_memc_write_op;
+
+typedef struct {
+
+	zend_bool is_persistent;
+	zend_bool compression_enabled;
+	zend_bool encoding_enabled;
+
+	zend_long serializer;
+	zend_long compression_type;
+	zend_long compression_level;
+
+	zend_long store_retry_count;
+	zend_long set_udf_flags;
+	zend_long item_size_limit;
+
+#ifdef HAVE_MEMCACHED_SASL
+	zend_bool has_sasl_data;
+#endif
+} php_memc_user_data_t;
+
+typedef struct {
+	memcached_st *memc;
+	zend_bool is_pristine;
+	int rescode;
+	int memc_errno;
+	zend_object zo;
+} php_memc_object_t;
+
+typedef struct {
+	size_t num_valid_keys;
+
+	const char **mkeys;
+	size_t *mkeys_len;
+
+	zend_string **strings;
+
+} php_memc_keys_t;
+
+typedef struct {
+	zval *object;
+	zend_fcall_info fci;
+	zend_fcall_info_cache fcc;
+} php_memc_result_callback_ctx_t;
+
+static inline php_memc_object_t *php_memc_fetch_object(zend_object *obj) {
+	return (php_memc_object_t *)((char *)obj - XtOffsetOf(php_memc_object_t, zo));
+}
+#define Z_MEMC_OBJ_P(zv) php_memc_fetch_object(Z_OBJ_P(zv));
+
+#define MEMC_METHOD_INIT_VARS                          \
+	zval*                  object         = getThis(); \
+	php_memc_object_t*     intern         = NULL;      \
+	php_memc_user_data_t*  memc_user_data = NULL;
+
+#if PHP_VERSION_ID < 80000
+#define MEMC_METHOD_FETCH_OBJECT                                                      \
+	intern = Z_MEMC_OBJ_P(object);                                                    \
+	if (!intern->memc) {                                                              \
+		php_error_docref(NULL, E_WARNING, "Memcached constructor was not called");    \
+		return;                                                                       \
+	}                                                                                 \
+	memc_user_data = (php_memc_user_data_t *) memcached_get_user_data(intern->memc);  \
+	(void)memc_user_data; /* avoid unused variable warning */
+#else
+#define MEMC_METHOD_FETCH_OBJECT                                                      \
+	intern = Z_MEMC_OBJ_P(object);                                                    \
+	if (!intern->memc) {                                                              \
+		zend_throw_error(NULL, "Memcached constructor was not called");               \
+		RETURN_THROWS();                                                                       \
+	}                                                                                 \
+	memc_user_data = (php_memc_user_data_t *) memcached_get_user_data(intern->memc);  \
+	(void)memc_user_data; /* avoid unused variable warning */
+#endif
+
+static
+zend_bool s_memc_valid_key_binary(zend_string *key)
+{
+	return memchr(ZSTR_VAL(key), '\n', ZSTR_LEN(key)) == NULL;
+}
+
+static
+uint32_t s_memc_object_key_max_length(php_memc_object_t *intern) {
+	memcached_return retval;
+	char *result;
+
+	result = memcached_callback_get(intern->memc, MEMCACHED_CALLBACK_PREFIX_KEY, &retval);
+	if (retval == MEMCACHED_SUCCESS && result) {
+		return MEMC_OBJECT_KEY_MAX_LENGTH - strlen(result);
+	} else {
+		return MEMC_OBJECT_KEY_MAX_LENGTH;
+	}
+}
+
+zend_bool s_memc_valid_key_ascii(zend_string *key, uint64_t verify_key)
+{
+	const char *str = ZSTR_VAL(key);
+	size_t i, len = ZSTR_LEN(key);
+
+	if (verify_key) {
+		for (i = 0; i < len; i++) {
+			if (!isgraph(stri) || isspace(stri))
+				return 0;
+		}
+	} else { /* if key verification is disabled, only check for spaces to avoid injection issues */
+		for (i = 0; i < len; i++) {
+			if (isspace(stri))
+				return 0;
+		}
+	}
+	return 1;
+}
+
+#define MEMC_CHECK_KEY(intern, key)                                               \
+	if (UNEXPECTED(ZSTR_LEN(key) == 0 ||                                          \
+		ZSTR_LEN(key) > s_memc_object_key_max_length(intern) ||                   \
+		(memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) \
+				? !s_memc_valid_key_binary(key)                                   \
+				: !s_memc_valid_key_ascii(key, memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_VERIFY_KEY)) \
+		))) {                                                                     \
+		intern->rescode = MEMCACHED_BAD_KEY_PROVIDED;                             \
+		RETURN_FALSE;                                                             \
+	}
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+typedef struct {
+	php_memc_proto_handler_t *handler;
+	zend_object zo;
+} php_memc_server_t;
+
+static inline php_memc_server_t *php_memc_server_fetch_object(zend_object *obj) {
+	return (php_memc_server_t *)((char *)obj - XtOffsetOf(php_memc_server_t, zo));
+}
+#define Z_MEMC_SERVER_P(zv) php_memc_server_fetch_object(Z_OBJ_P(zv))
+
+static zend_object_handlers memcached_server_object_handlers;
+static zend_class_entry *memcached_server_ce = NULL;
+#endif
+
+static zend_class_entry *memcached_ce = NULL;
+static zend_class_entry *memcached_exception_ce = NULL;
+static zend_object_handlers memcached_object_handlers;
+
+ZEND_DECLARE_MODULE_GLOBALS(php_memcached)
+
+#ifdef COMPILE_DL_MEMCACHED
+ZEND_GET_MODULE(memcached)
+#endif
+
+static PHP_INI_MH(OnUpdateCompressionType)
+{
+	if (!new_value) {
+		MEMC_G(compression_type) = COMPRESSION_TYPE_FASTLZ;
+	} else if (!strcmp(ZSTR_VAL(new_value), "fastlz")) {
+		MEMC_G(compression_type) = COMPRESSION_TYPE_FASTLZ;
+	} else if (!strcmp(ZSTR_VAL(new_value), "zlib")) {
+		MEMC_G(compression_type) = COMPRESSION_TYPE_ZLIB;
+#ifdef HAVE_ZSTD_H
+	} else if (!strcmp(ZSTR_VAL(new_value), "zstd")) {
+		MEMC_G(compression_type) = COMPRESSION_TYPE_ZSTD;
+#endif
+	} else {
+		return FAILURE;
+	}
+	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
+}
+
+static PHP_INI_MH(OnUpdateSerializer)
+{
+	if (!new_value) {
+		MEMC_G(serializer_type) = SERIALIZER_DEFAULT;
+	} else if (!strcmp(ZSTR_VAL(new_value), "php")) {
+		MEMC_G(serializer_type) = SERIALIZER_PHP;
+#ifdef HAVE_MEMCACHED_IGBINARY
+	} else if (!strcmp(ZSTR_VAL(new_value), "igbinary")) {
+		MEMC_G(serializer_type) = SERIALIZER_IGBINARY;
+#endif // IGBINARY
+#ifdef HAVE_JSON_API
+	} else if (!strcmp(ZSTR_VAL(new_value), "json")) {
+		MEMC_G(serializer_type) = SERIALIZER_JSON;
+	} else if (!strcmp(ZSTR_VAL(new_value), "json_array")) {
+		MEMC_G(serializer_type) = SERIALIZER_JSON_ARRAY;
+#endif // JSON
+#ifdef HAVE_MEMCACHED_MSGPACK
+	} else if (!strcmp(ZSTR_VAL(new_value), "msgpack")) {
+		MEMC_G(serializer_type) = SERIALIZER_MSGPACK;
+#endif // msgpack
+	} else {
+		return FAILURE;
+	}
+
+	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
+}
+
+#ifdef HAVE_MEMCACHED_SESSION
+static
+PHP_INI_MH(OnUpdateDeprecatedLockValue)
+{
+	if (ZSTR_LEN(new_value) > 0 && strcmp(ZSTR_VAL(new_value), "not set")) {
+		php_error_docref(NULL, E_DEPRECATED, "memcached.sess_lock_wait and memcached.sess_lock_max_wait are deprecated. Please update your configuration to use memcached.sess_lock_wait_min, memcached.sess_lock_wait_max and memcached.sess_lock_retries");
+	}
+	return FAILURE;
+}
+
+static
+PHP_INI_MH(OnUpdateSessionPrefixString)
+{
+	if (new_value && ZSTR_LEN(new_value) > 0) {
+		if (ZSTR_LEN(new_value) > MEMCACHED_MAX_KEY) {
+			php_error_docref(NULL, E_WARNING, "memcached.sess_prefix too long (max: %d)", MEMCACHED_MAX_KEY - 1);
+			return FAILURE;
+		}
+		if (!s_memc_valid_key_ascii(new_value, 1)) {
+			php_error_docref(NULL, E_WARNING, "memcached.sess_prefix cannot contain whitespace or control characters");
+			return FAILURE;
+		}
+	}
+	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
+}
+
+static
+PHP_INI_MH(OnUpdateConsistentHash)
+{
+	if (!new_value) {
+		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA;
+	} else if (!strcmp(ZSTR_VAL(new_value), "ketama")) {
+		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA;
+	} else if (!strcmp(ZSTR_VAL(new_value), "ketama_weighted")) {
+		MEMC_SESS_INI(consistent_hash_type) = MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED;
+	} else {
+		php_error_docref(NULL, E_WARNING, "memcached.sess_consistent_hash_type must be ketama or ketama_weighted");
+		return FAILURE;
+	}
+	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
+}
+#endif // HAVE_MEMCACHED_SESSION
+
+#define MEMC_INI_ENTRY(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_ENTRY("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals)
+
+#define MEMC_INI_BOOL(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_BOOLEAN("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals)
+
+#define MEMC_INI_LINK(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_ENTRY_EX("memcached."key, default_value, PHP_INI_ALL, update_fn, memc.gkey, zend_php_memcached_globals, php_memcached_globals, display_link_numbers)
+
+#define MEMC_SESSION_INI_ENTRY(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_ENTRY("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals)
+
+#define MEMC_SESSION_INI_BOOL(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_BOOLEAN("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals)
+
+#define MEMC_SESSION_INI_LINK(key, default_value, update_fn, gkey) \
+	STD_PHP_INI_ENTRY_EX("memcached.sess_"key, default_value, PHP_INI_ALL, update_fn, session.gkey, zend_php_memcached_globals, php_memcached_globals, display_link_numbers)
+
+
+/* {{{ INI entries */
+PHP_INI_BEGIN()
+
+#ifdef HAVE_MEMCACHED_SESSION
+	MEMC_SESSION_INI_BOOL ("locking",                "1",          OnUpdateBool,           lock_enabled)
+	MEMC_SESSION_INI_ENTRY("lock_wait_min",          "150",        OnUpdateLongGEZero,     lock_wait_min)
+	MEMC_SESSION_INI_ENTRY("lock_wait_max",          "150",        OnUpdateLongGEZero,     lock_wait_max)
+	MEMC_SESSION_INI_ENTRY("lock_retries",           "5",          OnUpdateLong,           lock_retries)
+	MEMC_SESSION_INI_ENTRY("lock_expire",            "0",          OnUpdateLongGEZero,     lock_expiration)
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX < 0x01000018
+	MEMC_SESSION_INI_BOOL ("binary_protocol",        "0",          OnUpdateBool,           binary_protocol_enabled)
+#else
+	MEMC_SESSION_INI_BOOL ("binary_protocol",        "1",          OnUpdateBool,           binary_protocol_enabled)
+#endif
+	MEMC_SESSION_INI_BOOL ("consistent_hash",        "1",          OnUpdateBool,           consistent_hash_enabled)
+	MEMC_SESSION_INI_ENTRY("consistent_hash_type",   "ketama",     OnUpdateConsistentHash, consistent_hash_name)
+	MEMC_SESSION_INI_ENTRY("number_of_replicas",     "0",          OnUpdateLongGEZero,     number_of_replicas)
+	MEMC_SESSION_INI_BOOL ("randomize_replica_read", "0",          OnUpdateBool,           randomize_replica_read_enabled)
+	MEMC_SESSION_INI_BOOL ("remove_failed_servers",  "0",          OnUpdateBool,           remove_failed_servers_enabled)
+	MEMC_SESSION_INI_ENTRY("server_failure_limit",   "0",          OnUpdateLongGEZero,     server_failure_limit)
+	MEMC_SESSION_INI_LINK ("connect_timeout",        "0",          OnUpdateLong,           connect_timeout)
+
+	MEMC_SESSION_INI_ENTRY("sasl_username",          "",           OnUpdateString,         sasl_username)
+	MEMC_SESSION_INI_ENTRY("sasl_password",          "",           OnUpdateString,         sasl_password)
+	MEMC_SESSION_INI_BOOL ("persistent",             "0",          OnUpdateBool,           persistent_enabled)
+	MEMC_SESSION_INI_ENTRY("prefix",                 "memc.sess.key.", OnUpdateSessionPrefixString,         prefix)
+	
+	/* Deprecated */
+	STD_PHP_INI_ENTRY("memcached.sess_lock_wait", "not set", PHP_INI_ALL, OnUpdateDeprecatedLockValue, no_effect, zend_php_memcached_globals, php_memcached_globals)
+	STD_PHP_INI_ENTRY("memcached.sess_lock_max_wait", "not set", PHP_INI_ALL, OnUpdateDeprecatedLockValue, no_effect, zend_php_memcached_globals, php_memcached_globals)
+	
+#endif
+
+	MEMC_INI_ENTRY("compression_type",      "fastlz",                OnUpdateCompressionType, compression_name)
+	MEMC_INI_ENTRY("compression_factor",    "1.3",                   OnUpdateReal,            compression_factor)
+	MEMC_INI_ENTRY("compression_level",     "3",                     OnUpdateLong,            compression_level)
+	MEMC_INI_ENTRY("compression_threshold", "2000",                  OnUpdateLong,            compression_threshold)
+	MEMC_INI_ENTRY("serializer",            SERIALIZER_DEFAULT_NAME, OnUpdateSerializer,      serializer_name)
+	MEMC_INI_ENTRY("store_retry_count",     "0",                     OnUpdateLong,            store_retry_count)
+	MEMC_INI_ENTRY("item_size_limit",       "0",                     OnUpdateLongGEZero,      item_size_limit)
+
+	MEMC_INI_BOOL ("default_consistent_hash",       "0", OnUpdateBool,       default_behavior.consistent_hash_enabled)
+	MEMC_INI_BOOL ("default_binary_protocol",       "0", OnUpdateBool,       default_behavior.binary_protocol_enabled)
+	MEMC_INI_LINK ("default_connect_timeout",       "0", OnUpdateLong,       default_behavior.connect_timeout)
+
+PHP_INI_END()
+/* }}} */
+
+#undef MEMC_INI_BOOL
+#undef MEMC_INI_LINK
+#undef MEMC_INI_ENTRY
+#undef MEMC_SESSION_INI_BOOL
+#undef MEMC_SESSION_INI_LINK
+#undef MEMC_SESSION_INI_ENTRY
+
+/****************************************
+  Forward declarations
+****************************************/
+static void php_memc_get_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+static void php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+static void php_memc_store_impl(INTERNAL_FUNCTION_PARAMETERS, int op, zend_bool by_key);
+static void php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+static void php_memc_delete_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+static void php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+static void php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key);
+
+/* Invoke PHP functions */
+static zend_bool s_invoke_cache_callback(zval *zobject, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_bool with_cas, zend_string *key, zval *value);
+
+/* Iterate result sets */
+typedef zend_bool (*php_memc_result_apply_fn)(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *context);
+
+static
+memcached_return php_memc_result_apply(php_memc_object_t *intern, php_memc_result_apply_fn result_apply_fn, zend_bool fetch_delay, void *context);
+
+static
+zend_bool php_memc_mget_apply(php_memc_object_t *intern, zend_string *server_key,
+								php_memc_keys_t *keys, php_memc_result_apply_fn result_apply_fn,
+								zend_bool with_cas, void *context);
+
+
+/* Callback functions for different server list iterations */
+static
+	memcached_return s_server_cursor_list_servers_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context);
+
+static
+	memcached_return s_server_cursor_version_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context);
+
+static
+	zend_bool s_memc_write_zval (php_memc_object_t *intern, php_memc_write_op op, zend_string *server_key, zend_string *key, zval *value, time_t expiration);
+
+static
+	void php_memc_destroy(memcached_st *memc, php_memc_user_data_t *memc_user_data);
+
+static
+	zend_bool s_memcached_result_to_zval(memcached_st *memc, memcached_result_st *result, zval *return_value);
+
+static
+	zend_string *s_zval_to_payload(php_memc_object_t *intern, zval *value, uint32_t *flags);
+
+static
+	void s_hash_to_keys(php_memc_keys_t *keys_out, HashTable *hash_in, zend_bool preserve_order, zval *return_value);
+
+static
+	void s_clear_keys(php_memc_keys_t *keys);
+
+
+/****************************************
+  Exported helper functions
+****************************************/
+
+zend_bool php_memc_init_sasl_if_needed()
+{
+#ifdef HAVE_MEMCACHED_SASL
+	if (MEMC_G(sasl_initialised)) {
+		return 1;
+	}
+	if (sasl_client_init(NULL) != SASL_OK) {
+		php_error_docref(NULL, E_ERROR, "Failed to initialize SASL library");
+		return 0;
+	}
+	return 1;
+#else
+	php_error_docref(NULL, E_ERROR, "Memcached not built with sasl support");
+	return 0;
+#endif
+}
+
+char *php_memc_printable_func (zend_fcall_info *fci, zend_fcall_info_cache *fci_cache)
+{
+	char *buffer = NULL;
+
+	if (fci->object) {
+		spprintf (&buffer, 0, "%s::%s", ZSTR_VAL(fci->object->ce->name), ZSTR_VAL(fci_cache->function_handler->common.function_name));
+	} else {
+		if (Z_TYPE (fci->function_name) == IS_OBJECT) {
+			spprintf (&buffer, 0, "%s", ZSTR_VAL(Z_OBJCE(fci->function_name)->name));
+		}
+		else {
+			spprintf (&buffer, 0, "%s", Z_STRVAL(fci->function_name));
+		}
+	}
+	return buffer;
+}
+
+
+/****************************************
+  Handling error codes
+****************************************/
+
+static
+zend_bool s_memcached_return_is_error(memcached_return status, zend_bool strict)
+{
+	zend_bool result = 0;
+
+	switch (status) {
+		case MEMCACHED_SUCCESS:
+		case MEMCACHED_STORED:
+		case MEMCACHED_DELETED:
+		case MEMCACHED_STAT:
+		case MEMCACHED_END:
+		case MEMCACHED_BUFFERED:
+			result = 0;
+			break;
+
+		case MEMCACHED_SOME_ERRORS:
+			result = strict;
+			break;
+
+		default:
+			result = 1;
+			break;
+	}
+	return result;
+}
+
+static
+int s_memc_status_handle_result_code(php_memc_object_t *intern, memcached_return status)
+{
+	intern->rescode = status;
+	intern->memc_errno = 0;
+
+	if (s_memcached_return_is_error(status, 1)) {
+		intern->memc_errno = memcached_last_error_errno(intern->memc);
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+
+static
+void s_memc_set_status(php_memc_object_t *intern, memcached_return status, int memc_errno)
+{
+	intern->rescode = status;
+	intern->memc_errno = memc_errno;
+}
+
+static
+zend_bool s_memc_status_has_error(php_memc_object_t *intern)
+{
+	return s_memcached_return_is_error(intern->rescode, 1);
+}
+
+static
+zend_bool s_memc_status_has_result_code(php_memc_object_t *intern, memcached_return status)
+{
+	return intern->rescode == status;
+}
+
+/****************************************
+  Marshall cas tokens
+****************************************/
+
+static
+void s_uint64_to_zval (zval *target, uint64_t value)
+{
+	if (value >= ((uint64_t) LONG_MAX)) {
+		zend_string *buffer;
+#ifdef PRIu64
+		buffer = strpprintf (0, "%" PRIu64, value);
+#else
+		/* Best effort */
+		buffer = strpprintf (0, "%llu", value);
+#endif
+		ZVAL_STR(target, buffer);
+	}
+	else {
+		ZVAL_LONG (target, (zend_long) value);
+	}
+}
+
+static
+uint64_t s_zval_to_uint64 (zval *cas)
+{
+	switch (Z_TYPE_P (cas)) {
+		case IS_LONG:
+			return (uint64_t) zval_get_long (cas);
+		break;
+
+		case IS_DOUBLE:
+			if (Z_DVAL_P (cas) < 0.0)
+				return 0;
+
+			return (uint64_t) zval_get_double (cas);
+		break;
+
+		case IS_STRING:
+		{
+			uint64_t val;
+			char *end;
+
+			errno = 0;
+			val = (uint64_t) strtoull (Z_STRVAL_P (cas), &end, 0);
+
+			if (*end || (errno == ERANGE && val == UINT64_MAX) || (errno != 0 && val == 0)) {
+				php_error_docref(NULL, E_ERROR, "Failed to unmarshall cas token");
+				return 0;
+			}
+			return val;
+		}
+		break;
+	}
+	return 0;
+}
+
+
+/****************************************
+  Iterate over memcached results and mget
+****************************************/
+
+static
+memcached_return php_memc_result_apply(php_memc_object_t *intern, php_memc_result_apply_fn result_apply_fn, zend_bool fetch_delay, void *context)
+{
+	memcached_result_st result, *result_ptr;
+	memcached_return rc, status = MEMCACHED_SUCCESS;
+
+	memcached_result_create(intern->memc, &result);
+
+	do {
+		result_ptr = memcached_fetch_result(intern->memc, &result, &rc);
+
+		if (s_memcached_return_is_error(rc, 0)) {
+			status = rc;
+		}
+
+		/* nothing returned */
+		if (!result_ptr) {
+			break;
+		}
+		else {
+			zend_string *key;
+			zval val, zcas;
+			zend_bool retval;
+
+			uint64_t cas;
+			uint32_t flags;
+
+			const char *res_key;
+			size_t res_key_len;
+			
+			if (!s_memcached_result_to_zval(intern->memc, &result, &val)) {
+				if (EG(exception)) {
+					status = MEMC_RES_PAYLOAD_FAILURE;
+					memcached_quit(intern->memc);
+					break;
+				}
+				status = MEMCACHED_SOME_ERRORS;
+				continue;
+			}
+
+			res_key     = memcached_result_key_value(&result);
+			res_key_len = memcached_result_key_length(&result);
+			cas         = memcached_result_cas(&result);
+			flags       = memcached_result_flags(&result);
+
+			s_uint64_to_zval(&zcas, cas);
+
+			key = zend_string_init (res_key, res_key_len, 0);
+			retval = result_apply_fn(intern, key, &val, &zcas, flags, context);
+
+			zend_string_release(key);
+			zval_ptr_dtor(&val);
+			zval_ptr_dtor(&zcas);
+
+			/* Stop iterating on false */
+			if (!retval) {
+				if (!fetch_delay) {
+					/* Make sure we clear our results */
+					while (memcached_fetch_result(intern->memc, &result, &rc)) {}
+				}
+				break;
+			}
+		}
+	} while (result_ptr != NULL);
+
+	memcached_result_free(&result);
+	return status;
+}
+
+static
+zend_bool php_memc_mget_apply(php_memc_object_t *intern, zend_string *server_key, php_memc_keys_t *keys,
+						php_memc_result_apply_fn result_apply_fn, zend_bool with_cas, void *context)
+{
+	memcached_return status;
+	int mget_status;
+	uint64_t orig_cas_flag = 0;
+
+	// Reset status code
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	if (!keys->num_valid_keys) {
+		intern->rescode = MEMCACHED_BAD_KEY_PROVIDED;
+		return 0;
+	}
+
+	if (with_cas) {
+		orig_cas_flag = memcached_behavior_get (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS);
+
+		if (!orig_cas_flag) {
+			memcached_behavior_set (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
+		}
+	}
+
+	if (server_key) {
+		status = memcached_mget_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), keys->mkeys, keys->mkeys_len, keys->num_valid_keys);
+	} else {
+		status = memcached_mget(intern->memc, keys->mkeys, keys->mkeys_len, keys->num_valid_keys);
+	}
+
+	/* Need to handle result code before restoring cas flags, would mess up errno */
+	mget_status = s_memc_status_handle_result_code(intern, status);
+		
+	if (with_cas && !orig_cas_flag) {
+		memcached_behavior_set (intern->memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, orig_cas_flag);
+	}
+
+	/* Return on failure codes */
+	if (mget_status == FAILURE) {
+		return 0;
+	}
+
+	if (!result_apply_fn) {
+		/* no callback, for example getDelayed */
+		return 1;
+	}
+
+	status = php_memc_result_apply(intern, result_apply_fn, 0, context);
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		return 0;
+	}
+
+	return 1;
+}
+
+/****************************************
+  Invoke callbacks
+****************************************/
+
+static
+zend_bool s_invoke_new_instance_cb(zval *object, zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zend_string *persistent_id)
+{
+	zend_bool ret = 1;
+	zval retval;
+	zval params2;
+
+	ZVAL_COPY(&params0, object);
+	if (persistent_id) {
+		ZVAL_STR(&params1, zend_string_copy(persistent_id));
+	} else {
+		ZVAL_NULL(&params1);
+	}
+
+	fci->retval = &retval;
+	fci->params = params;
+	fci->param_count = 2;
+
+	if (zend_call_function(fci, fci_cache) == FAILURE) {
+		char *buf = php_memc_printable_func (fci, fci_cache);
+		php_error_docref(NULL, E_WARNING, "Failed to invoke 'on_new' callback %s()", buf);
+		efree (buf);
+		ret = 0;
+	}
+
+	zval_ptr_dtor(&params0);
+	zval_ptr_dtor(&params1);
+	zval_ptr_dtor(&retval);
+
+	return ret;
+}
+
+static
+zend_bool s_invoke_cache_callback(zval *zobject, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_bool with_cas, zend_string *key, zval *value)
+{
+	zend_bool status = 0;
+	zval params4;
+	zval retval;
+	php_memc_object_t *intern = Z_MEMC_OBJ_P(zobject);
+
+	/* Prepare params */
+	ZVAL_COPY(&params0, zobject);
+	ZVAL_STR_COPY(&params1, key);    /* key */
+	ZVAL_NEW_REF(&params2, value);   /* value */
+
+	if (with_cas) {
+		fci->param_count = 3;
+	} else {
+		ZVAL_NEW_EMPTY_REF(&params3);    /* expiration */
+		ZVAL_NULL(Z_REFVAL(params3));
+		fci->param_count = 4;
+	}
+
+	fci->retval = &retval;
+	fci->params = params;
+
+	if (zend_call_function(fci, fcc) == SUCCESS) {
+		if (zend_is_true(&retval)) {
+			time_t expiration;
+			zval *val = Z_REFVAL(params2);
+
+			if (with_cas) {
+				if (Z_TYPE_P(val) == IS_ARRAY) {
+					zval *rv = zend_hash_str_find(Z_ARRVAL_P(val), "value", sizeof("value") - 1);
+					if (rv) {
+						zval *cas = zend_hash_str_find(Z_ARRVAL_P(val), "cas", sizeof("cas") -1);
+						expiration = cas? Z_LVAL_P(cas) : 0;
+						status = s_memc_write_zval (intern, MEMC_OP_SET, NULL, key, rv, expiration);
+					}
+					/* memleak?  zval_ptr_dtor(value); */
+					ZVAL_COPY(value, val);
+				}
+			} else {
+				expiration = zval_get_long(Z_REFVAL(params3));
+				status = s_memc_write_zval (intern, MEMC_OP_SET, NULL, key, val, expiration);
+				/* memleak?  zval_ptr_dtor(value); */
+				ZVAL_COPY(value, val);
+			}
+		}
+	}
+	else {
+		s_memc_set_status(intern, MEMCACHED_NOTFOUND, 0);
+	}
+
+	zval_ptr_dtor(&params0);
+	zval_ptr_dtor(&params1);
+	zval_ptr_dtor(&params2);
+	if (!with_cas) {
+		zval_ptr_dtor(&params3);
+	}
+	zval_ptr_dtor(&retval);
+
+	return status;
+}
+
+/****************************************
+  Wrapper for setting from zval
+****************************************/
+
+static
+zend_bool s_compress_value (php_memc_compression_type compression_type, zend_long compression_level, zend_string **payload_in, uint32_t *flags)
+{
+	/* status */
+	zend_bool compress_status = 0;
+	zend_string *payload = *payload_in;
+	uint32_t compression_type_flag = 0;
+
+	/* Additional 5% for the data */
+	size_t buffer_size = (size_t) (((double) ZSTR_LEN(payload) * 1.05) + 1.0);
+	char *buffer       = emalloc(buffer_size);
+
+	/* Store compressed size here */
+	size_t compressed_size = 0;
+	uint32_t original_size = ZSTR_LEN(payload);
+
+	switch (compression_type) {
+
+		case COMPRESSION_TYPE_FASTLZ:
+		{
+			compressed_size = fastlz_compress(ZSTR_VAL(payload), ZSTR_LEN(payload), buffer);
+
+			if (compressed_size > 0) {
+				compress_status = 1;
+				compression_type_flag = MEMC_VAL_COMPRESSION_FASTLZ;
+			}
+		}
+			break;
+
+#ifdef HAVE_ZSTD_H
+		case COMPRESSION_TYPE_ZSTD:
+		{
+			compressed_size = ZSTD_compress((void *)buffer, buffer_size, ZSTR_VAL(payload), ZSTR_LEN(payload), compression_level);
+
+			if (compression_level < -22) {
+				compression_level = -22;
+			} else if (compression_level > 22) {
+				compression_level = 22;
+			}
+
+			if (!ZSTD_isError(compressed_size)) {
+				compress_status = 1;
+				compression_type_flag = MEMC_VAL_COMPRESSION_ZSTD;
+			}
+		}
+			break;
+#endif
+
+		case COMPRESSION_TYPE_ZLIB:
+		{
+			unsigned long cs = compressed_size = buffer_size;
+
+			if (compression_level < 0) {
+				compression_level = 0;
+			} else if (compression_level > 9) {
+				compression_level = 9;
+			}
+
+			int status = compress2((Bytef *) buffer, &cs, (Bytef *) ZSTR_VAL(payload), ZSTR_LEN(payload), compression_level);
+
+			if (status == Z_OK) {
+				compressed_size = cs;
+				compress_status = 1;
+				compression_type_flag = MEMC_VAL_COMPRESSION_ZLIB;
+			}
+		}
+			break;
+
+		default:
+			compress_status = 0;
+			break;
+	}
+
+	/* This means the value was too small to be compressed and ended up larger */
+	if (ZSTR_LEN(payload) <= (compressed_size * MEMC_G(compression_factor))) {
+		compress_status = 0;
+	}
+
+	/* Replace the payload with the compressed copy */
+	if (compress_status) {
+		MEMC_VAL_SET_FLAG(*flags, MEMC_VAL_COMPRESSED | compression_type_flag);
+		payload = zend_string_realloc(payload, compressed_size + sizeof(uint32_t), 0);
+
+		/* Copy the uin32_t at the beginning */
+		memcpy(ZSTR_VAL(payload), &original_size, sizeof(uint32_t));
+		memcpy(ZSTR_VAL(payload) + sizeof (uint32_t), buffer, compressed_size);
+		efree(buffer);
+
+		zend_string_forget_hash_val(payload);
+		*payload_in = payload;
+
+		return 1;
+	}
+
+	/* Original payload was not modified */
+	efree(buffer);
+	return 0;
+}
+
+static
+zend_bool s_serialize_value (php_memc_serializer_type serializer, zval *value, smart_str *buf, uint32_t *flags)
+{
+	switch (serializer) {
+
+		/*
+			Igbinary serialization
+		*/
+#ifdef HAVE_MEMCACHED_IGBINARY
+		case SERIALIZER_IGBINARY:
+		{
+			uint8_t *buffer;
+			size_t buffer_len;
+
+			if (igbinary_serialize(&buffer, &buffer_len, value) != 0) {
+				php_error_docref(NULL, E_WARNING, "could not serialize value with igbinary");
+				return 0;
+			}
+			smart_str_appendl (buf, (char *)buffer, buffer_len);
+			efree(buffer);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_IGBINARY);
+		}
+			break;
+#endif
+
+		/*
+			JSON serialization
+		*/
+#ifdef HAVE_JSON_API
+		case SERIALIZER_JSON:
+		case SERIALIZER_JSON_ARRAY:
+		{
+			php_json_encode(buf, value, 0);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_JSON);
+		}
+			break;
+#endif
+
+		/*
+			msgpack serialization
+		*/
+#ifdef HAVE_MEMCACHED_MSGPACK
+		case SERIALIZER_MSGPACK:
+			php_msgpack_serialize(buf, value);
+			if (!buf->s) {
+				php_error_docref(NULL, E_WARNING, "could not serialize value with msgpack");
+				return 0;
+			}
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_MSGPACK);
+			break;
+#endif
+
+		/*
+			PHP serialization
+		*/
+		default:
+		{
+			php_serialize_data_t var_hash;
+			PHP_VAR_SERIALIZE_INIT(var_hash);
+			php_var_serialize(buf, value, &var_hash);
+			PHP_VAR_SERIALIZE_DESTROY(var_hash);
+
+			if (!buf->s) {
+				php_error_docref(NULL, E_WARNING, "could not serialize value");
+				return 0;
+			}
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_SERIALIZED);
+		}
+			break;
+	}
+
+	/* Check for exceptions caused by serializers */
+	if (EG(exception) && buf->s->len) {
+		return 0;
+	}
+	return 1;
+}
+
+static
+zend_string *s_zval_to_payload(php_memc_object_t *intern, zval *value, uint32_t *flags)
+{
+	zend_string *payload;
+	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
+	zend_bool should_compress = memc_user_data->compression_enabled;
+
+	switch (Z_TYPE_P(value)) {
+
+		case IS_STRING:
+			payload = zval_get_string(value);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_STRING);
+			break;
+
+		case IS_LONG:
+		{
+			smart_str buffer = {0};
+			smart_str_append_long (&buffer, Z_LVAL_P(value));
+			smart_str_0(&buffer);
+			payload = buffer.s;
+
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_LONG);
+			should_compress = 0;
+		}
+			break;
+
+		case IS_DOUBLE:
+		{
+			char buffer40;
+			php_memcached_g_fmt(buffer, Z_DVAL_P(value));
+			payload = zend_string_init (buffer, strlen (buffer), 0);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_DOUBLE);
+			should_compress = 0;
+		}
+			break;
+
+		case IS_TRUE:
+			payload = zend_string_init ("1", 1, 0);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_BOOL);
+			should_compress = 0;
+			break;
+
+		case IS_FALSE:
+			payload = zend_string_alloc (0, 0);
+			MEMC_VAL_SET_TYPE(*flags, MEMC_VAL_IS_BOOL);
+			should_compress = 0;
+			break;
+
+		default:
+		{
+			smart_str buffer = {0};
+
+			if (!s_serialize_value (memc_user_data->serializer, value, &buffer, flags)) {
+				smart_str_free(&buffer);
+				return NULL;
+			}
+			payload = buffer.s;
+		}
+			break;
+	}
+
+	/* turn off compression for values below the threshold */
+	if (ZSTR_LEN(payload) == 0 || ZSTR_LEN(payload) < MEMC_G(compression_threshold)) {
+		should_compress = 0;
+	}
+
+	/* If we have compression flag, compress the value */
+	if (should_compress) {
+		/* s_compress_value() will always leave a valid payload, even if that payload
+		 * did not actually get compressed. The flags will be set according to the
+		 * to the compression type or no compression.
+		 *
+		 * No need to check the return value because the payload is always valid.
+		 */
+		(void)s_compress_value (memc_user_data->compression_type, memc_user_data->compression_level, &payload, flags);
+	}
+
+	if (memc_user_data->set_udf_flags >= 0) {
+		MEMC_VAL_SET_USER_FLAGS(*flags, ((uint32_t) memc_user_data->set_udf_flags));
+	}
+
+	return payload;
+}
+
+static
+zend_bool s_is_payload_too_big(php_memc_object_t *intern, zend_string *payload)
+{
+	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
+
+	/* An item size limit of 0 implies no limit enforced */
+	if (memc_user_data->item_size_limit == 0) {
+		return 0;
+	}
+	if (ZSTR_LEN(payload) > memc_user_data->item_size_limit) {
+		return 1;
+	}
+	return 0;
+}
+
+static
+zend_bool s_should_retry_write (php_memc_object_t *intern, memcached_return status)
+{
+	if (memcached_server_count (intern->memc) == 0) {
+		return 0;
+	}
+
+	return s_memcached_return_is_error (status, 1);
+}
+
+static
+zend_bool s_memc_write_zval (php_memc_object_t *intern, php_memc_write_op op, zend_string *server_key, zend_string *key, zval *value, time_t expiration)
+{
+	uint32_t flags = 0;
+	zend_string *payload = NULL;
+	memcached_return status = 0;
+	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
+	zend_long retries = memc_user_data->store_retry_count;
+
+	if (value) {
+		payload = s_zval_to_payload(intern, value, &flags);
+
+		if (!payload) {
+			s_memc_set_status(intern, MEMC_RES_PAYLOAD_FAILURE, 0);
+			return 0;
+		}
+
+		if (s_is_payload_too_big(intern, payload)) {
+			s_memc_set_status(intern, MEMCACHED_E2BIG, 0);
+			zend_string_release(payload);
+			return 0;
+		}
+	}
+
+#define memc_write_using_fn(fn_name) payload ? fn_name(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags) : MEMC_RES_PAYLOAD_FAILURE;
+#define memc_write_using_fn_by_key(fn_name) payload ? fn_name(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags) : MEMC_RES_PAYLOAD_FAILURE;
+
+	if (server_key) {
+		switch (op) {
+			case MEMC_OP_SET:
+				status = memc_write_using_fn_by_key(memcached_set_by_key);
+			break;
+
+			case MEMC_OP_TOUCH:
+				status = php_memcached_touch_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), expiration);
+			break;
+			
+			case MEMC_OP_ADD:
+				status = memc_write_using_fn_by_key(memcached_add_by_key);
+			break;
+			
+			case MEMC_OP_REPLACE:
+				status = memc_write_using_fn_by_key(memcached_replace_by_key);
+			break;
+			
+			case MEMC_OP_APPEND:
+				status = memc_write_using_fn_by_key(memcached_append_by_key);
+			break;
+
+			case MEMC_OP_PREPEND:
+				status = memc_write_using_fn_by_key(memcached_prepend_by_key);
+			break;
+		}
+
+		if (status == MEMCACHED_END) {
+			status = MEMCACHED_SUCCESS;
+		}
+	}
+	else {
+retry:
+		switch (op) {
+			case MEMC_OP_SET:
+				status = memc_write_using_fn(memcached_set);
+			break;
+
+			case MEMC_OP_TOUCH:
+				status = php_memcached_touch(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), expiration);
+			break;
+			
+			case MEMC_OP_ADD:
+				status = memc_write_using_fn(memcached_add);
+			break;
+			
+			case MEMC_OP_REPLACE:
+				status = memc_write_using_fn(memcached_replace);
+			break;
+			
+			case MEMC_OP_APPEND:
+				status = memc_write_using_fn(memcached_append);
+			break;
+
+			case MEMC_OP_PREPEND:
+				status = memc_write_using_fn(memcached_prepend);
+			break;
+		}
+		if (status == MEMCACHED_END) {
+			status = MEMCACHED_SUCCESS;
+		}
+	}
+
+	if (s_should_retry_write (intern, status) && retries-- > 0) {
+		goto retry;
+	}
+
+#undef memc_write_using_fn
+#undef memc_write_using_fn_by_key
+
+	if (payload) {
+		zend_string_release(payload);
+	}
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		return 0;
+	}
+	return 1;
+}
+
+
+/****************************************
+  Methods
+****************************************/
+
+
+/* {{{ Memcached::__construct(string persistent_id, callback on_new, string connection_str))
+   Creates a Memcached object, optionally using persistent memcache connection */
+static PHP_METHOD(Memcached, __construct)
+{
+	php_memc_object_t *intern;
+	php_memc_user_data_t *memc_user_data;
+
+	zend_string *persistent_id = NULL;
+	zend_string *conn_str = NULL;
+	zend_string *plist_key = NULL;
+	zend_fcall_info fci = {0};
+	zend_fcall_info_cache fci_cache;
+
+	zend_bool is_persistent = 0;
+
+	/* "|S!f!S" */
+	ZEND_PARSE_PARAMETERS_START(0, 3)
+	        Z_PARAM_OPTIONAL
+	        Z_PARAM_STR_EX(persistent_id, 1, 0)
+	        Z_PARAM_FUNC_EX(fci, fci_cache, 1, 0)
+	        Z_PARAM_STR(conn_str)
+	ZEND_PARSE_PARAMETERS_END();
+
+	intern = Z_MEMC_OBJ_P(getThis());
+	intern->is_pristine = 1;
+
+	if (persistent_id && persistent_id->len) {
+		zend_resource *le;
+
+		plist_key = zend_string_alloc(sizeof("memcached:id=") + persistent_id->len - 1, 0);
+		snprintf(ZSTR_VAL(plist_key), plist_key->len + 1, "memcached:id=%s", ZSTR_VAL(persistent_id));
+
+		if ((le = zend_hash_find_ptr(&EG(persistent_list), plist_key)) != NULL) {
+			if (le->type == php_memc_list_entry()) {
+				intern->memc = le->ptr;
+				intern->is_pristine = 0;
+				zend_string_release (plist_key);
+				return;
+			}
+		}
+		is_persistent = 1;
+	}
+
+	if (conn_str && conn_str->len > 0) {
+		intern->memc = memcached (ZSTR_VAL(conn_str), ZSTR_LEN(conn_str));
+	}
+	else {
+		intern->memc = memcached (NULL, 0);
+	}
+
+	if (!intern->memc) {
+		php_error_docref(NULL, E_ERROR, "Failed to allocate memory for memcached structure");
+		/* never reached */
+	}
+
+	memc_user_data                    = pecalloc (1, sizeof(*memc_user_data), is_persistent);
+	memc_user_data->serializer        = MEMC_G(serializer_type);
+	memc_user_data->compression_type  = MEMC_G(compression_type);
+	memc_user_data->compression_level = MEMC_G(compression_level);
+	memc_user_data->compression_enabled = 1;
+	memc_user_data->encoding_enabled  = 0;
+	memc_user_data->store_retry_count = MEMC_G(store_retry_count);
+	memc_user_data->set_udf_flags     = -1;
+	memc_user_data->item_size_limit   = MEMC_G(item_size_limit);
+	memc_user_data->is_persistent     = is_persistent;
+
+	memcached_set_user_data(intern->memc, memc_user_data);
+
+	/* Set default behaviors */
+	if (MEMC_G(default_behavior.consistent_hash_enabled)) {
+		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT);
+		if (rc != MEMCACHED_SUCCESS) {
+			php_error_docref(NULL, E_WARNING, "Failed to turn on consistent hash: %s", memcached_strerror(intern->memc, rc));
+		}
+	}
+
+	if (MEMC_G(default_behavior.binary_protocol_enabled)) {
+		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+		if (rc != MEMCACHED_SUCCESS) {
+			php_error_docref(NULL, E_WARNING, "Failed to turn on binary protocol: %s", memcached_strerror(intern->memc, rc));
+		}
+		/* Also enable TCP_NODELAY when binary protocol is enabled */
+		rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+		if (rc != MEMCACHED_SUCCESS) {
+			php_error_docref(NULL, E_WARNING, "Failed to set TCP_NODELAY: %s", memcached_strerror(intern->memc, rc));
+		}
+	}
+
+	if (MEMC_G(default_behavior.connect_timeout)) {
+		memcached_return rc = memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, MEMC_G(default_behavior.connect_timeout));
+		if (rc != MEMCACHED_SUCCESS) {
+			php_error_docref(NULL, E_WARNING, "Failed to set connect timeout: %s", memcached_strerror(intern->memc, rc));
+		}
+	}
+
+	if (fci.size) {
+		if (!s_invoke_new_instance_cb(getThis(), &fci, &fci_cache, persistent_id) || EG(exception)) {
+			/* error calling or exception thrown from callback */
+			if (plist_key) {
+				zend_string_release(plist_key);
+			}
+			/*
+				Setting intern->memc null prevents object destruction from freeing the memcached_st
+				We free it manually here because it might be persistent and has not been
+				registered to persistent_list yet
+			*/
+			php_memc_destroy(intern->memc, memc_user_data);
+			intern->memc = NULL;
+			return;
+		}
+	}
+
+	if (plist_key) {
+		zend_resource le;
+
+		le.type = php_memc_list_entry();
+		le.ptr  = intern->memc;
+
+		GC_SET_REFCOUNT(&le, 1);
+
+		/* plist_key is not a persistent allocated key, thus we use str_update here */
+		if (zend_hash_str_update_mem(&EG(persistent_list), ZSTR_VAL(plist_key), ZSTR_LEN(plist_key), &le, sizeof(le)) == NULL) {
+			zend_string_release(plist_key);
+			php_error_docref(NULL, E_ERROR, "could not register persistent entry");
+			/* not reached */
+		}
+		zend_string_release(plist_key);
+	}
+}
+/* }}} */
+
+
+
+static
+void s_hash_to_keys(php_memc_keys_t *keys_out, HashTable *hash_in, zend_bool preserve_order, zval *return_value)
+{
+	size_t idx = 0, alloc_count;
+	zval *zv;
+
+	keys_out->num_valid_keys = 0;
+
+	alloc_count = zend_hash_num_elements(hash_in);
+	if (!alloc_count) {
+		return;
+	}
+	keys_out->mkeys     = ecalloc (alloc_count, sizeof (char *));
+	keys_out->mkeys_len = ecalloc (alloc_count, sizeof (size_t));
+	keys_out->strings   = ecalloc (alloc_count, sizeof (zend_string *));
+
+	ZEND_HASH_FOREACH_VAL(hash_in, zv) {
+		zend_string *key = zval_get_string(zv);
+
+		if (preserve_order && return_value) {
+			add_assoc_null_ex(return_value, ZSTR_VAL(key), ZSTR_LEN(key));
+		}
+
+		if (ZSTR_LEN(key) > 0 && ZSTR_LEN(key) < MEMCACHED_MAX_KEY) {
+			keys_out->mkeysidx     = ZSTR_VAL(key);
+			keys_out->mkeys_lenidx = ZSTR_LEN(key);
+
+			keys_out->stringsidx = key;
+			idx++;
+		}
+		else {
+			zend_string_release (key);
+		}
+
+	} ZEND_HASH_FOREACH_END();
+
+	if (!idx) {
+		efree (keys_out->mkeys);
+		efree (keys_out->mkeys_len);
+		efree (keys_out->strings);
+	}
+	keys_out->num_valid_keys = idx;
+}
+
+static
+void s_key_to_keys(php_memc_keys_t *keys_out, zend_string *key)
+{
+	zval zv_keys;
+
+	array_init(&zv_keys);
+	add_next_index_str(&zv_keys, zend_string_copy(key));
+
+	s_hash_to_keys(keys_out, Z_ARRVAL(zv_keys), 0, NULL);
+	zval_ptr_dtor(&zv_keys);
+}
+
+static
+void s_clear_keys(php_memc_keys_t *keys)
+{
+	size_t i;
+
+	if (!keys->num_valid_keys) {
+		return;
+	}
+
+	for (i = 0; i < keys->num_valid_keys; i++) {
+		zend_string_release (keys->stringsi);
+	}
+	efree(keys->strings);
+	efree(keys->mkeys);
+	efree(keys->mkeys_len);
+}
+
+typedef struct {
+	zend_bool extended;
+	zval *return_value;
+} php_memc_get_ctx_t;
+
+static
+zend_bool s_get_apply_fn(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
+{
+	php_memc_get_ctx_t *context = (php_memc_get_ctx_t *) in_context;
+
+	if (context->extended) {
+		Z_TRY_ADDREF_P(value);
+		Z_TRY_ADDREF_P(cas);
+
+		array_init (context->return_value);
+		add_assoc_zval (context->return_value, "value", value);
+		add_assoc_zval (context->return_value, "cas",   cas);
+		add_assoc_long (context->return_value, "flags", (zend_long) MEMC_VAL_GET_USER_FLAGS(flags));
+	}
+	else {
+		ZVAL_COPY(context->return_value, value);
+	}
+	return 0; /* Stop after one */
+}
+
+static
+void php_memc_get_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	php_memc_get_ctx_t context = {0};
+	php_memc_keys_t keys = {0};
+	zend_long get_flags = 0;
+	zend_string *key;
+	zend_string *server_key = NULL;
+	zend_bool mget_status;
+	memcached_return status = MEMCACHED_SUCCESS;
+	zend_fcall_info fci = empty_fcall_info;
+	zend_fcall_info_cache fcc = empty_fcall_info_cache;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		/* "SS|f!l" */
+		ZEND_PARSE_PARAMETERS_START(2, 4)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
+		        Z_PARAM_LONG(get_flags)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "S|f!l" */
+		ZEND_PARSE_PARAMETERS_START(1, 3)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
+		        Z_PARAM_LONG(get_flags)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+
+	context.extended = (get_flags & MEMC_GET_EXTENDED);
+
+	context.return_value = return_value;
+
+	s_key_to_keys(&keys, key);
+	mget_status = php_memc_mget_apply(intern, server_key, &keys, s_get_apply_fn, context.extended, &context);
+	s_clear_keys(&keys);
+
+	if (!mget_status) {
+		if (s_memc_status_has_result_code(intern, MEMCACHED_NOTFOUND) && fci.size > 0) {
+			status = s_invoke_cache_callback(object, &fci, &fcc, context.extended, key, return_value);
+
+			if (!status) {
+				zval_ptr_dtor(return_value);
+				RETURN_FROM_GET;
+			}
+		}
+	}
+
+	if (s_memc_status_has_error(intern)) {
+		zval_ptr_dtor(return_value);
+		RETURN_FROM_GET;
+	}
+}
+
+/* {{{ Memcached::get(string key , mixed callback , int get_flags = 0)
+   Returns a value for the given key or false */
+PHP_METHOD(Memcached, get)
+{
+	php_memc_get_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::getByKey(string server_key, string key , mixed callback , int get_flags = 0)
+   Returns a value for key from the server identified by the server key or false */
+PHP_METHOD(Memcached, getByKey)
+{
+	php_memc_get_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+static
+zend_bool s_get_multi_apply_fn(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
+{
+	php_memc_get_ctx_t *context = (php_memc_get_ctx_t *) in_context;
+
+	Z_TRY_ADDREF_P(value);
+
+	if (context->extended) {
+		zval node;
+
+		Z_TRY_ADDREF_P(cas);
+
+		array_init(&node);
+		add_assoc_zval(&node, "value", value);
+		add_assoc_zval(&node, "cas",   cas);
+		add_assoc_long(&node, "flags", (zend_long) MEMC_VAL_GET_USER_FLAGS(flags));
+
+		zend_symtable_update(Z_ARRVAL_P(context->return_value), key, &node);
+	}
+	else {
+		zend_symtable_update(Z_ARRVAL_P(context->return_value), key, value);
+	}
+	return 1;
+}
+
+/* {{{ -- php_memc_getMulti_impl */
+static void php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	php_memc_get_ctx_t context;
+	php_memc_keys_t keys_out;
+
+	zval *keys = NULL;
+	zend_string *server_key = NULL;
+	zend_long flags = 0;
+	MEMC_METHOD_INIT_VARS;
+	zend_bool retval, preserve_order;
+
+	if (by_key) {
+		/* "Sa|l" */
+		ZEND_PARSE_PARAMETERS_START(2, 3)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_ARRAY(keys)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(flags)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "a|l" */
+		ZEND_PARSE_PARAMETERS_START(1, 2)
+		        Z_PARAM_ARRAY(keys)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(flags)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	array_init(return_value);
+	if (zend_hash_num_elements(Z_ARRVAL_P(keys)) == 0) {
+		/* BC compatible */
+		s_memc_set_status(intern, MEMCACHED_NOTFOUND, 0);
+		return;
+	}
+
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	preserve_order = (flags & MEMC_GET_PRESERVE_ORDER);
+	s_hash_to_keys(&keys_out, Z_ARRVAL_P(keys), preserve_order, return_value);
+
+	context.extended = (flags & MEMC_GET_EXTENDED);
+	context.return_value = return_value;
+
+	retval = php_memc_mget_apply(intern, server_key, &keys_out, s_get_multi_apply_fn, context.extended, &context);
+
+	s_clear_keys(&keys_out);
+
+	if (!retval && (s_memc_status_has_result_code(intern, MEMCACHED_NOTFOUND) || s_memc_status_has_result_code(intern, MEMCACHED_SOME_ERRORS))) {
+		return;
+	}
+
+	if (!retval || EG(exception)) {
+		zval_dtor(return_value);
+		RETURN_FROM_GET;
+	}
+}
+/* }}} */
+
+/* {{{ Memcached::getMulti(array keys, long flags = 0 )
+   Returns values for the given keys or false */
+PHP_METHOD(Memcached, getMulti)
+{
+	php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::getMultiByKey(string server_key, array keys, long flags = 0 )
+   Returns values for the given keys from the server identified by the server key or false */
+PHP_METHOD(Memcached, getMultiByKey)
+{
+	php_memc_getMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::getDelayed(array keys , bool with_cas , mixed callback  )
+   Sends a request for the given keys and returns immediately */
+PHP_METHOD(Memcached, getDelayed)
+{
+	php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::getDelayedByKey(string server_key, array keys , bool with_cas , mixed callback  )
+   Sends a request for the given keys from the server identified by the server key and returns immediately */
+PHP_METHOD(Memcached, getDelayedByKey)
+{
+	php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+
+static
+void s_create_result_array(zend_string *key, zval *value, zval *cas, uint32_t flags, zval *return_value)
+{
+	Z_TRY_ADDREF_P(value);
+	Z_TRY_ADDREF_P(cas);
+
+	add_assoc_str_ex(return_value, ZEND_STRL("key"), zend_string_copy(key));
+	add_assoc_zval_ex(return_value, ZEND_STRL("value"), value);
+
+	if (Z_LVAL_P(cas)) {
+		/* BC compatible */
+		add_assoc_zval_ex(return_value, ZEND_STRL("cas"), cas);
+		add_assoc_long_ex(return_value, ZEND_STRL("flags"), MEMC_VAL_GET_USER_FLAGS(flags));
+	}
+}
+
+static
+zend_bool s_result_callback_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
+{
+	zend_bool status = 1;
+	zval params2;
+	zval retval;
+	php_memc_result_callback_ctx_t *context = (php_memc_result_callback_ctx_t *) in_context;
+
+	ZVAL_COPY(&params0, context->object);
+	array_init(&params1);
+
+	s_create_result_array(key, value, cas, flags, &params1);
+
+	context->fci.retval = &retval;
+	context->fci.params = params;
+	context->fci.param_count = 2;
+	
+	if (zend_call_function(&context->fci, &context->fcc) == FAILURE) {
+		php_error_docref(NULL, E_WARNING, "could not invoke result callback");
+		status = 0;
+	}
+
+	zval_ptr_dtor(&retval);
+
+	zval_ptr_dtor(&params0);
+	zval_ptr_dtor(&params1);
+
+	return status;
+}
+
+/* {{{ -- php_memc_getDelayed_impl */
+static void php_memc_getDelayed_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	php_memc_keys_t keys_out = {0};
+
+	zval *keys = NULL;
+	zend_string *server_key = NULL;
+	zend_bool with_cas = 0;
+
+	zend_fcall_info fci = empty_fcall_info;
+	zend_fcall_info_cache fcc = empty_fcall_info_cache;
+	memcached_return status = MEMCACHED_SUCCESS;
+	MEMC_METHOD_INIT_VARS;
+
+
+	if (by_key) {
+		/* "Sa/|bf!" */
+		ZEND_PARSE_PARAMETERS_START(2, 4)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_ARRAY_EX(keys, 0, 1)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_BOOL(with_cas)
+		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "a/|bf!" */
+		ZEND_PARSE_PARAMETERS_START(1, 3)
+		        Z_PARAM_ARRAY_EX(keys, 0, 1)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_BOOL(with_cas)
+		        Z_PARAM_FUNC_EX(fci, fcc, 1, 0)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	s_hash_to_keys(&keys_out, Z_ARRVAL_P(keys), 0, NULL);
+
+	if (fci.size > 0) {
+		php_memc_result_callback_ctx_t context = {
+			getThis(), fci, fcc
+		};
+		status = php_memc_mget_apply(intern, server_key, &keys_out, &s_result_callback_apply, with_cas, (void *) &context);
+	}
+	else {
+		status = php_memc_mget_apply(intern, server_key, &keys_out, NULL, with_cas, NULL);
+	}
+
+	s_clear_keys(&keys_out);
+	RETURN_BOOL(status);
+}
+/* }}} */
+
+static
+zend_bool s_fetch_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
+{
+	zval *return_value = (zval *) in_context;
+	s_create_result_array(key, value, cas, flags, return_value);
+
+	return 0; // stop iterating after one
+}
+
+/* {{{ Memcached::fetch()
+   Returns the next result from a previous delayed request */
+PHP_METHOD(Memcached, fetch)
+{
+	memcached_return status = MEMCACHED_SUCCESS;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	array_init(return_value);
+	status = php_memc_result_apply(intern, s_fetch_apply, 1, return_value);
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		zval_ptr_dtor(return_value);
+		RETURN_FROM_GET;
+	}
+}
+/* }}} */
+
+static
+zend_bool s_fetch_all_apply(php_memc_object_t *intern, zend_string *key, zval *value, zval *cas, uint32_t flags, void *in_context)
+{
+	zval zv;
+	zval *return_value = (zval *) in_context;
+
+	array_init (&zv);
+	s_create_result_array(key, value, cas, flags, &zv);
+
+	add_next_index_zval(return_value, &zv);
+	return 1;
+}
+
+/* {{{ Memcached::fetchAll()
+   Returns all the results from a previous delayed request */
+PHP_METHOD(Memcached, fetchAll)
+{
+	memcached_return status = MEMCACHED_SUCCESS;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	array_init(return_value);
+	status = php_memc_result_apply(intern, s_fetch_all_apply, 0, return_value);
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		zval_dtor(return_value);
+		RETURN_FALSE;
+	}
+}
+/* }}} */
+
+/* {{{ Memcached::set(string key, mixed value , int expiration )
+   Sets the value for the given key */
+PHP_METHOD(Memcached, set)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_SET, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::setByKey(string server_key, string key, mixed value , int expiration )
+   Sets the value for the given key on the server identified by the server key */
+PHP_METHOD(Memcached, setByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_SET, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::touch(string key, , int expiration )
+   Sets a new expiration for the given key */
+PHP_METHOD(Memcached, touch)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_TOUCH, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::touchbyKey(string key, , int expiration )
+   Sets a new expiration for the given key */
+PHP_METHOD(Memcached, touchByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_TOUCH, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::setMulti(array items , int expiration  )
+   Sets the keys/values specified in the items array */
+PHP_METHOD(Memcached, setMulti)
+{
+	php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::setMultiByKey(string server_key, array items , int expiration )
+   Sets the keys/values specified in the items array on the server identified by the given server key */
+PHP_METHOD(Memcached, setMultiByKey)
+{
+	php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+/* {{{ -- php_memc_setMulti_impl */
+static void php_memc_setMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	zval *entries;
+	zend_string *server_key = NULL;
+	zend_long expiration = 0;
+	zval *value;
+	zend_string *skey;
+	zend_ulong num_key;
+	int tmp_len = 0;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		/* "Sa|ll" */
+		ZEND_PARSE_PARAMETERS_START(2, 3)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_ARRAY(entries)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "a|ll" */
+		ZEND_PARSE_PARAMETERS_START(1, 2)
+		        Z_PARAM_ARRAY(entries)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	ZEND_HASH_FOREACH_KEY_VAL (Z_ARRVAL_P(entries), num_key, skey, value) {
+		zend_string *str_key = NULL;
+
+		if (skey) {
+			str_key = skey;
+		}
+		else {
+			char tmp_key64;
+
+			tmp_len = snprintf(tmp_key, sizeof(tmp_key) - 1, "%ld", (long)num_key);
+			str_key = zend_string_init(tmp_key, tmp_len, 0);
+		}
+
+		/* If this failed to write a value, intern stores the error for the return value */
+		s_memc_write_zval (intern, MEMC_OP_SET, server_key, str_key, value, expiration);
+
+		if (!skey) {
+			zend_string_release (str_key);
+		}
+
+	} ZEND_HASH_FOREACH_END();
+
+	RETURN_BOOL(!s_memc_status_has_error(intern));
+}
+/* }}} */
+
+/* {{{ Memcached::add(string key, mixed value , int expiration )
+   Sets the value for the given key, failing if the key already exists */
+PHP_METHOD(Memcached, add)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_ADD, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::addByKey(string server_key, string key, mixed value , int expiration )
+   Sets the value for the given key on the server identified by the sever key, failing if the key already exists */
+PHP_METHOD(Memcached, addByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_ADD, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::append(string key, mixed value)
+   Appends the value to existing one for the key */
+PHP_METHOD(Memcached, append)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_APPEND, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::appendByKey(string server_key, string key, mixed value)
+   Appends the value to existing one for the key on the server identified by the server key */
+PHP_METHOD(Memcached, appendByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_APPEND, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::prepend(string key, mixed value)
+   Prepends the value to existing one for the key */
+PHP_METHOD(Memcached, prepend)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_PREPEND, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::prependByKey(string server_key, string key, mixed value)
+   Prepends the value to existing one for the key on the server identified by the server key */
+PHP_METHOD(Memcached, prependByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_PREPEND, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::replace(string key, mixed value , int expiration )
+   Replaces the value for the given key, failing if the key doesn't exist */
+PHP_METHOD(Memcached, replace)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_REPLACE, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::replaceByKey(string server_key, string key, mixed value , int expiration )
+   Replaces the value for the given key on the server identified by the server key, failing if the key doesn't exist */
+PHP_METHOD(Memcached, replaceByKey)
+{
+	php_memc_store_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, MEMC_OP_REPLACE, 1);
+}
+/* }}} */
+
+/* {{{ -- php_memc_store_impl */
+static void php_memc_store_impl(INTERNAL_FUNCTION_PARAMETERS, int op, zend_bool by_key)
+{
+	zend_string *key;
+	zend_string *server_key = NULL;
+	zend_string *s_value;
+	zval s_zvalue;
+	zval *value = NULL;
+	zend_long expiration = 0;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
+			/* "SSS" */
+			ZEND_PARSE_PARAMETERS_START(3, 3)
+			        Z_PARAM_STR(server_key)
+			        Z_PARAM_STR(key)
+			        Z_PARAM_STR(s_value)
+			ZEND_PARSE_PARAMETERS_END();
+			value = &s_zvalue;
+			ZVAL_STR(value, s_value);
+		} else if (op == MEMC_OP_TOUCH) {
+			/* "SS|l" */
+			ZEND_PARSE_PARAMETERS_START(2, 3)
+			        Z_PARAM_STR(server_key)
+			        Z_PARAM_STR(key)
+				Z_PARAM_OPTIONAL
+				Z_PARAM_LONG(expiration)
+			ZEND_PARSE_PARAMETERS_END();
+		} else {
+			/* "SSz|l" */
+			ZEND_PARSE_PARAMETERS_START(3, 4)
+			        Z_PARAM_STR(server_key)
+			        Z_PARAM_STR(key)
+			        Z_PARAM_ZVAL(value)
+				Z_PARAM_OPTIONAL
+				Z_PARAM_LONG(expiration)
+			ZEND_PARSE_PARAMETERS_END();
+		}
+	} else {
+		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
+			/* "SS" */
+			ZEND_PARSE_PARAMETERS_START(2, 2)
+			        Z_PARAM_STR(key)
+			        Z_PARAM_STR(s_value)
+			ZEND_PARSE_PARAMETERS_END();
+			value = &s_zvalue;
+			ZVAL_STR(value, s_value);
+		} else if (op == MEMC_OP_TOUCH) {
+			/* "S|l */
+			ZEND_PARSE_PARAMETERS_START(1, 2)
+			        Z_PARAM_STR(key)
+			        Z_PARAM_OPTIONAL
+			        Z_PARAM_LONG(expiration)
+			ZEND_PARSE_PARAMETERS_END();
+		} else {
+			/* "Sz|l" */
+			ZEND_PARSE_PARAMETERS_START(2, 3)
+			        Z_PARAM_STR(key)
+			        Z_PARAM_ZVAL(value)
+			        Z_PARAM_OPTIONAL
+			        Z_PARAM_LONG(expiration)
+			ZEND_PARSE_PARAMETERS_END();
+		}
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+
+	if (memc_user_data->compression_enabled) {
+		/*
+		 * When compression is enabled, we cannot do appends/prepends because that would
+		 * corrupt the compressed values. It is up to the user to fetch the value,
+		 * append/prepend new data, and store it again.
+		 */
+		if (op == MEMC_OP_APPEND || op == MEMC_OP_PREPEND) {
+			php_error_docref(NULL, E_WARNING, "cannot append/prepend with compression turned on");
+			RETURN_NULL();
+		}
+	}
+
+	if (!s_memc_write_zval (intern, op, server_key, key, value, expiration)) {
+		RETURN_FALSE;
+	}
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ -- php_memc_cas_impl */
+static void php_memc_cas_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	zval *zv_cas;
+	uint64_t cas;
+	zend_string *key;
+	zend_string *server_key = NULL;
+	zval *value;
+	zend_long expiration = 0;
+	zend_string *payload;
+	uint32_t flags = 0;
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		/* "zSSz|l" */
+		ZEND_PARSE_PARAMETERS_START(4, 5)
+		        Z_PARAM_ZVAL(zv_cas)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_ZVAL(value)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "zSz|l" */
+		ZEND_PARSE_PARAMETERS_START(3, 4)
+		        Z_PARAM_ZVAL(zv_cas)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_ZVAL(value)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+
+	cas = s_zval_to_uint64(zv_cas);
+
+	payload = s_zval_to_payload(intern, value, &flags);
+	if (payload == NULL) {
+		intern->rescode = MEMC_RES_PAYLOAD_FAILURE;
+		RETURN_FALSE;
+	}
+
+	if (s_is_payload_too_big(intern, payload)) {
+		intern->rescode = MEMCACHED_E2BIG;
+		zend_string_release(payload);
+		RETURN_FALSE;
+	}
+
+	if (by_key) {
+		status = memcached_cas_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags, cas);
+	} else {
+		status = memcached_cas(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(payload), ZSTR_LEN(payload), expiration, flags, cas);
+	}
+
+	zend_string_release(payload);
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::cas(double cas_token, string key, mixed value , int expiration )
+   Sets the value for the given key, failing if the cas_token doesn't match the one in memcache */
+PHP_METHOD(Memcached, cas)
+{
+	php_memc_cas_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::casByKey(double cas_token, string server_key, string key, mixed value , int expiration )
+   Sets the value for the given key on the server identified by the server_key, failing if the cas_token doesn't match the one in memcache */
+PHP_METHOD(Memcached, casByKey)
+{
+	php_memc_cas_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::delete(string key , int time )
+   Deletes the given key */
+PHP_METHOD(Memcached, delete)
+{
+	php_memc_delete_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::deleteMulti(array keys , int time )
+   Deletes the given keys */
+PHP_METHOD(Memcached, deleteMulti)
+{
+	php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::deleteByKey(string server_key, string key , int time )
+   Deletes the given key from the server identified by the server key */
+PHP_METHOD(Memcached, deleteByKey)
+{
+	php_memc_delete_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::deleteMultiByKey(array keys , int time )
+   Deletes the given key from the server identified by the server key */
+PHP_METHOD(Memcached, deleteMultiByKey)
+{
+	php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */
+
+/* {{{ -- php_memc_delete_impl */
+static void php_memc_delete_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	zend_string *key, *server_key;
+	zend_long expiration = 0;
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		/* "SS|l" */
+		ZEND_PARSE_PARAMETERS_START(2, 3)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "S|l" */
+		ZEND_PARSE_PARAMETERS_START(1, 2)
+		        Z_PARAM_STR(key)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+		server_key = key;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+
+	if (by_key) {
+		status = memcached_delete_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key),
+									 ZSTR_LEN(key), expiration);
+	} else {
+		status = memcached_delete(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), expiration);
+	}
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ -- php_memc_deleteMulti_impl */
+static void php_memc_deleteMulti_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key)
+{
+	zval *entries, *zv, ret;
+	zend_string *server_key = NULL;
+	zend_long expiration = 0;
+	zend_string *entry;
+
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	if (by_key) {
+		/* "Sa/|l" */
+		ZEND_PARSE_PARAMETERS_START(2, 3)
+		        Z_PARAM_STR(server_key)
+		        Z_PARAM_ARRAY_EX(entries, 0, 1)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "a/|l" */
+		ZEND_PARSE_PARAMETERS_START(1, 2)
+		        Z_PARAM_ARRAY_EX(entries, 0, 1)
+		        Z_PARAM_OPTIONAL
+		        Z_PARAM_LONG(expiration)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	array_init(return_value);
+	ZEND_HASH_FOREACH_VAL (Z_ARRVAL_P(entries), zv) {
+		entry = zval_get_string(zv);
+
+		if (ZSTR_LEN(entry) == 0) {
+			zend_string_release(entry);
+			continue;
+		}
+
+		if (by_key) {
+			status = memcached_delete_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(entry), ZSTR_LEN(entry), expiration);
+		} else {
+			status = memcached_delete_by_key(intern->memc, ZSTR_VAL(entry), ZSTR_LEN(entry), ZSTR_VAL(entry), ZSTR_LEN(entry), expiration);
+		}
+
+		if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+			ZVAL_LONG(&ret, status);
+		} else {
+			ZVAL_TRUE(&ret);
+		}
+		zend_symtable_update(Z_ARRVAL_P(return_value), entry, &ret);
+		zend_string_release(entry);
+	} ZEND_HASH_FOREACH_END();
+
+	return;
+}
+/* }}} */
+
+/* {{{ -- php_memc_incdec_impl */
+static void php_memc_incdec_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool by_key, zend_bool incr)
+{
+	zend_string *key, *server_key = NULL;
+	zend_long offset = 1;
+	zend_long expiry = 0;
+	zend_long initial = 0;
+	uint64_t value = UINT64_MAX;
+	memcached_return status;
+	int n_args = ZEND_NUM_ARGS();
+
+	MEMC_METHOD_INIT_VARS;
+
+	if (!by_key) {
+		/* "S|lll" */
+		ZEND_PARSE_PARAMETERS_START(1, 4)
+			Z_PARAM_STR(key)
+			Z_PARAM_OPTIONAL
+			Z_PARAM_LONG(offset)
+			Z_PARAM_LONG(initial)
+			Z_PARAM_LONG(expiry)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		/* "SS|lll" */
+		ZEND_PARSE_PARAMETERS_START(2, 5)
+			Z_PARAM_STR(server_key)
+			Z_PARAM_STR(key)
+			Z_PARAM_OPTIONAL
+			Z_PARAM_LONG(offset)
+			Z_PARAM_LONG(initial)
+			Z_PARAM_LONG(expiry)
+		ZEND_PARSE_PARAMETERS_END();
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+
+	if (offset < 0) {
+		php_error_docref(NULL, E_WARNING, "offset cannot be a negative value");
+		RETURN_FALSE;
+	}
+
+	if ((!by_key && n_args < 3) || (by_key && n_args < 4)) {
+		if (by_key) {
+			if (incr) {
+				status = memcached_increment_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
+			} else {
+				status = memcached_decrement_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
+			}
+		} else {
+			/* The libmemcached API has a quirk that memcached_increment() takes only a 32-bit
+			 * offset, but memcached_increment_by_key() and all other increment and decrement
+			 * functions take a 64-bit offset. The memcached protocol allows increment/decrement
+			 * greater than UINT_MAX, so we just work around memcached_increment() here.
+			 */
+			if (incr) {
+				status = memcached_increment_by_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
+			} else {
+				status = memcached_decrement_by_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(key), ZSTR_LEN(key), offset, &value);
+			}
+		}
+
+	} else {
+		zend_long retries = memc_user_data->store_retry_count;
+
+retry_inc_dec:
+		if (!memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) {
+			php_error_docref(NULL, E_WARNING, "Initial value is only supported with binary protocol");
+			RETURN_FALSE;
+		}
+		if (by_key) {
+			if (incr) {
+				status = memcached_increment_with_initial_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
+			} else {
+				status = memcached_decrement_with_initial_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
+			}
+		} else {
+			if (incr) {
+				status = memcached_increment_with_initial(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
+			} else {
+				status = memcached_decrement_with_initial(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key), offset, initial, (time_t)expiry, &value);
+			}
+		}
+		if (s_should_retry_write(intern, status) && retries-- > 0) {
+			goto retry_inc_dec;
+		}
+	}
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	if (value == UINT64_MAX) {
+		RETURN_FALSE;
+	}
+
+	RETURN_LONG((long)value);
+}
+/* }}} */
+
+/* {{{ Memcached::increment(string key , int delta , initial_value , expiry time   )
+   Increments the value for the given key by delta, defaulting to 1 */
+PHP_METHOD(Memcached, increment)
+{
+	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::decrement(string key , int delta , initial_value , expiry time   )
+   Decrements the value for the given key by delta, defaulting to 1 */
+PHP_METHOD(Memcached, decrement)
+{
+	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::decrementByKey(string server_key, string key , int delta , initial_value , expiry time   )
+   Decrements by server the value for the given key by delta, defaulting to 1 */
+PHP_METHOD(Memcached, decrementByKey)
+{
+	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
+}
+/* }}} */
+
+/* {{{ Memcached::increment(string server_key, string key , int delta , initial_value , expiry time   )
+   Increments by server the value for the given key by delta, defaulting to 1 */
+PHP_METHOD(Memcached, incrementByKey)
+{
+	php_memc_incdec_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::addServer(string hostname, int port , int weight )
+   Adds the given memcache server to the list */
+PHP_METHOD(Memcached, addServer)
+{
+	zend_string *host;
+	zend_long port, weight = 0;
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "Sa/|l" */
+	ZEND_PARSE_PARAMETERS_START(2, 3)
+	        Z_PARAM_STR(host)
+	        Z_PARAM_LONG(port)
+	        Z_PARAM_OPTIONAL
+	        Z_PARAM_LONG(weight)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	status = memcached_server_add_with_weight(intern->memc, ZSTR_VAL(host), port, weight);
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::addServers(array servers)
+   Adds the given memcache servers to the server list */
+PHP_METHOD(Memcached, addServers)
+{
+	zval *servers;
+	zval *entry;
+	zval *z_host, *z_port, *z_weight = NULL;
+	HashPosition	pos;
+	int   entry_size, i = 0;
+	memcached_server_st *list = NULL;
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "a/" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_ARRAY_EX(servers, 0, 1)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	ZEND_HASH_FOREACH_VAL (Z_ARRVAL_P(servers), entry) {
+		if (Z_TYPE_P(entry) != IS_ARRAY) {
+			php_error_docref(NULL, E_WARNING, "server list entry #%d is not an array", i+1);
+			i++;
+			continue;
+		}
+
+		entry_size = zend_hash_num_elements(Z_ARRVAL_P(entry));
+
+		if (entry_size > 1) {
+			zend_string *host;
+			zend_long port;
+			uint32_t weight;
+
+			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(entry), &pos);
+
+			/* Check that we have a host */
+			if ((z_host = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
+				php_error_docref(NULL, E_WARNING, "could not get server host for entry #%d", i+1);
+				i++;
+				continue;
+			}
+
+			/* Check that we have a port */
+			if (zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos) == FAILURE ||
+			    (z_port = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
+				php_error_docref(NULL, E_WARNING, "could not get server port for entry #%d", i+1);
+				i++;
+				continue;
+			}
+
+			host = zval_get_string(z_host);
+			port = zval_get_long(z_port);
+
+			weight = 0;
+			if (entry_size > 2) {
+				/* Try to get weight */
+				if (zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos) == FAILURE ||
+					(z_weight = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) == NULL) {
+					php_error_docref(NULL, E_WARNING, "could not get server weight for entry #%d", i+1);
+				}
+
+				weight = zval_get_long(z_weight);
+			}
+
+			list = memcached_server_list_append_with_weight(list, ZSTR_VAL(host), port, weight, &status);
+
+			zend_string_release(host);
+
+			if (s_memc_status_handle_result_code(intern, status) == SUCCESS) {
+				i++;
+				continue;
+			}
+		}
+		i++;
+		/* catch-all for all errors */
+		php_error_docref(NULL, E_WARNING, "could not add entry #%d to the server list", i + 1);
+	} ZEND_HASH_FOREACH_END();
+
+	status = memcached_server_push(intern->memc, list);
+	memcached_server_list_free(list);
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::getServerList()
+   Returns the list of the memcache servers in use */
+PHP_METHOD(Memcached, getServerList)
+{
+	memcached_server_function callbacks1;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	callbacks0 = s_server_cursor_list_servers_cb;
+	array_init(return_value);
+	memcached_server_cursor(intern->memc, callbacks, return_value, 1);
+}
+/* }}} */
+
+/* {{{ Memcached::getServerByKey(string server_key)
+   Returns the server identified by the given server key */
+PHP_METHOD(Memcached, getServerByKey)
+{
+	zend_string *server_key;
+	php_memcached_instance_st server_instance;
+	memcached_return error;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "S" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_STR(server_key)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	server_instance = memcached_server_by_key(intern->memc, ZSTR_VAL(server_key), ZSTR_LEN(server_key), &error);
+	if (server_instance == NULL) {
+		s_memc_status_handle_result_code(intern, error);
+		RETURN_FALSE;
+	}
+
+	array_init(return_value);
+	add_assoc_string(return_value, "host", (char*) memcached_server_name(server_instance));
+	add_assoc_long(return_value, "port", memcached_server_port(server_instance));
+	add_assoc_long(return_value, "weight", 0);
+}
+/* }}} */
+
+/* {{{ Memcached::resetServerList()
+   Reset the server list in use */
+PHP_METHOD(Memcached, resetServerList)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	memcached_servers_reset(intern->memc);
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::quit()
+   Close any open connections */
+PHP_METHOD(Memcached, quit)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	memcached_quit(intern->memc);
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::flushBuffers()
+   Flush and senf buffered commands */
+PHP_METHOD(Memcached, flushBuffers)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+	RETURN_BOOL(memcached_flush_buffers(intern->memc) == MEMCACHED_SUCCESS);
+}
+/* }}} */
+
+/* {{{ Memcached::getLastErrorMessage()
+   Returns the last error message that occurred */
+PHP_METHOD(Memcached, getLastErrorMessage)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_STRING(memcached_last_error_message(intern->memc));
+}
+/* }}} */
+
+/* {{{ Memcached::getLastErrorCode()
+   Returns the last error code that occurred */
+PHP_METHOD(Memcached, getLastErrorCode)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_LONG(memcached_last_error(intern->memc));
+}
+/* }}} */
+
+/* {{{ Memcached::getLastErrorErrno()
+   Returns the last error errno that occurred */
+PHP_METHOD(Memcached, getLastErrorErrno)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_LONG(memcached_last_error_errno(intern->memc));
+}
+/* }}} */
+
+/* {{{ Memcached::getLastDisconnectedServer()
+   Returns the last disconnected server
+   Was added in 0.34 according to libmemcached's Changelog */
+PHP_METHOD(Memcached, getLastDisconnectedServer)
+{
+	php_memcached_instance_st server_instance;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	server_instance = memcached_server_get_last_disconnect(intern->memc);
+	if (server_instance == NULL) {
+		RETURN_FALSE;
+	}
+
+	array_init(return_value);
+	add_assoc_string(return_value, "host", (char*) memcached_server_name(server_instance));
+	add_assoc_long(return_value, "port", memcached_server_port(server_instance));
+}
+/* }}} */
+
+
+
+static
+zend_bool s_long_value(const char *str, zend_long *value)
+{
+	char *end = (char *) str;
+
+	errno = 0;
+	*value = strtol(str, &end, 10);
+
+	if (errno || str == end || *end != '\0') {
+		return 0;
+	}
+	return 1;
+}
+
+static
+zend_bool s_double_value(const char *str, double *value)
+{
+	char *end = (char *) str;
+
+	errno = 0;
+	*value = strtod(str, &end);
+
+	if (errno || str == end || *end != '\0') {
+		return 0;
+	}
+	return 1;
+}
+
+static
+memcached_return s_stat_execute_cb (php_memcached_instance_st instance, const char *key, size_t key_length, const char *value, size_t value_length, void *context)
+{
+	zend_string *server_key;
+	zend_long long_val;
+	double d_val;
+	char *buffer;
+
+	zval *return_value = (zval *) context;
+	zval *server_values;
+
+	server_key = strpprintf(0, "%s:%d", memcached_server_name(instance), memcached_server_port(instance));
+	server_values = zend_hash_find(Z_ARRVAL_P(return_value), server_key);
+
+	if (!server_values) {
+		zval zv;
+		array_init(&zv);
+
+		server_values = zend_hash_add(Z_ARRVAL_P(return_value), server_key, &zv);
+	}
+
+	spprintf (&buffer, 0, "%.*s", (int)value_length, value);
+
+	/* Check type */
+	if (s_long_value (buffer, &long_val)) {
+		add_assoc_long(server_values, key, long_val);
+	}
+	else if (s_double_value (buffer, &d_val)) {
+		add_assoc_double(server_values, key, d_val);
+	}
+	else {
+		add_assoc_stringl_ex(server_values, key, key_length, (char*)value, value_length);
+	}
+	efree (buffer);
+	zend_string_release(server_key);
+
+	return MEMCACHED_SUCCESS;
+}
+
+/* {{{ Memcached::getStats()
+   Returns statistics for the memcache servers */
+PHP_METHOD(Memcached, getStats)
+{
+	memcached_return status;
+	char *args = NULL;
+	zend_string *args_string = NULL;
+	uint64_t orig_no_block, orig_protocol;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "|S!" */
+	ZEND_PARSE_PARAMETERS_START(0, 1)
+	        Z_PARAM_OPTIONAL
+	        Z_PARAM_STR_EX(args_string, 1, 0)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	if (args_string)
+		args = ZSTR_VAL(args_string);
+
+	/* stats hangs in nonblocking mode, turn off during the call. Only change the
+	 * value if needed, because libmemcached reconnects for this behavior_set. */
+	orig_no_block = memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+	orig_protocol = memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL);
+	if (orig_no_block && orig_protocol)
+		memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+
+	array_init(return_value);
+	status = memcached_stat_execute(intern->memc, args, s_stat_execute_cb, return_value);
+
+	if (orig_no_block && orig_protocol)
+		memcached_behavior_set(intern->memc, MEMCACHED_BEHAVIOR_NO_BLOCK, orig_no_block);
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		zval_ptr_dtor(return_value);
+		RETURN_FALSE;
+	}
+}
+/* }}} */
+
+/* {{{ Memcached::getVersion()
+   Returns the version of each memcached server in the pool */
+PHP_METHOD(Memcached, getVersion)
+{
+	memcached_return status;
+	memcached_server_function callbacks1;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	status = memcached_version(intern->memc);
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	callbacks0 = s_server_cursor_version_cb;
+
+	array_init(return_value);
+	status = memcached_server_cursor(intern->memc, callbacks, return_value, 1);
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		zval_dtor(return_value);
+		RETURN_FALSE;
+	}
+}
+/* }}} */
+
+/* {{{ Memcached::getAllKeys()
+	Returns the keys stored on all the servers */
+static
+memcached_return s_dump_keys_cb(const memcached_st *ptr, const char *key, size_t key_length, void *in_context)
+{
+	zval *return_value = (zval*) in_context;
+	add_next_index_stringl(return_value, key, key_length);
+
+	return MEMCACHED_SUCCESS;
+}
+
+PHP_METHOD(Memcached, getAllKeys)
+{
+	memcached_return rc;
+	memcached_dump_func callback1;
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	callback0 = s_dump_keys_cb;
+	MEMC_METHOD_FETCH_OBJECT;
+
+	array_init(return_value);
+
+	rc = memcached_dump(intern->memc, callback, return_value, 1);
+
+	/* Ignore two errors. libmemcached has a hardcoded loop of 200 slab
+	 * classes that matches memcached < 1.4.24, at which version the server
+	 * has only 63 slabs and throws an error when requesting the 64th slab.
+	 *
+	 * In multi-server some non-deterministic number of elements will be dropped.
+	 */
+	if (rc != MEMCACHED_CLIENT_ERROR && rc != MEMCACHED_SERVER_ERROR
+	    && s_memc_status_handle_result_code(intern, rc) == FAILURE) {
+		zval_dtor(return_value);
+		RETURN_FALSE;
+	}
+}
+/* }}} */
+
+/* {{{ Memcached::flush( int delay )
+   Flushes the data on all the servers */
+static PHP_METHOD(Memcached, flush)
+{
+	zend_long delay = 0;
+	memcached_return status;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "|l" */
+	ZEND_PARSE_PARAMETERS_START(0, 1)
+	        Z_PARAM_OPTIONAL
+	        Z_PARAM_LONG(delay)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+
+	status = memcached_flush(intern->memc, delay);
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ Memcached::getOption(int option)
+   Returns the value for the given option constant */
+static PHP_METHOD(Memcached, getOption)
+{
+	zend_long option;
+	uint64_t result;
+	memcached_behavior flag;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "l" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_LONG(option)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	switch (option) {
+		case MEMC_OPT_COMPRESSION_TYPE:
+			RETURN_LONG(memc_user_data->compression_type);
+
+		case MEMC_OPT_COMPRESSION_LEVEL:
+			RETURN_LONG(memc_user_data->compression_level);
+
+		case MEMC_OPT_COMPRESSION:
+			RETURN_BOOL(memc_user_data->compression_enabled);
+
+		case MEMC_OPT_ITEM_SIZE_LIMIT:
+			RETURN_LONG(memc_user_data->item_size_limit);
+
+		case MEMC_OPT_PREFIX_KEY:
+		{
+			memcached_return retval;
+			char *result;
+
+			result = memcached_callback_get(intern->memc, MEMCACHED_CALLBACK_PREFIX_KEY, &retval);
+			if (retval == MEMCACHED_SUCCESS && result) {
+				RETURN_STRING(result);
+			} else {
+				RETURN_EMPTY_STRING();
+			}
+		}
+
+		case MEMC_OPT_SERIALIZER:
+			RETURN_LONG((long)memc_user_data->serializer);
+			break;
+
+		case MEMC_OPT_USER_FLAGS:
+			RETURN_LONG(memc_user_data->set_udf_flags);
+			break;
+
+		case MEMC_OPT_STORE_RETRY_COUNT:
+			RETURN_LONG((long)memc_user_data->store_retry_count);
+			break;
+
+		case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
+		case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
+			if (memcached_server_count(intern->memc) == 0) {
+				php_error_docref(NULL, E_WARNING, "no servers defined");
+				return;
+			}
+
+		default:
+			/*
+			 * Assume that it's a libmemcached behavior option.
+			 */
+			flag = (memcached_behavior) option;
+			result = memcached_behavior_get(intern->memc, flag);
+			RETURN_LONG((long)result);
+	}
+}
+/* }}} */
+
+static
+int php_memc_set_option(php_memc_object_t *intern, long option, zval *value)
+{
+	zend_long lval;
+	memcached_return rc = MEMCACHED_FAILURE;
+	memcached_behavior flag;
+	php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
+
+	switch (option) {
+		case MEMC_OPT_COMPRESSION:
+			memc_user_data->compression_enabled = zval_get_long(value) ? 1 : 0;
+			break;
+
+		case MEMC_OPT_COMPRESSION_TYPE:
+			lval = zval_get_long(value);
+			if (lval == COMPRESSION_TYPE_FASTLZ ||
+#ifdef HAVE_ZSTD_H
+				lval == COMPRESSION_TYPE_ZSTD ||
+#endif
+				lval == COMPRESSION_TYPE_ZLIB) {
+				memc_user_data->compression_type = lval;
+			} else {
+				/* invalid compression type */
+				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
+				return 0;
+			}
+			break;
+
+		case MEMC_OPT_COMPRESSION_LEVEL:
+			lval = zval_get_long(value);
+			memc_user_data->compression_level = lval;
+			break;
+
+		case MEMC_OPT_ITEM_SIZE_LIMIT:
+			lval = zval_get_long(value);
+			if (lval < 0) {
+				php_error_docref(NULL, E_WARNING, "ITEM_SIZE_LIMIT must be >= 0");
+				return 0;
+			}
+			memc_user_data->item_size_limit = lval;
+			break;
+
+		case MEMC_OPT_PREFIX_KEY:
+		{
+			zend_string *str;
+			char *key;
+			str = zval_get_string(value);
+			if (ZSTR_LEN(str) == 0) {
+				key = NULL;
+			} else {
+				key = ZSTR_VAL(str);
+			}
+			if (memcached_callback_set(intern->memc, MEMCACHED_CALLBACK_PREFIX_KEY, key) == MEMCACHED_BAD_KEY_PROVIDED) {
+				zend_string_release(str);
+				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
+				php_error_docref(NULL, E_WARNING, "bad key provided");
+				return 0;
+			}
+			zend_string_release(str);
+		}
+			break;
+
+		case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
+			flag = (memcached_behavior) option;
+
+			lval = zval_get_long(value);
+			rc = memcached_behavior_set(intern->memc, flag, (uint64_t)lval);
+
+			if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
+				php_error_docref(NULL, E_WARNING, "error setting memcached option: %s", memcached_strerror (intern->memc, rc));
+				return 0;
+			}
+
+			/*
+			 * This is necessary because libmemcached does not reset hash/distribution
+			 * options on false case, like it does for MEMCACHED_BEHAVIOR_KETAMA
+			 * (non-weighted) case. We have to clean up ourselves.
+			 */
+			if (!lval) {
+				(void)memcached_behavior_set_key_hash(intern->memc, MEMCACHED_HASH_DEFAULT);
+				(void)memcached_behavior_set_distribution_hash(intern->memc, MEMCACHED_HASH_DEFAULT);
+				(void)memcached_behavior_set_distribution(intern->memc, MEMCACHED_DISTRIBUTION_MODULA);
+			}
+			break;
+
+		case MEMC_OPT_SERIALIZER:
+		{
+			lval = zval_get_long(value);
+			/* igbinary serializer */
+#ifdef HAVE_MEMCACHED_IGBINARY
+			if (lval == SERIALIZER_IGBINARY) {
+				memc_user_data->serializer = SERIALIZER_IGBINARY;
+			} else
+#endif
+#ifdef HAVE_JSON_API
+			if (lval == SERIALIZER_JSON) {
+				memc_user_data->serializer = SERIALIZER_JSON;
+			} else if (lval == SERIALIZER_JSON_ARRAY) {
+				memc_user_data->serializer = SERIALIZER_JSON_ARRAY;
+			} else
+#endif
+			/* msgpack serializer */
+#ifdef HAVE_MEMCACHED_MSGPACK
+			if (lval == SERIALIZER_MSGPACK) {
+				memc_user_data->serializer = SERIALIZER_MSGPACK;
+			} else
+#endif
+			/* php serializer */
+			if (lval == SERIALIZER_PHP) {
+				memc_user_data->serializer = SERIALIZER_PHP;
+			} else {
+				memc_user_data->serializer = SERIALIZER_PHP;
+				intern->rescode = MEMCACHED_INVALID_ARGUMENTS;
+				php_error_docref(NULL, E_WARNING, "invalid serializer provided");
+				return 0;
+			}
+			break;
+		}
+
+		case MEMC_OPT_USER_FLAGS:
+			lval = zval_get_long(value);
+
+			if (lval < 0) {
+				memc_user_data->set_udf_flags = -1;
+				return 1;
+			}
+
+			if (lval > MEMC_VAL_USER_FLAGS_MAX) {
+				php_error_docref(NULL, E_WARNING, "MEMC_OPT_USER_FLAGS must be < %u", MEMC_VAL_USER_FLAGS_MAX);
+				return 0;
+			}
+			memc_user_data->set_udf_flags = lval;
+			break;
+
+		case MEMC_OPT_STORE_RETRY_COUNT:
+			lval = zval_get_long(value);
+			memc_user_data->store_retry_count = lval;
+			break;
+
+		default:
+			/*
+			 * Assume that it's a libmemcached behavior option.
+			 */
+			if (option < 0) {
+				rc = MEMCACHED_INVALID_ARGUMENTS;
+			}
+			else {
+				flag = (memcached_behavior) option;
+				lval = zval_get_long(value);
+
+				if (flag < MEMCACHED_BEHAVIOR_MAX) {
+					// don't reset the option when the option value wasn't modified,
+					// while the libmemcached may shutdown all connections.
+					if (memcached_behavior_get(intern->memc, flag) == (uint64_t)lval) {
+						return 1;
+					}
+					rc = memcached_behavior_set(intern->memc, flag, (uint64_t)lval);
+				}
+				else {
+					rc = MEMCACHED_INVALID_ARGUMENTS;
+				}
+			}
+
+			if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
+				php_error_docref(NULL, E_WARNING, "error setting memcached option: %s", memcached_strerror (intern->memc, rc));
+				return 0;
+			}
+			break;
+	}
+	return 1;
+}
+
+static
+uint32_t *s_zval_to_uint32_array (zval *input, size_t *num_elements)
+{
+	zval *pzval;
+	uint32_t *retval;
+	size_t i = 0;
+
+	*num_elements = zend_hash_num_elements(Z_ARRVAL_P(input));
+
+	if (!*num_elements) {
+		return NULL;
+	}
+
+	retval = ecalloc(*num_elements, sizeof(uint32_t));
+
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), pzval) {
+		zend_long value = 0;
+
+		value = zval_get_long(pzval);
+		if (value < 0) {
+			php_error_docref(NULL, E_WARNING, "the map must contain positive integers");
+			efree (retval);
+			*num_elements = 0;
+			return NULL;
+		}
+		retval i = (uint32_t) value;
+		i++;
+	} ZEND_HASH_FOREACH_END();
+	return retval;
+}
+
+/* {{{ Memcached::setBucket(array host_map, array forward_map, integer replicas)
+   Sets the memcached virtual buckets */
+
+PHP_METHOD(Memcached, setBucket)
+{
+	zval *zserver_map;
+	zval *zforward_map = NULL;
+	zend_long replicas = 0;
+	zend_bool retval = 1;
+
+	uint32_t *server_map = NULL, *forward_map = NULL;
+	size_t server_map_len = 0, forward_map_len = 0;
+	memcached_return rc;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "aa!l" */
+	ZEND_PARSE_PARAMETERS_START(3, 3)
+	        Z_PARAM_ARRAY(zserver_map)
+	        Z_PARAM_ARRAY_EX(zforward_map, 1, 0)
+	        Z_PARAM_LONG(replicas)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	if (zend_hash_num_elements (Z_ARRVAL_P(zserver_map)) == 0) {
+		php_error_docref(NULL, E_WARNING, "server map cannot be empty");
+		RETURN_FALSE;
+	}
+
+	if (zforward_map && zend_hash_num_elements (Z_ARRVAL_P(zserver_map)) != zend_hash_num_elements (Z_ARRVAL_P(zforward_map))) {
+		php_error_docref(NULL, E_WARNING, "forward_map length must match the server_map length");
+		RETURN_FALSE;
+	}
+
+	if (replicas < 0) {
+		php_error_docref(NULL, E_WARNING, "replicas must be larger than zero");
+		RETURN_FALSE;
+	}
+
+	server_map = s_zval_to_uint32_array (zserver_map, &server_map_len);
+
+	if (!server_map) {
+		RETURN_FALSE;
+	}
+
+	if (zforward_map) {
+		forward_map = s_zval_to_uint32_array (zforward_map, &forward_map_len);
+
+		if (!forward_map) {
+			efree (server_map);
+			RETURN_FALSE;
+		}
+	}
+
+	rc = memcached_bucket_set (intern->memc, server_map, forward_map, (uint32_t) server_map_len, replicas);
+
+	if (s_memc_status_handle_result_code(intern, rc) == FAILURE) {
+		retval = 0;
+	}
+
+	efree(server_map);
+
+	if (forward_map) {
+		efree(forward_map);
+	}
+	RETURN_BOOL(retval);
+}
+/* }}} */
+
+/* {{{ Memcached::setOptions(array options)
+   Sets the value for the given option constant */
+static PHP_METHOD(Memcached, setOptions)
+{
+	zval *options;
+	zend_bool ok = 1;
+	zend_string *key;
+	zend_ulong key_index;
+	zval *value;
+
+	MEMC_METHOD_INIT_VARS;
+
+	/* "a" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_ARRAY(options)
+	ZEND_PARSE_PARAMETERS_END();
+
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(options), key_index, key, value) {
+		if (key) {
+			php_error_docref(NULL, E_WARNING, "invalid configuration option");
+			ok = 0;
+		} else {
+			if (!php_memc_set_option(intern, (long) key_index, value)) {
+				ok = 0;
+			}
+		}
+	} ZEND_HASH_FOREACH_END();
+
+	RETURN_BOOL(ok);
+}
+/* }}} */
+
+/* {{{ Memcached::setOption(int option, mixed value)
+   Sets the value for the given option constant */
+static PHP_METHOD(Memcached, setOption)
+{
+	zend_long option;
+	zval *value;
+	MEMC_METHOD_INIT_VARS;
+
+	/* "lz/" */
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+	        Z_PARAM_LONG(option)
+	        Z_PARAM_ZVAL_EX(value, 0, 1)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_BOOL(php_memc_set_option(intern, option, value));
+}
+/* }}} */
+
+#ifdef HAVE_MEMCACHED_SASL
+/* {{{ Memcached::setSaslAuthData(string user, string pass)
+   Sets sasl credentials */
+static PHP_METHOD(Memcached, setSaslAuthData)
+{
+	MEMC_METHOD_INIT_VARS;
+	memcached_return status;
+	zend_string *user, *pass;
+
+	/* "SS/" */
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+	        Z_PARAM_STR(user)
+	        Z_PARAM_STR(pass)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!php_memc_init_sasl_if_needed()) {
+		RETURN_FALSE;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	if (!memcached_behavior_get(intern->memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) {
+		php_error_docref(NULL, E_WARNING, "SASL is only supported with binary protocol");
+		RETURN_FALSE;
+	}
+	memc_user_data->has_sasl_data = 1;
+	status = memcached_set_sasl_auth_data(intern->memc, ZSTR_VAL(user), ZSTR_VAL(pass));
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+	RETURN_TRUE;
+}
+/* }}} */
+#endif /* HAVE_MEMCACHED_SASL */
+
+#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
+/* {{{ Memcached::setEncodingKey(string key)
+   Sets AES encryption key (libmemcached 1.0.6 and higher) */
+static PHP_METHOD(Memcached, setEncodingKey)
+{
+	MEMC_METHOD_INIT_VARS;
+	memcached_return status;
+	zend_string *key;
+
+	/* "S" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_STR(key)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	// libmemcached < 1.0.18 cannot handle a change of encoding key. Warn about this and return false.
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX < 0x01000018
+	if (memc_user_data->encoding_enabled) {
+		php_error_docref(NULL, E_WARNING, "libmemcached versions less than 1.0.18 cannot change encoding key");
+		RETURN_FALSE;
+	}
+#endif
+
+	status = memcached_set_encoding_key(intern->memc, ZSTR_VAL(key), ZSTR_LEN(key));
+
+	if (s_memc_status_handle_result_code(intern, status) == FAILURE) {
+		RETURN_FALSE;
+	}
+
+	memc_user_data->encoding_enabled = 1;
+	RETURN_TRUE;
+}
+/* }}} */
+#endif /* HAVE_MEMCACHED_SET_ENCODING_KEY */
+
+/* {{{ Memcached::getResultCode()
+   Returns the result code from the last operation */
+static PHP_METHOD(Memcached, getResultCode)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_LONG(intern->rescode);
+}
+/* }}} */
+
+/* {{{ Memcached::getResultMessage()
+   Returns the result message from the last operation */
+static PHP_METHOD(Memcached, getResultMessage)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	switch (intern->rescode) {
+		case MEMC_RES_PAYLOAD_FAILURE:
+			RETURN_STRING("PAYLOAD FAILURE");
+			break;
+
+		case MEMCACHED_ERRNO:
+		case MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE:
+		case MEMCACHED_UNKNOWN_READ_FAILURE:
+			if (intern->memc_errno) {
+				zend_string *str = strpprintf(0, "%s: %s",
+						memcached_strerror(intern->memc, (memcached_return)intern->rescode), strerror(intern->memc_errno));
+				RETURN_STR(str);
+			}
+			/* Fall through */
+		default:
+			RETURN_STRING(memcached_strerror(intern->memc, (memcached_return)intern->rescode));
+			break;
+	}
+
+}
+/* }}} */
+
+/* {{{ Memcached::isPersistent()
+   Returns the true if instance uses a persistent connection */
+static PHP_METHOD(Memcached, isPersistent)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_BOOL(memc_user_data->is_persistent);
+}
+/* }}} */
+
+/* {{{ Memcached::isPristine()
+   Returns the true if instance is recently created */
+static PHP_METHOD(Memcached, isPristine)
+{
+	MEMC_METHOD_INIT_VARS;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	MEMC_METHOD_FETCH_OBJECT;
+
+	RETURN_BOOL(intern->is_pristine);
+}
+/* }}} */
+
+/* {{{ bool Memcached::checkKey(string key)
+   Checks if a key is valid */
+PHP_METHOD(Memcached, checkKey)
+{
+	zend_string *key;
+	MEMC_METHOD_INIT_VARS;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_STR(key)
+	ZEND_PARSE_PARAMETERS_END();
+
+	MEMC_METHOD_FETCH_OBJECT;
+	s_memc_set_status(intern, MEMCACHED_SUCCESS, 0);
+	MEMC_CHECK_KEY(intern, key);
+	RETURN_TRUE;
+}
+/* }}} */
+
+/****************************************
+  Internal support code
+****************************************/
+
+/* {{{ constructor/destructor */
+static
+void php_memc_destroy(memcached_st *memc, php_memc_user_data_t *memc_user_data)
+{
+#ifdef HAVE_MEMCACHED_SASL
+	if (memc_user_data->has_sasl_data) {
+		memcached_destroy_sasl_auth_data(memc);
+	}
+#endif
+
+	memcached_free(memc);
+	pefree(memc_user_data, memc_user_data->is_persistent);
+}
+
+static
+void php_memc_object_free_storage(zend_object *object)
+{
+	php_memc_object_t *intern = php_memc_fetch_object(object);
+
+	if (intern->memc) {
+		php_memc_user_data_t *memc_user_data = memcached_get_user_data(intern->memc);
+
+		if (!memc_user_data->is_persistent) {
+			php_memc_destroy(intern->memc, memc_user_data);
+		}
+	}
+
+	intern->memc = NULL;
+	zend_object_std_dtor(&intern->zo);
+}
+
+static
+zend_object *php_memc_object_new(zend_class_entry *ce)
+{
+	php_memc_object_t *intern = ecalloc(1, sizeof(php_memc_object_t) + zend_object_properties_size(ce));
+
+	zend_object_std_init(&intern->zo, ce);
+	object_properties_init(&intern->zo, ce);
+
+	intern->zo.handlers = &memcached_object_handlers;
+	return &intern->zo;
+}
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+static
+void php_memc_server_free_storage(zend_object *object)
+{
+	php_memc_server_t *intern = php_memc_server_fetch_object(object);
+
+	php_memc_proto_handler_destroy(&intern->handler);
+	zend_object_std_dtor(&intern->zo);
+}
+
+zend_object *php_memc_server_new(zend_class_entry *ce)
+{
+	php_memc_server_t *intern;
+
+	intern = ecalloc(1, sizeof(php_memc_server_t) + zend_object_properties_size(ce));
+
+	zend_object_std_init(&intern->zo, ce);
+	object_properties_init(&intern->zo, ce);
+
+	intern->zo.handlers = &memcached_server_object_handlers;
+	intern->handler = php_memc_proto_handler_new();
+
+	return &intern->zo;
+}
+#endif
+
+ZEND_RSRC_DTOR_FUNC(php_memc_dtor)
+{
+	if (res->ptr) {
+		memcached_st *memc = (memcached_st *) res->ptr;
+		php_memc_destroy(memc, memcached_get_user_data(memc));
+		res->ptr = NULL;
+	}
+}
+
+/* }}} */
+
+/* {{{ internal API functions */
+static
+memcached_return s_server_cursor_list_servers_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context)
+{
+	zval array;
+	zval *return_value = (zval *) in_context;
+
+	array_init(&array);
+	add_assoc_string(&array, "host", (char*)memcached_server_name(instance));
+	add_assoc_long(&array,   "port", memcached_server_port(instance));
+	add_assoc_string(&array, "type", (char*)memcached_server_type(instance));
+	/*
+	 * API does not allow to get at this field.
+	add_assoc_long(array, "weight", instance->weight);
+	*/
+
+	add_next_index_zval(return_value, &array);
+	return MEMCACHED_SUCCESS;
+}
+
+static
+memcached_return s_server_cursor_version_cb(const memcached_st *ptr, php_memcached_instance_st instance, void *in_context)
+{
+	zend_string *address, *version;
+	zval rv, *return_value = (zval *)in_context;
+
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000009
+	version = strpprintf(0, "%d.%d.%d",
+				memcached_server_major_version(instance),
+				memcached_server_minor_version(instance),
+				memcached_server_micro_version(instance));
+#else
+	version = strpprintf(0, "%d.%d.%d",
+				instance->major_version,
+				instance->minor_version,
+				instance->micro_version);
+#endif
+
+	address = strpprintf(0, "%s:%d", memcached_server_name(instance), memcached_server_port(instance));
+
+	ZVAL_STR(&rv, version);
+	zend_hash_add(Z_ARRVAL_P(return_value), address, &rv);
+
+	zend_string_release(address);
+
+	return MEMCACHED_SUCCESS;
+}
+
+
+static
+zend_string *s_decompress_value (const char *payload, size_t payload_len, uint32_t flags)
+{
+	zend_string *buffer;
+
+	uint32_t stored_length;
+	unsigned long length;
+	zend_bool decompress_status = 0;
+	zend_bool is_fastlz = 0, is_zlib = 0, is_zstd = 0;
+
+	if (payload_len < sizeof (uint32_t)) {
+		return NULL;
+	}
+
+	is_fastlz = MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSION_FASTLZ);
+	is_zstd   = MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSION_ZSTD);
+	is_zlib   = MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSION_ZLIB);
+
+#ifndef HAVE_ZSTD_H
+	if (is_zstd) {
+		php_error_docref(NULL, E_WARNING, "could not decompress value: value was compressed with zstd but zstd support has not been compiled in");
+		return NULL;
+	}
+#endif
+
+	if (!is_fastlz && !is_zlib && !is_zstd) {
+		php_error_docref(NULL, E_WARNING, "could not decompress value: unrecognised compression type");
+		return NULL;
+	}
+
+	memcpy(&stored_length, payload, sizeof (uint32_t));
+
+	payload     += sizeof (uint32_t);
+	payload_len -= sizeof (uint32_t);
+
+	buffer = zend_string_alloc (stored_length, 0);
+
+#ifdef HAVE_ZSTD_H
+	if (is_zstd) {
+		length = ZSTD_getFrameContentSize(payload, payload_len);
+		if (length == ZSTD_CONTENTSIZE_ERROR) {
+			php_error_docref(NULL, E_WARNING, "value was not compressed by zstd");
+			zend_string_release (buffer);
+			return NULL;
+		} else if (length == ZSTD_CONTENTSIZE_UNKNOWN) {
+			php_error_docref(NULL, E_WARNING, "zstd streaming decompression not supported");
+			zend_string_release (buffer);
+			return NULL;
+		}
+		decompress_status = !ZSTD_isError(ZSTD_decompress(&buffer->val, buffer->len, payload, payload_len));
+
+	}
+	else
+#endif
+	if (is_fastlz) {
+		decompress_status = ((length = fastlz_decompress(payload, payload_len, &buffer->val, buffer->len)) > 0);
+	}
+	else if (is_zlib) {
+		unsigned long ds = buffer->len;
+
+		decompress_status = (uncompress((Bytef *) buffer->val, &ds, (Bytef *)payload, payload_len) == Z_OK);
+		buffer->len = ds;
+	}
+
+	ZSTR_VAL(buffer)stored_length = '\0';
+
+	if (!decompress_status) {
+		php_error_docref(NULL, E_WARNING, "could not decompress value");
+		zend_string_release (buffer);
+		return NULL;
+	}
+
+	zend_string_forget_hash_val(buffer);
+	return buffer;
+}
+
+static
+zend_bool s_unserialize_value (memcached_st *memc, int val_type, zend_string *payload, zval *return_value)
+{
+	switch (val_type) {
+		case MEMC_VAL_IS_SERIALIZED:
+		{
+			php_unserialize_data_t var_hash;
+			const unsigned char *p, *max;
+
+			p   = (const unsigned char *) ZSTR_VAL(payload);
+			max = p + ZSTR_LEN(payload);
+
+			PHP_VAR_UNSERIALIZE_INIT(var_hash);
+			if (!php_var_unserialize(return_value, &p, max, &var_hash)) {
+				zval_ptr_dtor(return_value);
+				ZVAL_FALSE(return_value);
+				PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
+				php_error_docref(NULL, E_WARNING, "could not unserialize value");
+				return 0;
+			}
+			PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
+		}
+			break;
+
+		case MEMC_VAL_IS_IGBINARY:
+#ifdef HAVE_MEMCACHED_IGBINARY
+			if (igbinary_unserialize((uint8_t *) ZSTR_VAL(payload), ZSTR_LEN(payload), return_value)) {
+				ZVAL_FALSE(return_value);
+				php_error_docref(NULL, E_WARNING, "could not unserialize value with igbinary");
+				return 0;
+			}
+#else
+			ZVAL_FALSE(return_value);
+			php_error_docref(NULL, E_WARNING, "could not unserialize value, no igbinary support");
+			return 0;
+#endif
+			break;
+
+		case MEMC_VAL_IS_JSON:
+#ifdef HAVE_JSON_API
+		{
+			php_memc_user_data_t *memc_user_data = memcached_get_user_data(memc);
+			php_json_decode(return_value, ZSTR_VAL(payload), ZSTR_LEN(payload), (memc_user_data->serializer == SERIALIZER_JSON_ARRAY), PHP_JSON_PARSER_DEFAULT_DEPTH);
+		}
+#else
+			ZVAL_FALSE(return_value);
+			php_error_docref(NULL, E_WARNING, "could not unserialize value, no json support");
+			return 0;
+#endif
+			break;
+
+		case MEMC_VAL_IS_MSGPACK:
+#ifdef HAVE_MEMCACHED_MSGPACK
+			php_msgpack_unserialize(return_value, ZSTR_VAL(payload), ZSTR_LEN(payload));
+#else
+			ZVAL_FALSE(return_value);
+			php_error_docref(NULL, E_WARNING, "could not unserialize value, no msgpack support");
+			return 0;
+#endif
+ 			break;
+	}
+	return 1;
+}
+
+static
+zend_bool s_memcached_result_to_zval(memcached_st *memc, memcached_result_st *result, zval *return_value)
+{
+	zend_string *data;
+	const char *payload;
+	size_t payload_len;
+	uint32_t flags;
+	zend_bool retval = 1;
+
+	payload     = memcached_result_value(result);
+	payload_len = memcached_result_length(result);
+	flags       = memcached_result_flags(result);
+
+	if (!payload && payload_len > 0) {
+		php_error_docref(NULL, E_WARNING, "Could not handle non-existing value of length %zu", payload_len);
+		return 0;
+	}
+
+	if (MEMC_VAL_HAS_FLAG(flags, MEMC_VAL_COMPRESSED)) {
+		data = s_decompress_value (payload, payload_len, flags);
+		if (!data) {
+			return 0;
+		}
+	} else {
+		data = zend_string_init(payload, payload_len, 0);
+	}
+
+	switch (MEMC_VAL_GET_TYPE(flags)) {
+
+		case MEMC_VAL_IS_STRING:
+			ZVAL_STR_COPY(return_value, data);
+			break;
+
+		case MEMC_VAL_IS_LONG:
+			ZVAL_LONG(return_value, strtol(ZSTR_VAL(data), NULL, 10));
+			break;
+
+		case MEMC_VAL_IS_DOUBLE:
+		{
+			if (zend_string_equals_literal(data, "Infinity")) {
+				ZVAL_DOUBLE(return_value, php_get_inf());
+			}
+			else if (zend_string_equals_literal(data, "-Infinity")) {
+				ZVAL_DOUBLE(return_value, -php_get_inf());
+			}
+			else if (zend_string_equals_literal(data, "NaN")) {
+				ZVAL_DOUBLE(return_value, php_get_nan());
+			}
+			else {
+				ZVAL_DOUBLE(return_value, zend_strtod(ZSTR_VAL(data), NULL));
+			}
+		}
+			break;
+
+		case MEMC_VAL_IS_BOOL:
+			ZVAL_BOOL(return_value, payload_len > 0 && ZSTR_VAL(data)0 == '1');
+			break;
+
+		case MEMC_VAL_IS_SERIALIZED:
+		case MEMC_VAL_IS_IGBINARY:
+		case MEMC_VAL_IS_JSON:
+		case MEMC_VAL_IS_MSGPACK:
+			retval = s_unserialize_value (memc, MEMC_VAL_GET_TYPE(flags), data, return_value);
+			break;
+
+		default:
+			php_error_docref(NULL, E_WARNING, "unknown payload type");
+			retval = 0;
+			break;
+	}
+	zend_string_release(data);
+
+	return retval;
+}
+
+
+PHP_MEMCACHED_API
+zend_class_entry *php_memc_get_ce(void)
+{
+	return memcached_ce;
+}
+
+PHP_MEMCACHED_API
+zend_class_entry *php_memc_get_exception(void)
+{
+	return memcached_exception_ce;
+}
+
+PHP_MEMCACHED_API
+zend_class_entry *php_memc_get_exception_base(int root)
+{
+	if (!root) {
+		if (!spl_ce_RuntimeException) {
+			zend_class_entry *pce;
+			zval *pce_z;
+
+			if ((pce_z = zend_hash_str_find(CG(class_table),
+							"runtimeexception",
+							sizeof("RuntimeException") - 1)) != NULL) {
+				pce = Z_CE_P(pce_z);
+				spl_ce_RuntimeException = pce;
+				return pce;
+			}
+		} else {
+			return spl_ce_RuntimeException;
+		}
+	}
+
+	return zend_exception_get_default();
+}
+
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+
+static
+void s_destroy_cb (zend_fcall_info *fci)
+{
+	if (fci->size > 0) {
+		zval_ptr_dtor(&fci->function_name);
+		if (fci->object) {
+			OBJ_RELEASE(fci->object);
+		}
+	}
+}
+
+static
+PHP_METHOD(MemcachedServer, run)
+{
+	int i;
+	zend_bool rc;
+	zend_string *address;
+
+	php_memc_server_t *intern;
+	intern = Z_MEMC_SERVER_P(getThis());
+
+	/* "S" */
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+	        Z_PARAM_STR(address)
+	ZEND_PARSE_PARAMETERS_END();
+
+	rc = php_memc_proto_handler_run(intern->handler, address);
+
+	for (i = MEMC_SERVER_ON_MIN + 1; i < MEMC_SERVER_ON_MAX; i++) {
+		s_destroy_cb(&MEMC_SERVER_G(callbacks) i.fci);
+	}
+
+	RETURN_BOOL(rc);
+}
+
+static
+PHP_METHOD(MemcachedServer, on)
+{
+	zend_long event;
+	zend_fcall_info fci;
+	zend_fcall_info_cache fci_cache;
+	zend_bool rc = 0;
+
+	/* "lf!" */
+	ZEND_PARSE_PARAMETERS_START(2, 2)
+	        Z_PARAM_LONG(event)
+	        Z_PARAM_FUNC_EX(fci, fci_cache, 1, 0)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (event <= MEMC_SERVER_ON_MIN || event >= MEMC_SERVER_ON_MAX) {
+		RETURN_FALSE;
+	}
+
+	if (fci.size > 0) {
+		s_destroy_cb (&MEMC_SERVER_G(callbacks) event.fci);
+
+		MEMC_SERVER_G(callbacks) event.fci       = fci;
+		MEMC_SERVER_G(callbacks) event.fci_cache = fci_cache;
+
+		Z_TRY_ADDREF(fci.function_name);
+		if (fci.object) {
+			GC_ADDREF(fci.object);
+		}
+	}
+	RETURN_BOOL(rc);
+}
+
+#endif
+
+#if PHP_VERSION_ID < 80000
+#include "php_memcached_legacy_arginfo.h"
+#else
+#include "zend_attributes.h"
+#include "php_memcached_arginfo.h"
+#endif
+
+/* {{{ memcached_module_entry
+ */
+
+#if ZEND_MODULE_API_NO >= 20050922
+static const zend_module_dep memcached_deps = {
+#ifdef HAVE_MEMCACHED_SESSION
+	ZEND_MOD_REQUIRED("session")
+#endif
+#ifdef HAVE_MEMCACHED_IGBINARY
+	ZEND_MOD_REQUIRED("igbinary")
+#endif
+#ifdef HAVE_MEMCACHED_MSGPACK
+	ZEND_MOD_REQUIRED("msgpack")
+#endif
+	ZEND_MOD_REQUIRED("spl")
+	ZEND_MOD_END
+};
+#endif
+
+static
+PHP_GINIT_FUNCTION(php_memcached)
+{
+#ifdef HAVE_MEMCACHED_SESSION
+	php_memcached_globals->session.lock_enabled = 0;
+	php_memcached_globals->session.lock_wait_max = 150;
+	php_memcached_globals->session.lock_wait_min = 150;
+	php_memcached_globals->session.lock_retries = 200;
+	php_memcached_globals->session.lock_expiration = 30;
+	php_memcached_globals->session.binary_protocol_enabled = 1;
+	php_memcached_globals->session.consistent_hash_enabled = 1;
+	php_memcached_globals->session.consistent_hash_type = MEMCACHED_BEHAVIOR_KETAMA;
+	php_memcached_globals->session.consistent_hash_name = NULL;
+	php_memcached_globals->session.number_of_replicas = 0;
+	php_memcached_globals->session.server_failure_limit = 1;
+	php_memcached_globals->session.randomize_replica_read_enabled = 1;
+	php_memcached_globals->session.remove_failed_servers_enabled = 1;
+	php_memcached_globals->session.connect_timeout = 1000;
+	php_memcached_globals->session.prefix = NULL;
+	php_memcached_globals->session.persistent_enabled = 0;
+	php_memcached_globals->session.sasl_username = NULL;
+	php_memcached_globals->session.sasl_password = NULL;
+#endif
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+	memset(&php_memcached_globals->server, 0, sizeof(php_memcached_globals->server));
+#endif
+
+	php_memcached_globals->memc.serializer_name = NULL;
+	php_memcached_globals->memc.serializer_type = SERIALIZER_DEFAULT;
+	php_memcached_globals->memc.compression_name = NULL;
+	php_memcached_globals->memc.compression_threshold = 2000;
+	php_memcached_globals->memc.compression_type = COMPRESSION_TYPE_FASTLZ;
+	php_memcached_globals->memc.compression_factor = 1.30;
+	php_memcached_globals->memc.compression_level = 6;
+	php_memcached_globals->memc.store_retry_count = 2;
+	php_memcached_globals->memc.item_size_limit = 0;
+
+	php_memcached_globals->memc.sasl_initialised = 0;
+	php_memcached_globals->no_effect = 0;
+
+	/* Defaults for certain options */
+	php_memcached_globals->memc.default_behavior.consistent_hash_enabled = 0;
+	php_memcached_globals->memc.default_behavior.binary_protocol_enabled = 0;
+	php_memcached_globals->memc.default_behavior.connect_timeout         = 0;
+}
+
+zend_module_entry memcached_module_entry = {
+	STANDARD_MODULE_HEADER_EX, NULL,
+	memcached_deps,
+	"memcached",
+	NULL,
+	PHP_MINIT(memcached),
+	PHP_MSHUTDOWN(memcached),
+	NULL,
+	NULL,
+	PHP_MINFO(memcached),
+	PHP_MEMCACHED_VERSION,
+	PHP_MODULE_GLOBALS(php_memcached),
+	PHP_GINIT(php_memcached),
+	NULL,
+	NULL,
+	STANDARD_MODULE_PROPERTIES_EX
+};
+/* }}} */
+
+
+/* {{{ php_memc_register_constants */
+static void php_memc_register_constants(INIT_FUNC_ARGS)
+{
+	#define REGISTER_MEMC_CLASS_CONST_LONG(name, value) zend_declare_class_constant_long(php_memc_get_ce() , ZEND_STRS( #name ) - 1, value)
+	#define REGISTER_MEMC_CLASS_CONST_BOOL(name, value) zend_declare_class_constant_bool(php_memc_get_ce() , ZEND_STRS( #name ) - 1, value)
+	#define REGISTER_MEMC_CLASS_CONST_NULL(name) zend_declare_class_constant_null(php_memc_get_ce() , ZEND_STRS( #name ) - 1)
+
+	/*
+	 * Class options
+	 */
+	REGISTER_MEMC_CLASS_CONST_LONG(LIBMEMCACHED_VERSION_HEX, LIBMEMCACHED_VERSION_HEX);
+
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_COMPRESSION, MEMC_OPT_COMPRESSION);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_COMPRESSION_TYPE, MEMC_OPT_COMPRESSION_TYPE);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_COMPRESSION_LEVEL, MEMC_OPT_COMPRESSION_LEVEL);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_PREFIX_KEY,  MEMC_OPT_PREFIX_KEY);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERIALIZER,  MEMC_OPT_SERIALIZER);
+
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_USER_FLAGS,  MEMC_OPT_USER_FLAGS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_STORE_RETRY_COUNT,  MEMC_OPT_STORE_RETRY_COUNT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_ITEM_SIZE_LIMIT, MEMC_OPT_ITEM_SIZE_LIMIT);
+
+	/*
+	 * Indicate whether igbinary serializer is available
+	 */
+#ifdef HAVE_MEMCACHED_IGBINARY
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_IGBINARY, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_IGBINARY, 0);
+#endif
+
+	/*
+	 * Indicate whether zstd compression is available
+	 */
+#ifdef HAVE_ZSTD_H
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ZSTD, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ZSTD, 0);
+#endif
+
+	/*
+	 * Indicate whether json serializer is available
+	 */
+#ifdef HAVE_JSON_API
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_JSON, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_JSON, 0);
+#endif
+
+	/*
+	 * Indicate whether msgpack serializer is available
+	 */
+#ifdef HAVE_MEMCACHED_MSGPACK
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_MSGPACK, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_MSGPACK, 0);
+#endif
+
+	/*
+	 * Indicate whether set_encoding_key is available
+	 */
+#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ENCODING, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_ENCODING, 0);
+#endif
+
+#ifdef HAVE_MEMCACHED_SESSION
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SESSION, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SESSION, 0);
+#endif
+
+#ifdef HAVE_MEMCACHED_SASL
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SASL, 1);
+#else
+	REGISTER_MEMC_CLASS_CONST_BOOL(HAVE_SASL, 0);
+#endif
+
+	/*
+	 * libmemcached behavior options
+	 */
+
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_HASH, MEMCACHED_BEHAVIOR_HASH);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_DEFAULT, MEMCACHED_HASH_DEFAULT);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_MD5, MEMCACHED_HASH_MD5);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_CRC, MEMCACHED_HASH_CRC);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1_64, MEMCACHED_HASH_FNV1_64);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1A_64, MEMCACHED_HASH_FNV1A_64);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1_32, MEMCACHED_HASH_FNV1_32);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_FNV1A_32, MEMCACHED_HASH_FNV1A_32);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_HSIEH, MEMCACHED_HASH_HSIEH);
+	REGISTER_MEMC_CLASS_CONST_LONG(HASH_MURMUR, MEMCACHED_HASH_MURMUR);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_DISTRIBUTION, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_MODULA, MEMCACHED_DISTRIBUTION_MODULA);
+	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_CONSISTENT, MEMCACHED_DISTRIBUTION_CONSISTENT);
+	REGISTER_MEMC_CLASS_CONST_LONG(DISTRIBUTION_VIRTUAL_BUCKET, MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_LIBKETAMA_COMPATIBLE, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_LIBKETAMA_HASH, MEMCACHED_BEHAVIOR_KETAMA_HASH);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_TCP_KEEPALIVE, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_BUFFER_WRITES, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_BINARY_PROTOCOL, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NO_BLOCK, MEMCACHED_BEHAVIOR_NO_BLOCK);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_TCP_NODELAY, MEMCACHED_BEHAVIOR_TCP_NODELAY);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SOCKET_SEND_SIZE, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SOCKET_RECV_SIZE, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_CONNECT_TIMEOUT, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RETRY_TIMEOUT, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT);
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000003
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_DEAD_TIMEOUT, MEMCACHED_BEHAVIOR_DEAD_TIMEOUT);
+#endif
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SEND_TIMEOUT, MEMCACHED_BEHAVIOR_SND_TIMEOUT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RECV_TIMEOUT, MEMCACHED_BEHAVIOR_RCV_TIMEOUT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_POLL_TIMEOUT, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_CACHE_LOOKUPS, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERVER_FAILURE_LIMIT, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_AUTO_EJECT_HOSTS, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_HASH_WITH_PREFIX_KEY, MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NOREPLY, MEMCACHED_BEHAVIOR_NOREPLY);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SORT_HOSTS, MEMCACHED_BEHAVIOR_SORT_HOSTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_VERIFY_KEY, MEMCACHED_BEHAVIOR_VERIFY_KEY);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_USE_UDP, MEMCACHED_BEHAVIOR_USE_UDP);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_NUMBER_OF_REPLICAS, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_RANDOMIZE_REPLICA_READ, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_REMOVE_FAILED_SERVERS, MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS);
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000018
+	REGISTER_MEMC_CLASS_CONST_LONG(OPT_SERVER_TIMEOUT_LIMIT, MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT);
+#endif
+
+	/*
+	 * libmemcached result codes
+	 */
+
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SUCCESS,                   MEMCACHED_SUCCESS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_FAILURE,                   MEMCACHED_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_HOST_LOOKUP_FAILURE,       MEMCACHED_HOST_LOOKUP_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_FAILURE,        MEMCACHED_CONNECTION_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_BIND_FAILURE,   MEMCACHED_CONNECTION_BIND_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_WRITE_FAILURE,             MEMCACHED_WRITE_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_READ_FAILURE,              MEMCACHED_READ_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_UNKNOWN_READ_FAILURE,      MEMCACHED_UNKNOWN_READ_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_PROTOCOL_ERROR,            MEMCACHED_PROTOCOL_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_CLIENT_ERROR,              MEMCACHED_CLIENT_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_ERROR,              MEMCACHED_SERVER_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_DATA_EXISTS,               MEMCACHED_DATA_EXISTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_DATA_DOES_NOT_EXIST,       MEMCACHED_DATA_DOES_NOT_EXIST);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOTSTORED,                 MEMCACHED_NOTSTORED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_STORED,                    MEMCACHED_STORED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOTFOUND,                  MEMCACHED_NOTFOUND);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARTIAL_READ,              MEMCACHED_PARTIAL_READ);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SOME_ERRORS,               MEMCACHED_SOME_ERRORS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_NO_SERVERS,                MEMCACHED_NO_SERVERS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_END,                       MEMCACHED_END);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_DELETED,                   MEMCACHED_DELETED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_VALUE,                     MEMCACHED_VALUE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_STAT,                      MEMCACHED_STAT);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_ITEM,                      MEMCACHED_ITEM);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_ERRNO,                     MEMCACHED_ERRNO);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_FAIL_UNIX_SOCKET,          MEMCACHED_FAIL_UNIX_SOCKET);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_NOT_SUPPORTED,             MEMCACHED_NOT_SUPPORTED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_NO_KEY_PROVIDED,           MEMCACHED_NO_KEY_PROVIDED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_FETCH_NOTFINISHED,         MEMCACHED_FETCH_NOTFINISHED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_TIMEOUT,                   MEMCACHED_TIMEOUT);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_BUFFERED,                  MEMCACHED_BUFFERED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_BAD_KEY_PROVIDED,          MEMCACHED_BAD_KEY_PROVIDED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_INVALID_HOST_PROTOCOL,     MEMCACHED_INVALID_HOST_PROTOCOL);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_MARKED_DEAD,        MEMCACHED_SERVER_MARKED_DEAD);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_UNKNOWN_STAT_KEY,          MEMCACHED_UNKNOWN_STAT_KEY);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_INVALID_ARGUMENTS,         MEMCACHED_INVALID_ARGUMENTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARSE_ERROR,               MEMCACHED_PARSE_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_PARSE_USER_ERROR,          MEMCACHED_PARSE_USER_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_DEPRECATED,                MEMCACHED_DEPRECATED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_IN_PROGRESS,               MEMCACHED_IN_PROGRESS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_MAXIMUM_RETURN,            MEMCACHED_MAXIMUM_RETURN);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_MEMORY_ALLOCATION_FAILURE, MEMCACHED_MEMORY_ALLOCATION_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_CONNECTION_SOCKET_CREATE_FAILURE, MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE);
+
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_E2BIG,                            MEMCACHED_E2BIG);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_KEY_TOO_BIG,                      MEMCACHED_KEY_TOO_BIG);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_TEMPORARILY_DISABLED,      MEMCACHED_SERVER_TEMPORARILY_DISABLED);
+
+#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX >= 0x01000008
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_SERVER_MEMORY_ALLOCATION_FAILURE, MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE);
+#endif
+
+#ifdef HAVE_MEMCACHED_SASL
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_PROBLEM,  MEMCACHED_AUTH_PROBLEM);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_FAILURE,  MEMCACHED_AUTH_FAILURE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_AUTH_CONTINUE, MEMCACHED_AUTH_CONTINUE);
+#endif
+
+	/*
+	 * Our result codes.
+	 */
+
+	REGISTER_MEMC_CLASS_CONST_LONG(RES_PAYLOAD_FAILURE, MEMC_RES_PAYLOAD_FAILURE);
+
+	/*
+	 * Serializer types.
+	 */
+	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_PHP,        SERIALIZER_PHP);
+	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_IGBINARY,   SERIALIZER_IGBINARY);
+	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_JSON,       SERIALIZER_JSON);
+	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_JSON_ARRAY, SERIALIZER_JSON_ARRAY);
+	REGISTER_MEMC_CLASS_CONST_LONG(SERIALIZER_MSGPACK,    SERIALIZER_MSGPACK);
+
+	/*
+	 * Compression types
+	 */
+	REGISTER_MEMC_CLASS_CONST_LONG(COMPRESSION_FASTLZ, COMPRESSION_TYPE_FASTLZ);
+	REGISTER_MEMC_CLASS_CONST_LONG(COMPRESSION_ZLIB,   COMPRESSION_TYPE_ZLIB);
+	REGISTER_MEMC_CLASS_CONST_LONG(COMPRESSION_ZSTD,   COMPRESSION_TYPE_ZSTD);
+
+	/*
+	 * Flags.
+	 */
+	REGISTER_MEMC_CLASS_CONST_LONG(GET_PRESERVE_ORDER, MEMC_GET_PRESERVE_ORDER);
+	REGISTER_MEMC_CLASS_CONST_LONG(GET_EXTENDED,       MEMC_GET_EXTENDED);
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+	/*
+	 * Server callbacks
+	 */
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_CONNECT,   MEMC_SERVER_ON_CONNECT);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_ADD,       MEMC_SERVER_ON_ADD);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_APPEND,    MEMC_SERVER_ON_APPEND);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_DECREMENT, MEMC_SERVER_ON_DECREMENT);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_DELETE,    MEMC_SERVER_ON_DELETE);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_FLUSH,     MEMC_SERVER_ON_FLUSH);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_GET,       MEMC_SERVER_ON_GET);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_INCREMENT, MEMC_SERVER_ON_INCREMENT);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_NOOP,      MEMC_SERVER_ON_NOOP);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_PREPEND,   MEMC_SERVER_ON_PREPEND);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_QUIT,      MEMC_SERVER_ON_QUIT);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_REPLACE,   MEMC_SERVER_ON_REPLACE);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_SET,       MEMC_SERVER_ON_SET);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_STAT,      MEMC_SERVER_ON_STAT);
+	REGISTER_MEMC_CLASS_CONST_LONG(ON_VERSION,   MEMC_SERVER_ON_VERSION);
+
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_SUCCESS,         PROTOCOL_BINARY_RESPONSE_SUCCESS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_KEY_ENOENT,      PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_KEY_EEXISTS,     PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_E2BIG,           PROTOCOL_BINARY_RESPONSE_E2BIG);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EINVAL,          PROTOCOL_BINARY_RESPONSE_EINVAL);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_STORED,      PROTOCOL_BINARY_RESPONSE_NOT_STORED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_DELTA_BADVAL,    PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_MY_VBUCKET,  PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_AUTH_ERROR,      PROTOCOL_BINARY_RESPONSE_AUTH_ERROR);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_AUTH_CONTINUE,   PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_UNKNOWN_COMMAND, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_ENOMEM,          PROTOCOL_BINARY_RESPONSE_ENOMEM);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_NOT_SUPPORTED,   PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EINTERNAL,       PROTOCOL_BINARY_RESPONSE_EINTERNAL);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_EBUSY,           PROTOCOL_BINARY_RESPONSE_EBUSY);
+	REGISTER_MEMC_CLASS_CONST_LONG(RESPONSE_ETMPFAIL,        PROTOCOL_BINARY_RESPONSE_ETMPFAIL);
+#endif
+
+	/*
+	 * Return value from simple get errors
+	 */
+	REGISTER_MEMC_CLASS_CONST_BOOL(GET_ERROR_RETURN_VALUE, 0);
+
+	#undef REGISTER_MEMC_CLASS_CONST_LONG
+	#undef REGISTER_MEMC_CLASS_CONST_BOOL
+	#undef REGISTER_MEMC_CLASS_CONST_NULL
+
+}
+/* }}} */
+
+/* {{{ PHP_MINIT_FUNCTION */
+PHP_MINIT_FUNCTION(memcached)
+{
+	zend_class_entry ce;
+
+	memcpy(&memcached_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	memcached_object_handlers.offset    = XtOffsetOf(php_memc_object_t, zo);
+	memcached_object_handlers.clone_obj = NULL;
+	memcached_object_handlers.free_obj  = php_memc_object_free_storage;
+
+	le_memc = zend_register_list_destructors_ex(NULL, php_memc_dtor, "Memcached persistent connection", module_number);
+
+	memcached_ce = register_class_Memcached();
+	memcached_ce->create_object = php_memc_object_new;
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+	memcpy(&memcached_server_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	memcached_server_object_handlers.offset = XtOffsetOf(php_memc_server_t, zo);
+	memcached_server_object_handlers.clone_obj = NULL;
+	memcached_server_object_handlers.free_obj = php_memc_server_free_storage;
+
+	memcached_server_ce = register_class_MemcachedServer();
+	memcached_server_ce->create_object = php_memc_server_new;
+#endif
+
+	INIT_CLASS_ENTRY(ce, "MemcachedException", NULL);
+	memcached_exception_ce = zend_register_internal_class_ex(&ce, php_memc_get_exception_base(0));
+	/* TODO
+	 * possibly declare custom exception property here
+	 */
+
+	php_memc_register_constants(INIT_FUNC_ARGS_PASSTHRU);
+	REGISTER_INI_ENTRIES();
+
+#ifdef HAVE_MEMCACHED_SESSION
+	php_memc_session_minit(module_number);
+#endif
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MSHUTDOWN_FUNCTION */
+PHP_MSHUTDOWN_FUNCTION(memcached)
+{
+#ifdef HAVE_MEMCACHED_SASL
+	if (MEMC_G(sasl_initialised)) {
+		sasl_done();
+	}
+#endif
+
+	UNREGISTER_INI_ENTRIES();
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION */
+PHP_MINFO_FUNCTION(memcached)
+{
+	php_info_print_table_start();
+	php_info_print_table_header(2, "memcached support", "enabled");
+	php_info_print_table_row(2, "Version", PHP_MEMCACHED_VERSION);
+
+#ifdef LIBMEMCACHED_AWESOME
+	if (strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version())) {
+		php_info_print_table_row(2, "libmemcached-awesome headers version", LIBMEMCACHED_VERSION_STRING);
+		php_info_print_table_row(2, "libmemcached-awesome library version", memcached_lib_version());
+	} else {
+		php_info_print_table_row(2, "libmemcached-awesome version", memcached_lib_version());
+	}
+#else
+	if (strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version())) {
+		php_info_print_table_row(2, "libmemcached headers version", LIBMEMCACHED_VERSION_STRING);
+		php_info_print_table_row(2, "libmemcached library version", memcached_lib_version());
+	} else {
+		php_info_print_table_row(2, "libmemcached version", memcached_lib_version());
+	}
+#endif
+
+#ifdef HAVE_MEMCACHED_SASL
+	php_info_print_table_row(2, "SASL support", "yes");
+#else
+	php_info_print_table_row(2, "SASL support", "no");
+#endif
+
+#ifdef HAVE_MEMCACHED_SESSION
+	php_info_print_table_row(2, "Session support", "yes");
+#else
+	php_info_print_table_row(2, "Session support ", "no");
+#endif
+
+#ifdef HAVE_MEMCACHED_IGBINARY
+	php_info_print_table_row(2, "igbinary support", "yes");
+#else
+	php_info_print_table_row(2, "igbinary support", "no");
+#endif
+
+#ifdef HAVE_JSON_API
+	php_info_print_table_row(2, "json support", "yes");
+#else
+	php_info_print_table_row(2, "json support", "no");
+#endif
+
+#ifdef HAVE_MEMCACHED_MSGPACK
+	php_info_print_table_row(2, "msgpack support", "yes");
+#else
+	php_info_print_table_row(2, "msgpack support", "no");
+#endif
+
+#ifdef HAVE_ZSTD_H
+	php_info_print_table_row(2, "zstd support", "yes");
+#else
+	php_info_print_table_row(2, "zstd support", "no");
+#endif
+
+	php_info_print_table_end();
+
+	DISPLAY_INI_ENTRIES();
+}
+/* }}} */
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim: noet sw=4 ts=4 fdm=marker:
+ */

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached.h Added

@@ -0,0 +1,57 @@
+/*
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2009 The PHP Group                                     |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.0 of the PHP license,       |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_0.txt.                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors: Andrei Zmievski <andrei@php.net>                            |
+  +----------------------------------------------------------------------+
+*/
+
+#ifndef PHP_MEMCACHED_H
+#define PHP_MEMCACHED_H
+
+#include "php.h"
+#include "Zend/zend_smart_str.h"
+
+#ifdef PHP_WIN32
+#include "main/config.w32.h"
+#else
+#include "main/php_config.h"
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#define PHP_MEMCACHED_VERSION "3.3.0"
+
+#if defined(PHP_WIN32) && defined(MEMCACHED_EXPORTS)
+#define PHP_MEMCACHED_API __declspec(dllexport)
+#else
+#define PHP_MEMCACHED_API PHPAPI
+#endif
+
+PHP_MEMCACHED_API zend_class_entry *php_memc_get_ce(void);
+PHP_MEMCACHED_API zend_class_entry *php_memc_get_exception(void);
+PHP_MEMCACHED_API zend_class_entry *php_memc_get_exception_base(int root);
+
+extern zend_module_entry memcached_module_entry;
+#define phpext_memcached_ptr &memcached_module_entry
+
+#endif /* PHP_MEMCACHED_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached.stub.php Added

@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ * @generate-class-entries
+ */
+
+class Memcached {
+
+	public function __construct(?string $persistent_id=null, ?callable $callback=null, ?string $connection_str=null) {}
+
+	public function getResultCode(): int {}
+	public function getResultMessage(): string {}
+
+	public function get(string $key, ?callable $cache_cb=null, int $get_flags=0): mixed {}
+	public function getByKey(string $server_key, string $key, ?callable $cache_cb=null, int $get_flags=0): mixed {}
+	public function getMulti(array $keys, int $get_flags=0): array|false {}
+	public function getMultiByKey(string $server_key, array $keys, int $get_flags=0): array|false {}
+	public function getDelayed(array $keys, bool $with_cas=false, ?callable $value_cb=null): bool {}
+	public function getDelayedByKey(string $server_key, array $keys, bool $with_cas=false, ?callable $value_cb=null): bool {}
+	public function fetch(): array|false {}
+	public function fetchAll(): array|false {}
+
+	public function set(string $key, mixed $value, int $expiration=0): bool {}
+	public function setByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
+
+	public function touch(string $key, int $expiration=0): bool {}
+	public function touchByKey(string $server_key, string $key, int $expiration=0): bool {}
+
+	public function setMulti(array $items, int $expiration=0): bool {}
+	public function setMultiByKey(string $server_key, array $items, int $expiration=0): bool {}
+
+	public function cas(string|int|float $cas_token, string $key, mixed $value, int $expiration=0): bool {}
+	public function casByKey(string|int|float $cas_token, string $server_key, string $key, mixed $value, int $expiration=0): bool {}
+	public function add(string $key, mixed $value, int $expiration=0): bool {}
+	public function addByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
+	public function append(string $key, string $value): ?bool {}
+	public function appendByKey(string $server_key, string $key, string $value): ?bool {}
+	public function prepend(string $key, string $value): ?bool {}
+	public function prependByKey(string $server_key, string $key, string $value): ?bool {}
+	public function replace(string $key, mixed $value, int $expiration=0): bool {}
+	public function replaceByKey(string $server_key, string $key, mixed $value, int $expiration=0): bool {}
+	public function delete(string $key, int $time=0): bool {}
+	public function deleteMulti(array $keys, int $time=0): array {}
+	public function deleteByKey(string $server_key, string $key, int $time=0): bool {}
+	public function deleteMultiByKey(string $server_key, array $keys, int $time=0): array {}
+
+	public function increment(string $key, int $offset=1, int $initial_value=0, int $expiry=0): int|false {}
+	public function decrement(string $key, int $offset=1, int $initial_value=0, int $expiry=0): int|false {}
+	public function incrementByKey(string $server_key, string $key, int $offset=1, int $initial_value=0, int $expiry=0): int|false {}
+	public function decrementByKey(string $server_key, string $key, int $offset=1, int $initial_value=0, int $expiry=0): int|false {}
+
+	public function addServer(string $host, int $port, int $weight=0): bool {}
+	public function addServers(array $servers): bool {}
+	public function getServerList(): array {}
+	public function getServerByKey(string $server_key): array|false {}
+	public function resetServerList(): bool {}
+	public function quit(): bool {}
+	public function flushBuffers(): bool {}
+
+	public function getLastErrorMessage(): string {}
+	public function getLastErrorCode(): int {}
+	public function getLastErrorErrno(): int {}
+	public function getLastDisconnectedServer(): array|false {}
+
+	public function getStats(?string $type=null): array|false {}
+	public function getVersion(): array|false {}
+	public function getAllKeys(): array|false {}
+
+	public function flush(int $delay=0): bool {}
+
+	public function getOption(int $option): mixed {}
+	public function setOption(int $option, mixed $value): bool {}
+	public function setOptions(array $options): bool {}
+	public function setBucket(array $host_map, ?array $forward_map, int $replicas): bool {}
+#ifdef HAVE_MEMCACHED_SASL
+	public function setSaslAuthData(string $username, #\SensitiveParameter string $password): bool {}
+#endif
+
+#ifdef HAVE_MEMCACHED_SET_ENCODING_KEY
+	public function setEncodingKey(string $key): bool {}
+#endif
+	public function isPersistent(): bool {}
+	public function isPristine(): bool {}
+	public function checkKey(string $key): bool {}
+}
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+class MemcachedServer {
+
+	public function run(string $address): bool {}
+	public function on(int $event, callable $callback): bool {}
+}
+#endif

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_arginfo.h Added

@@ -0,0 +1,444 @@
+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 75604abd7f58655a9ebda6f0ea579840311c1f08 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached___construct, 0, 0, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, persistent_id, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, callback, IS_CALLABLE, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, connection_str, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getResultCode, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getResultMessage, 0, 0, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_get, 0, 1, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cache_cb, IS_CALLABLE, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getByKey, 0, 2, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cache_cb, IS_CALLABLE, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getMulti, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getMultiByKey, 0, 2, MAY_BE_ARRAY|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_flags, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getDelayed, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, with_cas, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, value_cb, IS_CALLABLE, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getDelayedByKey, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, with_cas, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, value_cb, IS_CALLABLE, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_fetch, 0, 0, MAY_BE_ARRAY|MAY_BE_FALSE)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_fetchAll arginfo_class_Memcached_fetch
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_set, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setByKey, 0, 3, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_touch, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_touchByKey, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setMulti, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, items, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setMultiByKey, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, items, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_cas, 0, 3, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_MASK(0, cas_token, MAY_BE_STRING|MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_casByKey, 0, 4, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_MASK(0, cas_token, MAY_BE_STRING|MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiration, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_add arginfo_class_Memcached_set
+
+#define arginfo_class_Memcached_addByKey arginfo_class_Memcached_setByKey
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_append, 0, 2, _IS_BOOL, 1)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_appendByKey, 0, 3, _IS_BOOL, 1)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_prepend arginfo_class_Memcached_append
+
+#define arginfo_class_Memcached_prependByKey arginfo_class_Memcached_appendByKey
+
+#define arginfo_class_Memcached_replace arginfo_class_Memcached_set
+
+#define arginfo_class_Memcached_replaceByKey arginfo_class_Memcached_setByKey
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_delete, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteMulti, 0, 1, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteByKey, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_deleteMultiByKey, 0, 2, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, keys, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_increment, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, initial_value, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiry, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_decrement arginfo_class_Memcached_increment
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_incrementByKey, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, initial_value, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, expiry, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_decrementByKey arginfo_class_Memcached_incrementByKey
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_addServer, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, host, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, port, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, weight, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_addServers, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, servers, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getServerList, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getServerByKey, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO(0, server_key, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_resetServerList, 0, 0, _IS_BOOL, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_quit arginfo_class_Memcached_resetServerList
+
+#define arginfo_class_Memcached_flushBuffers arginfo_class_Memcached_resetServerList
+
+#define arginfo_class_Memcached_getLastErrorMessage arginfo_class_Memcached_getResultMessage
+
+#define arginfo_class_Memcached_getLastErrorCode arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastErrorErrno arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastDisconnectedServer arginfo_class_Memcached_fetch
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_Memcached_getStats, 0, 0, MAY_BE_ARRAY|MAY_BE_FALSE)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, type, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_getVersion arginfo_class_Memcached_fetch
+
+#define arginfo_class_Memcached_getAllKeys arginfo_class_Memcached_fetch
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_flush, 0, 0, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delay, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_getOption, 0, 1, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setOption, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setOptions, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, options, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setBucket, 0, 3, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, host_map, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, forward_map, IS_ARRAY, 1)
+	ZEND_ARG_TYPE_INFO(0, replicas, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+#if defined(HAVE_MEMCACHED_SASL)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setSaslAuthData, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, username, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, password, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+#endif
+
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_setEncodingKey, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+#endif
+
+#define arginfo_class_Memcached_isPersistent arginfo_class_Memcached_resetServerList
+
+#define arginfo_class_Memcached_isPristine arginfo_class_Memcached_resetServerList
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Memcached_checkKey, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_MemcachedServer_run, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+#endif
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_MemcachedServer_on, 0, 2, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, event, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
+ZEND_END_ARG_INFO()
+#endif
+
+
+ZEND_METHOD(Memcached, __construct);
+ZEND_METHOD(Memcached, getResultCode);
+ZEND_METHOD(Memcached, getResultMessage);
+ZEND_METHOD(Memcached, get);
+ZEND_METHOD(Memcached, getByKey);
+ZEND_METHOD(Memcached, getMulti);
+ZEND_METHOD(Memcached, getMultiByKey);
+ZEND_METHOD(Memcached, getDelayed);
+ZEND_METHOD(Memcached, getDelayedByKey);
+ZEND_METHOD(Memcached, fetch);
+ZEND_METHOD(Memcached, fetchAll);
+ZEND_METHOD(Memcached, set);
+ZEND_METHOD(Memcached, setByKey);
+ZEND_METHOD(Memcached, touch);
+ZEND_METHOD(Memcached, touchByKey);
+ZEND_METHOD(Memcached, setMulti);
+ZEND_METHOD(Memcached, setMultiByKey);
+ZEND_METHOD(Memcached, cas);
+ZEND_METHOD(Memcached, casByKey);
+ZEND_METHOD(Memcached, add);
+ZEND_METHOD(Memcached, addByKey);
+ZEND_METHOD(Memcached, append);
+ZEND_METHOD(Memcached, appendByKey);
+ZEND_METHOD(Memcached, prepend);
+ZEND_METHOD(Memcached, prependByKey);
+ZEND_METHOD(Memcached, replace);
+ZEND_METHOD(Memcached, replaceByKey);
+ZEND_METHOD(Memcached, delete);
+ZEND_METHOD(Memcached, deleteMulti);
+ZEND_METHOD(Memcached, deleteByKey);
+ZEND_METHOD(Memcached, deleteMultiByKey);
+ZEND_METHOD(Memcached, increment);
+ZEND_METHOD(Memcached, decrement);
+ZEND_METHOD(Memcached, incrementByKey);
+ZEND_METHOD(Memcached, decrementByKey);
+ZEND_METHOD(Memcached, addServer);
+ZEND_METHOD(Memcached, addServers);
+ZEND_METHOD(Memcached, getServerList);
+ZEND_METHOD(Memcached, getServerByKey);
+ZEND_METHOD(Memcached, resetServerList);
+ZEND_METHOD(Memcached, quit);
+ZEND_METHOD(Memcached, flushBuffers);
+ZEND_METHOD(Memcached, getLastErrorMessage);
+ZEND_METHOD(Memcached, getLastErrorCode);
+ZEND_METHOD(Memcached, getLastErrorErrno);
+ZEND_METHOD(Memcached, getLastDisconnectedServer);
+ZEND_METHOD(Memcached, getStats);
+ZEND_METHOD(Memcached, getVersion);
+ZEND_METHOD(Memcached, getAllKeys);
+ZEND_METHOD(Memcached, flush);
+ZEND_METHOD(Memcached, getOption);
+ZEND_METHOD(Memcached, setOption);
+ZEND_METHOD(Memcached, setOptions);
+ZEND_METHOD(Memcached, setBucket);
+#if defined(HAVE_MEMCACHED_SASL)
+ZEND_METHOD(Memcached, setSaslAuthData);
+#endif
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+ZEND_METHOD(Memcached, setEncodingKey);
+#endif
+ZEND_METHOD(Memcached, isPersistent);
+ZEND_METHOD(Memcached, isPristine);
+ZEND_METHOD(Memcached, checkKey);
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_METHOD(MemcachedServer, run);
+#endif
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_METHOD(MemcachedServer, on);
+#endif
+
+
+static const zend_function_entry class_Memcached_methods = {
+	ZEND_ME(Memcached, __construct, arginfo_class_Memcached___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getResultCode, arginfo_class_Memcached_getResultCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getResultMessage, arginfo_class_Memcached_getResultMessage, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, get, arginfo_class_Memcached_get, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getByKey, arginfo_class_Memcached_getByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getMulti, arginfo_class_Memcached_getMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getMultiByKey, arginfo_class_Memcached_getMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getDelayed, arginfo_class_Memcached_getDelayed, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getDelayedByKey, arginfo_class_Memcached_getDelayedByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, fetch, arginfo_class_Memcached_fetch, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, fetchAll, arginfo_class_Memcached_fetchAll, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, set, arginfo_class_Memcached_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setByKey, arginfo_class_Memcached_setByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, touch, arginfo_class_Memcached_touch, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, touchByKey, arginfo_class_Memcached_touchByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setMulti, arginfo_class_Memcached_setMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setMultiByKey, arginfo_class_Memcached_setMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, cas, arginfo_class_Memcached_cas, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, casByKey, arginfo_class_Memcached_casByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, add, arginfo_class_Memcached_add, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addByKey, arginfo_class_Memcached_addByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, append, arginfo_class_Memcached_append, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, appendByKey, arginfo_class_Memcached_appendByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, prepend, arginfo_class_Memcached_prepend, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, prependByKey, arginfo_class_Memcached_prependByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, replace, arginfo_class_Memcached_replace, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, replaceByKey, arginfo_class_Memcached_replaceByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, delete, arginfo_class_Memcached_delete, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteMulti, arginfo_class_Memcached_deleteMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteByKey, arginfo_class_Memcached_deleteByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteMultiByKey, arginfo_class_Memcached_deleteMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, increment, arginfo_class_Memcached_increment, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, decrement, arginfo_class_Memcached_decrement, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, incrementByKey, arginfo_class_Memcached_incrementByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, decrementByKey, arginfo_class_Memcached_decrementByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addServer, arginfo_class_Memcached_addServer, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addServers, arginfo_class_Memcached_addServers, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getServerList, arginfo_class_Memcached_getServerList, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getServerByKey, arginfo_class_Memcached_getServerByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, resetServerList, arginfo_class_Memcached_resetServerList, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, quit, arginfo_class_Memcached_quit, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, flushBuffers, arginfo_class_Memcached_flushBuffers, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorMessage, arginfo_class_Memcached_getLastErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorCode, arginfo_class_Memcached_getLastErrorCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorErrno, arginfo_class_Memcached_getLastErrorErrno, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastDisconnectedServer, arginfo_class_Memcached_getLastDisconnectedServer, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getStats, arginfo_class_Memcached_getStats, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getVersion, arginfo_class_Memcached_getVersion, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getAllKeys, arginfo_class_Memcached_getAllKeys, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, flush, arginfo_class_Memcached_flush, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getOption, arginfo_class_Memcached_getOption, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setOption, arginfo_class_Memcached_setOption, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setOptions, arginfo_class_Memcached_setOptions, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setBucket, arginfo_class_Memcached_setBucket, ZEND_ACC_PUBLIC)
+#if defined(HAVE_MEMCACHED_SASL)
+	ZEND_ME(Memcached, setSaslAuthData, arginfo_class_Memcached_setSaslAuthData, ZEND_ACC_PUBLIC)
+#endif
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+	ZEND_ME(Memcached, setEncodingKey, arginfo_class_Memcached_setEncodingKey, ZEND_ACC_PUBLIC)
+#endif
+	ZEND_ME(Memcached, isPersistent, arginfo_class_Memcached_isPersistent, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, isPristine, arginfo_class_Memcached_isPristine, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, checkKey, arginfo_class_Memcached_checkKey, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+static const zend_function_entry class_MemcachedServer_methods = {
+	ZEND_ME(MemcachedServer, run, arginfo_class_MemcachedServer_run, ZEND_ACC_PUBLIC)
+	ZEND_ME(MemcachedServer, on, arginfo_class_MemcachedServer_on, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+#endif
+
+static zend_class_entry *register_class_Memcached(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "Memcached", class_Memcached_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+#if (PHP_VERSION_ID >= 80200)
+
+#if defined(HAVE_MEMCACHED_SASL)
+
+	zend_add_parameter_attribute(zend_hash_str_find_ptr(&class_entry->function_table, "setsaslauthdata", sizeof("setsaslauthdata") - 1), 1, ZSTR_KNOWN(ZEND_STR_SENSITIVEPARAMETER), 0);
+#endif
+#endif
+
+	return class_entry;
+}
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+static zend_class_entry *register_class_MemcachedServer(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "MemcachedServer", class_MemcachedServer_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}
+#endif

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_legacy_arginfo.h Added

@@ -0,0 +1,433 @@
+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 75604abd7f58655a9ebda6f0ea579840311c1f08 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached___construct, 0, 0, 0)
+	ZEND_ARG_INFO(0, persistent_id)
+	ZEND_ARG_INFO(0, callback)
+	ZEND_ARG_INFO(0, connection_str)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getResultCode, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_getResultMessage arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_get, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, cache_cb)
+	ZEND_ARG_INFO(0, get_flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, cache_cb)
+	ZEND_ARG_INFO(0, get_flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getMulti, 0, 0, 1)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, get_flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getMultiByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, get_flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getDelayed, 0, 0, 1)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, with_cas)
+	ZEND_ARG_INFO(0, value_cb)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getDelayedByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, with_cas)
+	ZEND_ARG_INFO(0, value_cb)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_fetch arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_fetchAll arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_set, 0, 0, 2)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setByKey, 0, 0, 3)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_touch, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_touchByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setMulti, 0, 0, 1)
+	ZEND_ARG_INFO(0, items)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setMultiByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, items)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_cas, 0, 0, 3)
+	ZEND_ARG_INFO(0, cas_token)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_casByKey, 0, 0, 4)
+	ZEND_ARG_INFO(0, cas_token)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+	ZEND_ARG_INFO(0, expiration)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_add arginfo_class_Memcached_set
+
+#define arginfo_class_Memcached_addByKey arginfo_class_Memcached_setByKey
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_append, 0, 0, 2)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_appendByKey, 0, 0, 3)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_prepend arginfo_class_Memcached_append
+
+#define arginfo_class_Memcached_prependByKey arginfo_class_Memcached_appendByKey
+
+#define arginfo_class_Memcached_replace arginfo_class_Memcached_set
+
+#define arginfo_class_Memcached_replaceByKey arginfo_class_Memcached_setByKey
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_delete, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, time)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteMulti, 0, 0, 1)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, time)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, time)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_deleteMultiByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, keys)
+	ZEND_ARG_INFO(0, time)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_increment, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, offset)
+	ZEND_ARG_INFO(0, initial_value)
+	ZEND_ARG_INFO(0, expiry)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_decrement arginfo_class_Memcached_increment
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_incrementByKey, 0, 0, 2)
+	ZEND_ARG_INFO(0, server_key)
+	ZEND_ARG_INFO(0, key)
+	ZEND_ARG_INFO(0, offset)
+	ZEND_ARG_INFO(0, initial_value)
+	ZEND_ARG_INFO(0, expiry)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_decrementByKey arginfo_class_Memcached_incrementByKey
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_addServer, 0, 0, 2)
+	ZEND_ARG_INFO(0, host)
+	ZEND_ARG_INFO(0, port)
+	ZEND_ARG_INFO(0, weight)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_addServers, 0, 0, 1)
+	ZEND_ARG_INFO(0, servers)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_getServerList arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getServerByKey, 0, 0, 1)
+	ZEND_ARG_INFO(0, server_key)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_resetServerList arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_quit arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_flushBuffers arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastErrorMessage arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastErrorCode arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastErrorErrno arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getLastDisconnectedServer arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getStats, 0, 0, 0)
+	ZEND_ARG_INFO(0, type)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Memcached_getVersion arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_getAllKeys arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_flush, 0, 0, 0)
+	ZEND_ARG_INFO(0, delay)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_getOption, 0, 0, 1)
+	ZEND_ARG_INFO(0, option)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setOption, 0, 0, 2)
+	ZEND_ARG_INFO(0, option)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setOptions, 0, 0, 1)
+	ZEND_ARG_INFO(0, options)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setBucket, 0, 0, 3)
+	ZEND_ARG_INFO(0, host_map)
+	ZEND_ARG_INFO(0, forward_map)
+	ZEND_ARG_INFO(0, replicas)
+ZEND_END_ARG_INFO()
+
+#if defined(HAVE_MEMCACHED_SASL)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setSaslAuthData, 0, 0, 2)
+	ZEND_ARG_INFO(0, username)
+	ZEND_ARG_INFO(0, password)
+ZEND_END_ARG_INFO()
+#endif
+
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_setEncodingKey, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+ZEND_END_ARG_INFO()
+#endif
+
+#define arginfo_class_Memcached_isPersistent arginfo_class_Memcached_getResultCode
+
+#define arginfo_class_Memcached_isPristine arginfo_class_Memcached_getResultCode
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Memcached_checkKey, 0, 0, 1)
+	ZEND_ARG_INFO(0, key)
+ZEND_END_ARG_INFO()
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_MemcachedServer_run, 0, 0, 1)
+	ZEND_ARG_INFO(0, address)
+ZEND_END_ARG_INFO()
+#endif
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_MemcachedServer_on, 0, 0, 2)
+	ZEND_ARG_INFO(0, event)
+	ZEND_ARG_INFO(0, callback)
+ZEND_END_ARG_INFO()
+#endif
+
+
+ZEND_METHOD(Memcached, __construct);
+ZEND_METHOD(Memcached, getResultCode);
+ZEND_METHOD(Memcached, getResultMessage);
+ZEND_METHOD(Memcached, get);
+ZEND_METHOD(Memcached, getByKey);
+ZEND_METHOD(Memcached, getMulti);
+ZEND_METHOD(Memcached, getMultiByKey);
+ZEND_METHOD(Memcached, getDelayed);
+ZEND_METHOD(Memcached, getDelayedByKey);
+ZEND_METHOD(Memcached, fetch);
+ZEND_METHOD(Memcached, fetchAll);
+ZEND_METHOD(Memcached, set);
+ZEND_METHOD(Memcached, setByKey);
+ZEND_METHOD(Memcached, touch);
+ZEND_METHOD(Memcached, touchByKey);
+ZEND_METHOD(Memcached, setMulti);
+ZEND_METHOD(Memcached, setMultiByKey);
+ZEND_METHOD(Memcached, cas);
+ZEND_METHOD(Memcached, casByKey);
+ZEND_METHOD(Memcached, add);
+ZEND_METHOD(Memcached, addByKey);
+ZEND_METHOD(Memcached, append);
+ZEND_METHOD(Memcached, appendByKey);
+ZEND_METHOD(Memcached, prepend);
+ZEND_METHOD(Memcached, prependByKey);
+ZEND_METHOD(Memcached, replace);
+ZEND_METHOD(Memcached, replaceByKey);
+ZEND_METHOD(Memcached, delete);
+ZEND_METHOD(Memcached, deleteMulti);
+ZEND_METHOD(Memcached, deleteByKey);
+ZEND_METHOD(Memcached, deleteMultiByKey);
+ZEND_METHOD(Memcached, increment);
+ZEND_METHOD(Memcached, decrement);
+ZEND_METHOD(Memcached, incrementByKey);
+ZEND_METHOD(Memcached, decrementByKey);
+ZEND_METHOD(Memcached, addServer);
+ZEND_METHOD(Memcached, addServers);
+ZEND_METHOD(Memcached, getServerList);
+ZEND_METHOD(Memcached, getServerByKey);
+ZEND_METHOD(Memcached, resetServerList);
+ZEND_METHOD(Memcached, quit);
+ZEND_METHOD(Memcached, flushBuffers);
+ZEND_METHOD(Memcached, getLastErrorMessage);
+ZEND_METHOD(Memcached, getLastErrorCode);
+ZEND_METHOD(Memcached, getLastErrorErrno);
+ZEND_METHOD(Memcached, getLastDisconnectedServer);
+ZEND_METHOD(Memcached, getStats);
+ZEND_METHOD(Memcached, getVersion);
+ZEND_METHOD(Memcached, getAllKeys);
+ZEND_METHOD(Memcached, flush);
+ZEND_METHOD(Memcached, getOption);
+ZEND_METHOD(Memcached, setOption);
+ZEND_METHOD(Memcached, setOptions);
+ZEND_METHOD(Memcached, setBucket);
+#if defined(HAVE_MEMCACHED_SASL)
+ZEND_METHOD(Memcached, setSaslAuthData);
+#endif
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+ZEND_METHOD(Memcached, setEncodingKey);
+#endif
+ZEND_METHOD(Memcached, isPersistent);
+ZEND_METHOD(Memcached, isPristine);
+ZEND_METHOD(Memcached, checkKey);
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_METHOD(MemcachedServer, run);
+#endif
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+ZEND_METHOD(MemcachedServer, on);
+#endif
+
+
+static const zend_function_entry class_Memcached_methods = {
+	ZEND_ME(Memcached, __construct, arginfo_class_Memcached___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getResultCode, arginfo_class_Memcached_getResultCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getResultMessage, arginfo_class_Memcached_getResultMessage, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, get, arginfo_class_Memcached_get, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getByKey, arginfo_class_Memcached_getByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getMulti, arginfo_class_Memcached_getMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getMultiByKey, arginfo_class_Memcached_getMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getDelayed, arginfo_class_Memcached_getDelayed, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getDelayedByKey, arginfo_class_Memcached_getDelayedByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, fetch, arginfo_class_Memcached_fetch, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, fetchAll, arginfo_class_Memcached_fetchAll, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, set, arginfo_class_Memcached_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setByKey, arginfo_class_Memcached_setByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, touch, arginfo_class_Memcached_touch, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, touchByKey, arginfo_class_Memcached_touchByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setMulti, arginfo_class_Memcached_setMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setMultiByKey, arginfo_class_Memcached_setMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, cas, arginfo_class_Memcached_cas, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, casByKey, arginfo_class_Memcached_casByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, add, arginfo_class_Memcached_add, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addByKey, arginfo_class_Memcached_addByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, append, arginfo_class_Memcached_append, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, appendByKey, arginfo_class_Memcached_appendByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, prepend, arginfo_class_Memcached_prepend, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, prependByKey, arginfo_class_Memcached_prependByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, replace, arginfo_class_Memcached_replace, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, replaceByKey, arginfo_class_Memcached_replaceByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, delete, arginfo_class_Memcached_delete, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteMulti, arginfo_class_Memcached_deleteMulti, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteByKey, arginfo_class_Memcached_deleteByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, deleteMultiByKey, arginfo_class_Memcached_deleteMultiByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, increment, arginfo_class_Memcached_increment, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, decrement, arginfo_class_Memcached_decrement, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, incrementByKey, arginfo_class_Memcached_incrementByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, decrementByKey, arginfo_class_Memcached_decrementByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addServer, arginfo_class_Memcached_addServer, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, addServers, arginfo_class_Memcached_addServers, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getServerList, arginfo_class_Memcached_getServerList, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getServerByKey, arginfo_class_Memcached_getServerByKey, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, resetServerList, arginfo_class_Memcached_resetServerList, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, quit, arginfo_class_Memcached_quit, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, flushBuffers, arginfo_class_Memcached_flushBuffers, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorMessage, arginfo_class_Memcached_getLastErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorCode, arginfo_class_Memcached_getLastErrorCode, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastErrorErrno, arginfo_class_Memcached_getLastErrorErrno, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getLastDisconnectedServer, arginfo_class_Memcached_getLastDisconnectedServer, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getStats, arginfo_class_Memcached_getStats, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getVersion, arginfo_class_Memcached_getVersion, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getAllKeys, arginfo_class_Memcached_getAllKeys, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, flush, arginfo_class_Memcached_flush, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, getOption, arginfo_class_Memcached_getOption, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setOption, arginfo_class_Memcached_setOption, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setOptions, arginfo_class_Memcached_setOptions, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, setBucket, arginfo_class_Memcached_setBucket, ZEND_ACC_PUBLIC)
+#if defined(HAVE_MEMCACHED_SASL)
+	ZEND_ME(Memcached, setSaslAuthData, arginfo_class_Memcached_setSaslAuthData, ZEND_ACC_PUBLIC)
+#endif
+#if defined(HAVE_MEMCACHED_SET_ENCODING_KEY)
+	ZEND_ME(Memcached, setEncodingKey, arginfo_class_Memcached_setEncodingKey, ZEND_ACC_PUBLIC)
+#endif
+	ZEND_ME(Memcached, isPersistent, arginfo_class_Memcached_isPersistent, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, isPristine, arginfo_class_Memcached_isPristine, ZEND_ACC_PUBLIC)
+	ZEND_ME(Memcached, checkKey, arginfo_class_Memcached_checkKey, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+static const zend_function_entry class_MemcachedServer_methods = {
+	ZEND_ME(MemcachedServer, run, arginfo_class_MemcachedServer_run, ZEND_ACC_PUBLIC)
+	ZEND_ME(MemcachedServer, on, arginfo_class_MemcachedServer_on, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+#endif
+
+static zend_class_entry *register_class_Memcached(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "Memcached", class_Memcached_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}
+
+#if defined(HAVE_MEMCACHED_PROTOCOL)
+static zend_class_entry *register_class_MemcachedServer(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "MemcachedServer", class_MemcachedServer_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}
+#endif

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_private.h Added

@@ -0,0 +1,255 @@
+/*
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2009 The PHP Group                                     |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.0 of the PHP license,       |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_0.txt.                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors: Andrei Zmievski <andrei@php.net>                            |
+  +----------------------------------------------------------------------+
+*/
+
+#ifndef PHP_MEMCACHED_PRIVATE_H
+#define PHP_MEMCACHED_PRIVATE_H
+
+#ifdef PHP_WIN32
+#include "main/config.w32.h"
+#else
+#include "main/php_config.h"
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "php_libmemcached_compat.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <php.h>
+#include <php_main.h>
+
+#ifdef ZTS
+#  include "TSRM.h"
+#endif
+
+#include <php_ini.h>
+#include <SAPI.h>
+#include <ext/standard/info.h>
+#include <zend_extensions.h>
+#include <zend_exceptions.h>
+#include <ext/standard/php_smart_string.h>
+#include <ext/standard/php_var.h>
+#include <ext/standard/basic_functions.h>
+
+#ifdef PHP_WIN32
+   #  if PHP_VERSION_ID >= 80000
+   #  include <stdint.h>
+   #else
+   # include "win32/php_stdint.h"
+   #endif
+#else
+/* Used to store the size of the block */
+#  if defined(HAVE_INTTYPES_H)
+#    include <inttypes.h>
+#  elif defined(HAVE_STDINT_H)
+#    include <stdint.h>
+#  endif
+#endif
+
+#ifndef HAVE_INT32_T
+#  if SIZEOF_INT == 4
+typedef int int32_t;
+#  elif SIZEOF_LONG == 4
+typedef long int int32_t;
+#  endif
+#endif
+
+#ifndef HAVE_UINT32_T
+#  if SIZEOF_INT == 4
+typedef unsigned int uint32_t;
+#  elif SIZEOF_LONG == 4
+typedef unsigned long int uint32_t;
+#  endif
+#endif
+
+/* Backwards compatibility for GC API change in PHP 7.3 */
+#if PHP_VERSION_ID < 70300
+#  define GC_ADDREF(p)            ++GC_REFCOUNT(p)
+#  define GC_DELREF(p)            --GC_REFCOUNT(p)
+#  define GC_SET_REFCOUNT(p, rc)  GC_REFCOUNT(p) = rc
+#endif
+
+/****************************************
+  Structures and definitions
+****************************************/
+typedef enum {
+	SERIALIZER_PHP        = 1,
+	SERIALIZER_IGBINARY   = 2,
+	SERIALIZER_JSON       = 3,
+	SERIALIZER_JSON_ARRAY = 4,
+	SERIALIZER_MSGPACK    = 5
+} php_memc_serializer_type;
+
+typedef enum {
+	COMPRESSION_TYPE_ZLIB   = 1,
+	COMPRESSION_TYPE_FASTLZ = 2,
+	COMPRESSION_TYPE_ZSTD   = 3
+} php_memc_compression_type;
+
+typedef struct {
+	const char *name;
+	php_memc_serializer_type type;
+} php_memc_serializer;
+
+#if defined(HAVE_MEMCACHED_IGBINARY)
+# define SERIALIZER_DEFAULT SERIALIZER_IGBINARY
+# define SERIALIZER_DEFAULT_NAME "igbinary"
+#elif defined(HAVE_MEMCACHED_MSGPACK)
+# define SERIALIZER_DEFAULT SERIALIZER_MSGPACK
+# define SERIALIZER_DEFAULT_NAME "msgpack"
+#else
+# define SERIALIZER_DEFAULT SERIALIZER_PHP
+# define SERIALIZER_DEFAULT_NAME "php"
+#endif /* HAVE_MEMCACHED_IGBINARY / HAVE_MEMCACHED_MSGPACK */
+
+#ifdef HAVE_MEMCACHED_SASL
+# include <sasl/sasl.h>
+#endif
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+typedef enum {
+	MEMC_SERVER_ON_MIN       = -1,
+	MEMC_SERVER_ON_CONNECT   = 0,
+	MEMC_SERVER_ON_ADD       = 1,
+	MEMC_SERVER_ON_APPEND    = 2,
+	MEMC_SERVER_ON_DECREMENT = 3,
+	MEMC_SERVER_ON_DELETE    = 4,
+	MEMC_SERVER_ON_FLUSH     = 5,
+	MEMC_SERVER_ON_GET       = 6,
+	MEMC_SERVER_ON_INCREMENT = 7,
+	MEMC_SERVER_ON_NOOP      = 8,
+	MEMC_SERVER_ON_PREPEND   = 9,
+	MEMC_SERVER_ON_QUIT      = 10,
+	MEMC_SERVER_ON_REPLACE   = 11,
+	MEMC_SERVER_ON_SET       = 12,
+	MEMC_SERVER_ON_STAT      = 13,
+	MEMC_SERVER_ON_VERSION   = 14,
+	MEMC_SERVER_ON_MAX
+} php_memc_event_t;
+
+
+typedef struct {
+	zend_fcall_info fci;
+	zend_fcall_info_cache fci_cache;
+} php_memc_server_cb_t;
+#endif
+
+ZEND_BEGIN_MODULE_GLOBALS(php_memcached)
+
+#ifdef HAVE_MEMCACHED_SESSION
+	/* Session related variables */
+	struct {
+		zend_bool lock_enabled;
+		zend_long lock_wait_max;
+		zend_long lock_wait_min;
+		zend_long lock_retries;
+		zend_long lock_expiration;
+
+		zend_bool binary_protocol_enabled;
+		zend_bool consistent_hash_enabled;
+		char     *consistent_hash_name;
+		int       consistent_hash_type;
+
+		zend_long server_failure_limit;
+		zend_long number_of_replicas;
+		zend_bool randomize_replica_read_enabled;
+		zend_bool remove_failed_servers_enabled;
+
+		zend_long connect_timeout;
+
+		char *prefix;
+		zend_bool persistent_enabled;
+
+		char *sasl_username;
+		char *sasl_password;
+	} session;
+#endif
+
+	struct {
+		char     *serializer_name;
+		char     *compression_name;
+		zend_long compression_threshold;
+		double    compression_factor;
+		zend_long store_retry_count;
+		zend_long compression_level;
+		zend_long item_size_limit;
+
+		/* Converted values*/
+		php_memc_serializer_type  serializer_type;
+		php_memc_compression_type compression_type;
+
+		/* Whether we have initialised sasl for this process */
+		zend_bool sasl_initialised;
+
+		struct {
+
+			zend_bool consistent_hash_enabled;
+			zend_bool binary_protocol_enabled;
+			zend_long connect_timeout;
+
+		} default_behavior;
+
+	} memc;
+
+	/* For deprecated values */
+	zend_long no_effect;
+
+#ifdef HAVE_MEMCACHED_PROTOCOL
+	struct {
+		php_memc_server_cb_t callbacks MEMC_SERVER_ON_MAX;
+	} server;
+#endif
+
+ZEND_END_MODULE_GLOBALS(php_memcached)
+
+/* Globals accessor macros */
+#ifdef ZTS
+#  define MEMC_G(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, memc.v)
+#  define MEMC_SERVER_G(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, server.v)
+#  define MEMC_SESS_INI(v) TSRMG(php_memcached_globals_id, zend_php_memcached_globals *, session.v)
+#else
+#  define MEMC_G(v) (php_memcached_globals.memc.v)
+#  define MEMC_SERVER_G(v) (php_memcached_globals.server.v)
+#  define MEMC_SESS_INI(v) (php_memcached_globals.session.v)
+#endif
+
+#define MEMC_SESS_STR_INI(vv) ((MEMC_SESS_INI(vv) && *MEMC_SESS_INI(vv)) ? MEMC_SESS_INI(vv) : NULL)
+
+PHP_RINIT_FUNCTION(memcached);
+PHP_RSHUTDOWN_FUNCTION(memcached);
+PHP_MINIT_FUNCTION(memcached);
+PHP_MSHUTDOWN_FUNCTION(memcached);
+PHP_MINFO_FUNCTION(memcached);
+
+char *php_memc_printable_func (zend_fcall_info *fci, zend_fcall_info_cache *fci_cache);
+
+memcached_return php_memcached_exist (memcached_st *memc, zend_string *key);
+
+zend_bool php_memc_init_sasl_if_needed();
+
+#endif /* PHP_MEMCACHED_PRIVATE_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_server.c Changed

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_server.h Changed

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_session.c Changed

memcached-3.3.0.tgz/memcached-3.3.0/php_memcached_session.h Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/001.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/add.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/append.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bad_construct.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bad_construct_8.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bug_16084.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bug_16959.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bug_17137.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/bug_18639.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/cachecallback.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/callback_exception.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/callback_exception_2.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/cas.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/cas_multi.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/check_if_persistent.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/check_if_pristine.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/check_key.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/clone.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/compression_conditions.phpt Added

@@ -0,0 +1,125 @@
+--TEST--
+Memcached compression test
+--SKIPIF--
+<?php if (!extension_loaded("memcached")) print "skip"; ?>
+--FILE--
+<?php
+include dirname (__FILE__) . '/config.inc';
+$m = memc_get_instance ();
+
+$short_data = "abcdefg";
+$data = file_get_contents(dirname(__FILE__) . '/testdata.res');
+
+set_error_handler(function($errno, $errstr, $errfile, $errline, array $errcontext) {
+	echo "$errstr\n";
+	return true;
+}, E_WARNING);
+
+function get_compression($name) {
+	switch (strtolower($name)) {
+		case 'zlib':
+			return Memcached::COMPRESSION_ZLIB;
+		case 'fastlz':
+			return Memcached::COMPRESSION_FASTLZ;
+		case 'zstd':
+			return Memcached::COMPRESSION_ZSTD;
+		default:
+			echo "Strange compression type: $name\n";
+			return 0;
+	}
+}
+
+function fetch_with_compression($m, $key, $value, $set_compression = '', $factor = 1.3, $threshold = 2000) {
+ 	ini_set("memcached.compression_factor", $factor);
+ 	ini_set("memcached.compression_threshold", $threshold);
+	
+	$len=strlen($value);
+	echo "len=$len set=$set_compression factor=$factor threshold=$threshold\n";
+	
+	if (!$set_compression) {
+		$m->setOption(Memcached::OPT_COMPRESSION, false);
+	} else {
+		$m->setOption(Memcached::OPT_COMPRESSION, true);
+		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($set_compression));
+	}
+	
+	$m->set($key, $value, 1800);
+	
+	$value_back = $m->get($key);
+	var_dump($value === $value_back);
+}
+
+fetch_with_compression($m, 'hello01', $data, 'zlib',         1.3, 4);
+fetch_with_compression($m, 'hello02', $data, 'fastlz',       1.3, 4);
+fetch_with_compression($m, 'hello03', $data, '',             1.3, 4);
+fetch_with_compression($m, 'hello04', $short_data, 'zlib',   1.3, 4);
+fetch_with_compression($m, 'hello05', $short_data, 'fastlz', 1.3, 4);
+fetch_with_compression($m, 'hello06', $short_data, '',       1.3, 4);
+fetch_with_compression($m, 'hello11', $data, 'zlib',         0.3, 4);
+fetch_with_compression($m, 'hello12', $data, 'fastlz',       0.3, 4);
+fetch_with_compression($m, 'hello13', $data, '',             0.3, 4);
+fetch_with_compression($m, 'hello14', $short_data, 'zlib',   0.3, 4);
+fetch_with_compression($m, 'hello15', $short_data, 'fastlz', 0.3, 4);
+fetch_with_compression($m, 'hello16', $short_data, '',       0.3, 4);
+fetch_with_compression($m, 'hello21', $data, 'zlib',         1.3, 2000);
+fetch_with_compression($m, 'hello22', $data, 'fastlz',       1.3, 2000);
+fetch_with_compression($m, 'hello23', $data, '',             1.3, 2000);
+fetch_with_compression($m, 'hello24', $short_data, 'zlib',   1.3, 2000);
+fetch_with_compression($m, 'hello25', $short_data, 'fastlz', 1.3, 2000);
+fetch_with_compression($m, 'hello26', $short_data, '',       1.3, 2000);
+fetch_with_compression($m, 'hello31', $data, 'zlib',         0.3, 2000);
+fetch_with_compression($m, 'hello32', $data, 'fastlz',       0.3, 2000);
+fetch_with_compression($m, 'hello33', $data, '',             0.3, 2000);
+fetch_with_compression($m, 'hello34', $short_data, 'zlib',   0.3, 2000);
+fetch_with_compression($m, 'hello35', $short_data, 'fastlz', 0.3, 2000);
+fetch_with_compression($m, 'hello36', $short_data, '',       0.3, 2000);
+?>
+--EXPECT--
+len=4877 set=zlib factor=1.3 threshold=4
+bool(true)
+len=4877 set=fastlz factor=1.3 threshold=4
+bool(true)
+len=4877 set= factor=1.3 threshold=4
+bool(true)
+len=7 set=zlib factor=1.3 threshold=4
+bool(true)
+len=7 set=fastlz factor=1.3 threshold=4
+bool(true)
+len=7 set= factor=1.3 threshold=4
+bool(true)
+len=4877 set=zlib factor=0.3 threshold=4
+bool(true)
+len=4877 set=fastlz factor=0.3 threshold=4
+bool(true)
+len=4877 set= factor=0.3 threshold=4
+bool(true)
+len=7 set=zlib factor=0.3 threshold=4
+bool(true)
+len=7 set=fastlz factor=0.3 threshold=4
+bool(true)
+len=7 set= factor=0.3 threshold=4
+bool(true)
+len=4877 set=zlib factor=1.3 threshold=2000
+bool(true)
+len=4877 set=fastlz factor=1.3 threshold=2000
+bool(true)
+len=4877 set= factor=1.3 threshold=2000
+bool(true)
+len=7 set=zlib factor=1.3 threshold=2000
+bool(true)
+len=7 set=fastlz factor=1.3 threshold=2000
+bool(true)
+len=7 set= factor=1.3 threshold=2000
+bool(true)
+len=4877 set=zlib factor=0.3 threshold=2000
+bool(true)
+len=4877 set=fastlz factor=0.3 threshold=2000
+bool(true)
+len=4877 set= factor=0.3 threshold=2000
+bool(true)
+len=7 set=zlib factor=0.3 threshold=2000
+bool(true)
+len=7 set=fastlz factor=0.3 threshold=2000
+bool(true)
+len=7 set= factor=0.3 threshold=2000
+bool(true)

memcached-3.3.0.tgz/memcached-3.3.0/tests/compression_types.phpt Added

@@ -0,0 +1,110 @@
+--TEST--
+Memcached compression test
+--SKIPIF--
+<?php include "skipif.inc";?>
+--FILE--
+<?php
+include dirname (__FILE__) . '/config.inc';
+$m = memc_get_instance ();
+
+$data = file_get_contents(dirname(__FILE__) . '/testdata.res');
+
+function get_compression($name) {
+	switch (strtolower($name)) {
+		case 'zlib':
+			return Memcached::COMPRESSION_ZLIB;
+		case 'fastlz':
+			return Memcached::COMPRESSION_FASTLZ;
+		case 'zstd':
+			if (Memcached::HAVE_ZSTD) {
+				return Memcached::COMPRESSION_ZSTD;
+			} else return 0;
+		default:
+			echo "Strange compression type: $name\n";
+			return 0;
+	}
+}
+
+function fetch_with_compression($m, $key, $value, $set_compression = '', $get_compression = '') {
+	
+	echo "set=$set_compression get=$get_compression\n";
+	
+	if (!$set_compression) {
+		$m->setOption(Memcached::OPT_COMPRESSION, false);
+	} else {
+		$m->setOption(Memcached::OPT_COMPRESSION, true);
+		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($set_compression));
+	}
+	
+	$m->set($key, $value, 1800);
+	
+	if (!$get_compression) {
+		$m->setOption(Memcached::OPT_COMPRESSION, true);
+	} else {
+		$m->setOption(Memcached::OPT_COMPRESSION, true);
+		$m->setOption(Memcached::OPT_COMPRESSION_TYPE, get_compression($get_compression));
+	}
+
+	$value_back = $m->get($key);
+	var_dump($value === $value_back);
+}
+
+fetch_with_compression($m, 'hello1', $data, 'zlib', 'zlib');
+fetch_with_compression($m, 'hello2', $data, 'zlib', 'fastlz');
+fetch_with_compression($m, 'hello3', $data, 'fastlz', 'fastlz');
+fetch_with_compression($m, 'hello4', $data, 'fastlz', 'zlib');
+fetch_with_compression($m, 'hello5', $data, '', 'zlib');
+fetch_with_compression($m, 'hello6', $data, '', 'fastlz');
+fetch_with_compression($m, 'hello7', $data, 'zlib', '');
+fetch_with_compression($m, 'hello8', $data, 'fastlz', '');
+fetch_with_compression($m, 'hello9', $data, '', '');
+if (Memcached::HAVE_ZSTD) {
+fetch_with_compression($m, 'hello10', $data, 'zstd', 'zstd');
+fetch_with_compression($m, 'hello11', $data, 'zstd', 'fastlz');
+fetch_with_compression($m, 'hello12', $data, 'fastlz', 'zstd');
+fetch_with_compression($m, 'hello13', $data, '', 'zstd');
+fetch_with_compression($m, 'hello14', $data, 'zstd', '');
+} else {
+	echo <<<EOB
+set=zstd get=zstd
+bool(true)
+set=zstd get=fastlz
+bool(true)
+set=fastlz get=zstd
+bool(true)
+set= get=zstd
+bool(true)
+set=zstd get=
+bool(true)
+EOB;
+}
+?>
+--EXPECT--
+set=zlib get=zlib
+bool(true)
+set=zlib get=fastlz
+bool(true)
+set=fastlz get=fastlz
+bool(true)
+set=fastlz get=zlib
+bool(true)
+set= get=zlib
+bool(true)
+set= get=fastlz
+bool(true)
+set=zlib get=
+bool(true)
+set=fastlz get=
+bool(true)
+set= get=
+bool(true)
+set=zstd get=zstd
+bool(true)
+set=zstd get=fastlz
+bool(true)
+set=fastlz get=zstd
+bool(true)
+set= get=zstd
+bool(true)
+set=zstd get=
+bool(true)

memcached-3.3.0.tgz/memcached-3.3.0/tests/conf_persist.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/config.inc Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/construct.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/construct_persistent.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/default_behavior.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/deleted.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/deletemulti.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/deletemultitypes.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/expire.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/flush_buffers.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/get_flags.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/getdelayed.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/getmulti.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/getserverbykey.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/getserverlist.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_155.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_21.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_500.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_77.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_90.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/gh_93.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/incrdecr.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/incrdecr_64.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/incrdecr_bykey.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/incrdecr_initial.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/incrdecr_invalid_key.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/invalid_options.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/invoke_callback.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/invoke_callback_2.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/invoke_callback_twice.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/keys_ascii.phpt Added

@@ -0,0 +1,187 @@
+--TEST--
+Test valid and invalid keys - ascii
+--SKIPIF--
+<?php include "skipif.inc";?>
+--FILE--
+<?php
+
+include dirname (__FILE__) . '/config.inc';
+$ascii = memc_get_instance (array (
+				Memcached::OPT_BINARY_PROTOCOL => false,
+				Memcached::OPT_VERIFY_KEY => true
+		));
+
+echo 'ASCII: SPACES' . PHP_EOL;
+var_dump ($ascii->set ('ascii key with spaces', 'this is a test'));
+var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+
+echo 'ASCII: NEWLINE' . PHP_EOL;
+var_dump ($ascii->set ('asciikeywithnewline' . PHP_EOL, 'this is a test'));
+var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+
+echo 'ASCII: EMPTY' . PHP_EOL;
+var_dump ($ascii->set (''/*empty key*/, 'this is a test'));
+var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+
+echo 'ASCII: TOO LONG' . PHP_EOL;
+var_dump ($ascii->set (str_repeat ('1234567890', 512), 'this is a test'));
+var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+
+echo 'ASCII: GET' . PHP_EOL;
+for ($i=0;$i<32;$i++) {
+	var_dump ($ascii->get ('asciikeywithnonprintablechar-' . chr($i) . '-here'));
+	var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+}
+
+echo 'ASCII: SET' . PHP_EOL;
+for ($i=0;$i<32;$i++) {
+	var_dump ($ascii->set ('asciikeywithnonprintablechar-' . chr($i) . '-here', 'this is a test'));
+	var_dump ($ascii->getResultCode () == Memcached::RES_BAD_KEY_PROVIDED);
+}
+
+echo 'OK' . PHP_EOL;
+
+--EXPECT--
+ASCII: SPACES
+bool(false)
+bool(true)
+ASCII: NEWLINE
+bool(false)
+bool(true)
+ASCII: EMPTY
+bool(false)
+bool(true)
+ASCII: TOO LONG
+bool(false)
+bool(true)
+ASCII: GET
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+ASCII: SET
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+OK

memcached-3.3.0.tgz/memcached-3.3.0/tests/keys_binary.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/localserver.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/memcachedserver.phpt Added

@@ -0,0 +1,118 @@
+--TEST--
+MemcachedServer
+--SKIPIF--
+<?php
+if (!extension_loaded("memcached")) {
+	die("skip memcached is not loaded\n");
+}
+if (!class_exists("MemcachedServer")) {
+	die("skip memcached not built with libmemcachedprotocol support\n");
+}
+if (Memcached::LIBMEMCACHED_VERSION_HEX < 0x1001000) {
+       die("skip needs at least libmemcached 1.1.0\n");
+}
+?>
+--FILE--
+<?php
+include __DIR__ . '/server.inc';
+$server = memcached_server_start();
+
+$cache = new Memcached();
+$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
+$cache->setOption(Memcached::OPT_COMPRESSION, false);
+$cache->addServer('127.0.0.1', 3434);
+
+$cache->add("add_key", "hello", 500);
+$cache->append("append_key", "world");
+$cache->prepend("prepend_key", "world");
+
+$cache->increment("incr", 2, 1, 500);
+$cache->decrement("decr", 2, 1, 500);
+
+$cache->delete("delete_k");
+$cache->flush(1);
+
+var_dump($cache->get('get_this'));
+
+$cache->set ('set_key', 'value 1', 100);
+$cache->replace ('replace_key', 'value 2', 200);
+
+var_dump($cache->getVersion());
+var_dump($cache->getStats());
+var_dump($cache->getStats("empty"));
+var_dump($cache->getStats("foobar"));
+var_dump($cache->getStats("scalar"));
+var_dump($cache->getStats("numeric array"));
+
+$cache->quit();
+usleep(50000);
+
+memcached_server_stop($server);
+?>
+Done
+--EXPECTF--
+Listening on 127.0.0.1:3434
+Incoming connection from 127.0.0.1:%s
+Incoming connection from 127.0.0.1:%s
+client_id=%s: Add key=add_key, value=hello, flags=0, expiration=500
+client_id=%s: Append key=append_key, value=world, cas=0
+client_id=%s: Prepend key=prepend_key, value=world, cas=0
+client_id=%s: Incrementing key=incr, delta=2, initial=1, expiration=500
+client_id=%s: Decrementing key=decr, delta=2, initial=1, expiration=500
+client_id=%s: Delete key=delete_k, cas=0
+client_id=%s: Flush when=1
+client_id=%s: Get key=get_this
+client_id=%s: Noop
+string(20) "Hello to you client!"
+client_id=%s: Set key=set_key, value=value 1, flags=0, expiration=100, cas=0
+client_id=%s: Replace key=replace_key, value=value 2, flags=0, expiration=200, cas=0
+client_id=%s: Version
+array(1) {
+  "127.0.0.1:3434"=>
+  string(5) "1.1.1"
+}
+client_id=%s: Stat key=
+array(1) {
+  "127.0.0.1:3434"=>
+  array(2) {
+    "key"=>
+    string(0) ""
+    "foo"=>
+    string(3) "bar"
+  }
+}
+client_id=%s: Stat key=empty
+array(0) {
+}
+client_id=%s: Stat key=foobar
+array(1) {
+  "127.0.0.1:3434"=>
+  array(2) {
+    "key"=>
+    string(6) "foobar"
+    "foo"=>
+    string(3) "bar"
+  }
+}
+client_id=%s: Stat key=scalar
+array(1) {
+  "127.0.0.1:3434"=>
+  array(1) {
+    0=>
+    string(%d) "you want it, you get it"
+  }
+}
+client_id=%s: Stat key=numeric array
+array(1) {
+  "127.0.0.1:3434"=>
+  array(3) {
+    -1=>
+    string(3) "one"
+    0=>
+    string(3) "two"
+    1=>
+    string(5) "three"
+  }
+}
+client_id=%s: Client quit
+Done

memcached-3.3.0.tgz/memcached-3.3.0/tests/memcachedserver6.phpt Added

@@ -0,0 +1,118 @@
+--TEST--
+MemcachedServer
+--SKIPIF--
+<?php
+if (!extension_loaded("memcached")) {
+	die("skip memcached is not loaded\n");
+}
+if (!class_exists("MemcachedServer")) {
+	die("skip memcached not built with libmemcachedprotocol support\n");
+}
+if (Memcached::LIBMEMCACHED_VERSION_HEX < 0x1001000) {
+       die("skip needs at least libmemcached 1.1.0\n");
+}
+?>
+--FILE--
+<?php
+include __DIR__ . '/server.inc';
+$server = memcached_server_start('server.php', '::1', 3434);
+
+$cache = new Memcached();
+$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
+$cache->setOption(Memcached::OPT_COMPRESSION, false);
+$cache->addServer('::1', 3434);
+
+$cache->add("add_key", "hello", 500);
+$cache->append("append_key", "world");
+$cache->prepend("prepend_key", "world");
+
+$cache->increment("incr", 2, 1, 500);
+$cache->decrement("decr", 2, 1, 500);
+
+$cache->delete("delete_k");
+$cache->flush(1);
+
+var_dump($cache->get('get_this'));
+
+$cache->set ('set_key', 'value 1', 100);
+$cache->replace ('replace_key', 'value 2', 200);
+
+var_dump($cache->getVersion());
+var_dump($cache->getStats());
+var_dump($cache->getStats("empty"));
+var_dump($cache->getStats("foobar"));
+var_dump($cache->getStats("scalar"));
+var_dump($cache->getStats("numeric array"));
+
+$cache->quit();
+usleep(50000);
+
+memcached_server_stop($server);
+?>
+Done
+--EXPECTF--
+Listening on ::1:3434
+Incoming connection from ::1:%s
+Incoming connection from ::1:%s
+client_id=%s: Add key=add_key, value=hello, flags=0, expiration=500
+client_id=%s: Append key=append_key, value=world, cas=0
+client_id=%s: Prepend key=prepend_key, value=world, cas=0
+client_id=%s: Incrementing key=incr, delta=2, initial=1, expiration=500
+client_id=%s: Decrementing key=decr, delta=2, initial=1, expiration=500
+client_id=%s: Delete key=delete_k, cas=0
+client_id=%s: Flush when=1
+client_id=%s: Get key=get_this
+client_id=%s: Noop
+string(20) "Hello to you client!"
+client_id=%s: Set key=set_key, value=value 1, flags=0, expiration=100, cas=0
+client_id=%s: Replace key=replace_key, value=value 2, flags=0, expiration=200, cas=0
+client_id=%s: Version
+array(1) {
+  "::1:3434"=>
+  string(5) "1.1.1"
+}
+client_id=%s: Stat key=
+array(1) {
+  "::1:3434"=>
+  array(2) {
+    "key"=>
+    string(0) ""
+    "foo"=>
+    string(3) "bar"
+  }
+}
+client_id=%s: Stat key=empty
+array(0) {
+}
+client_id=%s: Stat key=foobar
+array(1) {
+  "::1:3434"=>
+  array(2) {
+    "key"=>
+    string(6) "foobar"
+    "foo"=>
+    string(3) "bar"
+  }
+}
+client_id=%s: Stat key=scalar
+array(1) {
+  "::1:3434"=>
+  array(1) {
+    0=>
+    string(%d) "you want it, you get it"
+  }
+}
+client_id=%s: Stat key=numeric array
+array(1) {
+  "::1:3434"=>
+  array(3) {
+    -1=>
+    string(3) "one"
+    0=>
+    string(3) "two"
+    1=>
+    string(5) "three"
+  }
+}
+client_id=%s: Client quit
+Done

memcached-3.3.0.tgz/memcached-3.3.0/tests/multi_order.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/no-not-found.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/options.phpt Added

@@ -0,0 +1,75 @@
+--TEST--
+Memcached options
+--SKIPIF--
+<?php include "skipif.inc";?>
+--FILE--
+<?php 
+$m = new Memcached();
+$m->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP);
+
+var_dump($m->getOption(Memcached::OPT_COMPRESSION));
+var_dump($m->getOption(Memcached::OPT_SERIALIZER));
+var_dump($m->getOption(Memcached::OPT_SOCKET_SEND_SIZE));
+
+$m->setOption(Memcached::OPT_PREFIX_KEY, "\x01");
+
+var_dump($m->getOption(Memcached::OPT_HASH) == Memcached::HASH_DEFAULT);
+$m->setOption(Memcached::OPT_HASH, Memcached::HASH_MURMUR);
+var_dump($m->getOption(Memcached::OPT_HASH) == Memcached::HASH_MURMUR);
+
+
+$m->setOption(Memcached::OPT_COMPRESSION_TYPE, Memcached::COMPRESSION_ZLIB);
+var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_ZLIB);
+
+$m->setOption(Memcached::OPT_COMPRESSION_TYPE, Memcached::COMPRESSION_FASTLZ);
+var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_FASTLZ);
+
+var_dump($m->setOption(Memcached::OPT_COMPRESSION_TYPE, 0));
+var_dump($m->getOption(Memcached::OPT_COMPRESSION_TYPE) == Memcached::COMPRESSION_FASTLZ);
+
+echo "item_size_limit setOption\n";
+var_dump($m->setOption(Memcached::OPT_ITEM_SIZE_LIMIT, 0));
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) === 0);
+var_dump($m->setOption(Memcached::OPT_ITEM_SIZE_LIMIT, -1));
+var_dump($m->setOption(Memcached::OPT_ITEM_SIZE_LIMIT, 1000000));
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) == 1000000);
+
+echo "item_size_limit ini\n";
+ini_set('memcached.item_size_limit', '0');
+$m = new Memcached();
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) === 0);
+
+ini_set('memcached.item_size_limit', '1000000');
+$m = new Memcached();
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) == 1000000);
+
+ini_set('memcached.item_size_limit', null);
+$m = new Memcached();
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) === 0);
+?>
+--EXPECTF--
+bool(true)
+int(1)
+
+Warning: Memcached::getOption(): no servers defined in %s on line %d
+NULL
+
+Warning: Memcached::setOption(): bad key provided in %s on line %d
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+item_size_limit setOption
+bool(true)
+bool(true)
+
+Warning: Memcached::setOption(): ITEM_SIZE_LIMIT must be >= 0 in %s on line %d
+bool(false)
+bool(true)
+bool(true)
+item_size_limit ini
+bool(true)
+bool(true)
+bool(true)

memcached-3.3.0.tgz/memcached-3.3.0/tests/pr_75.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/prepend.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/replace.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/rescode.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/reset_keyprefix.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/sasl_basic.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/server.inc Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/server.php Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_emptyprefix.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_locktime.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_persistent.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_prefix.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_servers-php72.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_badconf_servers.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_basic.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_basic2.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_basic3.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_lazy_warning.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_lock-php71.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_lock.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_persistent.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/session_regenerate.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/set_encoding_key.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/set_encoding_key2.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/set_large.phpt Added

memcached-3.3.0.tgz/memcached-3.3.0/tests/setmulti.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/setoptions.phpt Added

@@ -0,0 +1,48 @@
+--TEST--
+Set options using setOptions
+--SKIPIF--
+<?php include "skipif.inc";?>
+--FILE--
+<?php
+$m = new Memcached();
+
+/* existing options */
+var_dump($m->setOptions(array(
+	Memcached::OPT_PREFIX_KEY => 'a_prefix',
+	Memcached::OPT_SERIALIZER => Memcached::SERIALIZER_PHP,
+	Memcached::OPT_COMPRESSION => 0,
+	Memcached::OPT_LIBKETAMA_COMPATIBLE => 1,
+	Memcached::OPT_CONNECT_TIMEOUT => 5000,
+	Memcached::OPT_ITEM_SIZE_LIMIT => 1000000,
+)));
+
+var_dump($m->getOption(Memcached::OPT_PREFIX_KEY) == 'a_prefix');
+var_dump($m->getOption(Memcached::OPT_SERIALIZER) == Memcached::SERIALIZER_PHP);
+var_dump($m->getOption(Memcached::OPT_COMPRESSION) == 0);
+var_dump($m->getOption(Memcached::OPT_LIBKETAMA_COMPATIBLE) == 1);
+var_dump($m->getOption(Memcached::OPT_ITEM_SIZE_LIMIT) == 1000000);
+
+echo "test invalid options\n";
+
+var_dump($m->setOptions(array(
+	"asdf" => 123
+)));
+
+var_dump($m->setOptions(array(
+	-1 => 123
+)));
+
+--EXPECTF--
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+test invalid options
+
+Warning: Memcached::setOptions(): invalid configuration option in %s on line %d
+bool(false)
+
+Warning: Memcached::setOptions(): error setting memcached option: %s in %s on line %d
+bool(false)

memcached-3.3.0.tgz/memcached-3.3.0/tests/skipif.inc Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/stats.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/stats_hang.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/testdata.res Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/touch_binary.phpt Added

@@ -0,0 +1,73 @@
+--TEST--
+Touch in binary mode
+--SKIPIF--
+<?php
+$min_version = "1.4.8"; //TOUCH is added since 1.4.8
+include dirname(__FILE__) . "/skipif.inc";
+// The touch command in binary mode will work in libmemcached 1.0.16, but runs out the timeout clock
+// See https://github.com/php-memcached-dev/php-memcached/issues/310 for further explanation
+// The problem is fixed fully in libmemcached 1.0.18, so we'll focus tests on that version
+if (Memcached::LIBMEMCACHED_VERSION_HEX < 0x01000018) die ('skip too old libmemcached');
+?>
+--FILE--
+<?php
+
+function resolve_to_constant ($code)
+{
+	$refl = new ReflectionClass ('memcached');
+	$c = $refl->getConstants ();
+	
+	foreach ($c as $name => $value) {
+		if (strpos ($name, 'RES_') === 0 && $value == $code)
+			return $name;
+	}
+}
+
+function status_print ($op, $mem, $expected)
+{
+	$code = $mem->getResultcode();
+
+	if ($code == $expected)
+		echo "{$op} status code as expected" . PHP_EOL;
+	else {
+		$expected = resolve_to_constant ($expected);
+		$code = resolve_to_constant ($code);
+		
+		echo "{$op} status code mismatch, expected {$expected} but got {$code}" . PHP_EOL;
+	}
+}
+
+include dirname (__FILE__) . '/config.inc';
+$mem = memc_get_instance (array (Memcached::OPT_BINARY_PROTOCOL => true));
+
+$key = uniqid ('touch_t_');
+
+$mem->get($key);
+status_print ('get', $mem, Memcached::RES_NOTFOUND);
+
+$mem->set ($key, 1);
+status_print ('set', $mem, Memcached::RES_SUCCESS);
+
+$mem->get($key);
+status_print ('get', $mem, Memcached::RES_SUCCESS);
+
+$mem->touch ($key, 10);
+status_print ('touch', $mem, Memcached::RES_SUCCESS);
+
+$mem->get($key);
+status_print ('get', $mem, Memcached::RES_SUCCESS);
+
+$mem->get($key);
+status_print ('get', $mem, Memcached::RES_SUCCESS);
+
+echo "OK\n";
+
+?>
+--EXPECT--
+get status code as expected
+set status code as expected
+get status code as expected
+touch status code as expected
+get status code as expected
+get status code as expected
+OK

memcached-3.3.0.tgz/memcached-3.3.0/tests/types.inc Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_igbinary.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_igbinary_multi.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_json.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_json_multi.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_msgpack.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_msgpack_multi.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_php.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/types_php_multi.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/undefined_set.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/user-flags.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/vbucket.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/vbucket_error_7.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/vbucket_error_8.phpt Changed

memcached-3.3.0.tgz/memcached-3.3.0/tests/version.phpt Changed

memcached-3.2.0.tgz/package.xml -> memcached-3.3.0.tgz/package.xml Changed

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
-<package packagerversion="1.10.13" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
+<package packagerversion="1.10.15" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
  <name>memcached</name>
  <channel>pecl.php.net</channel>
  <summary>PHP extension for interfacing with memcached via libmemcached library</summary>
@@ -28,11 +28,17 @@
   <email>remi@php.net</email>
   <active>yes</active>
  </lead>
- <date>2022-03-24</date>
- <time>11:52:50</time>
+ <lead>
+  <name>Michael Wallner</name>
+  <user>mike</user>
+  <email>mike@php.net</email>
+  <active>yes</active>
+ </lead>
+ <date>2024-10-17</date>
+ <time>17:34:21</time>
  <version>
-  <release>3.2.0</release>
-  <api>3.2.0</api>
+  <release>3.3.0</release>
+  <api>3.3.0</api>
  </version>
  <stability>
   <release>stable</release>
@@ -40,11 +46,17 @@
  </stability>
  <license uri="http://www.php.net/license">PHP</license>
  <notes>
-- PHP 8.0 and 8.1 support
-- store_retry_count is no more set explicitly (#452)
-- fix MemcachedServer (libmemcached-awesome is recommended)
-- code cleanup
-- fix windows build
+- Add #515 option to locally enforce payload size limit
+- Add #539 zstd support
+- Add #540 compression_level option
+- Mark password as a sensitive param for PHP 8.2
+- Upgrade Windows libmemcached to v1.1.4
+- Fix Windows PHP 8 compatibility
+- Fix #518 Windows msgpack support
+- Fix #522 signed integer overflow
+- Fix #523 incorrect PHP reflection type for Memcached::cas $cas_token
+- Fix #546 don&apos;t check key automatically, unless client-side verify_key is enabled
+- Fix #555 incompatible pointer types (32-bit)
  </notes>
  <contents>
   <dir name="/">
@@ -63,8 +75,8 @@
    <file md5sum="c209649db8e54b0b24542d4142896a52" name="tests/check_if_pristine.phpt" role="test" />
    <file md5sum="3a72f2f6e1cb0ac6a1c9eccc90ee490d" name="tests/check_key.phpt" role="test" />
    <file md5sum="d753b7841da68d7a3a9f0f14c601d0da" name="tests/clone.phpt" role="test" />
-   <file md5sum="02b42848750f01304b8b543c9f551ab8" name="tests/compression_conditions.phpt" role="test" />
-   <file md5sum="337a4a603ad6baef7ee8c622b0f278d6" name="tests/compression_types.phpt" role="test" />
+   <file md5sum="042852362ed5118723080dd995e3334f" name="tests/compression_conditions.phpt" role="test" />
+   <file md5sum="24c8d6a84b1ca107d21a93c81025dd93" name="tests/compression_types.phpt" role="test" />
    <file md5sum="f108206906e74b243e4e9ca4cec5a62c" name="tests/conf_persist.phpt" role="test" />
    <file md5sum="5f653e588dcafc00722756b35c83a539" name="tests/construct.phpt" role="test" />
    <file md5sum="09480798efb9358e3b86c3df93c27b1f" name="tests/construct_persistent.phpt" role="test" />
@@ -85,7 +97,7 @@
    <file md5sum="e666041d8ea0fd1b7d8b1a3136b35340" name="tests/localserver.phpt" role="test" />
    <file md5sum="5b846320e91090eb202cd4a5dc307225" name="tests/multi_order.phpt" role="test" />
    <file md5sum="253552a6ed8402d7fb915e11d8fa2c3c" name="tests/no-not-found.phpt" role="test" />
-   <file md5sum="4e361af2d7b2475787a644e501ce0c54" name="tests/options.phpt" role="test" />
+   <file md5sum="ef8f88009efdb7e5a608b51cff77f3c9" name="tests/options.phpt" role="test" />
    <file md5sum="52cd927ff3e4ce93bc40c0e92a06878b" name="tests/pr_75.phpt" role="test" />
    <file md5sum="9b182457d9aa8f5a4c0a11c9a5fd437f" name="tests/rescode.phpt" role="test" />
    <file md5sum="f7087831c069974dea58fdcd418d0588" name="tests/session_badconf_emptyprefix.phpt" role="test" />
@@ -98,9 +110,9 @@
    <file md5sum="aa156bf7bb4462e9173317c7e6daaeac" name="tests/session_basic2.phpt" role="test" />
    <file md5sum="515c05e73a3d1bb4e3ed6e58d256b8c4" name="tests/session_basic3.phpt" role="test" />
    <file md5sum="e97c28a1b11a7a513eadc4560db17780" name="tests/session_persistent.phpt" role="test" />
-   <file md5sum="c7030c53a0a4a70db0eb9f4931b20efd" name="tests/set_large.phpt" role="test" />
-   <file md5sum="bc001a6bdfc8535411aa509d9d40e95c" name="tests/setoptions.phpt" role="test" />
-   <file md5sum="5096ca152b3344f8dab6a2182c98ace0" name="tests/touch_binary.phpt" role="test" />
+   <file md5sum="a3b1bfa74587ee190efb82a989f06e4a" name="tests/set_large.phpt" role="test" />
+   <file md5sum="805d702bc6f370be159337cc62cb84f6" name="tests/setoptions.phpt" role="test" />
+   <file md5sum="9f9da1ab15aa1e68eca2d9654474b9f1" name="tests/touch_binary.phpt" role="test" />
    <file md5sum="977a8c648fefbfdd0281146b99566046" name="tests/types.inc" role="test" />
    <file md5sum="2efee38de0a9ac21aa08195d2f028e66" name="tests/types_igbinary.phpt" role="test" />
    <file md5sum="eb026f27e4bf6341c7a113bceca0124c" name="tests/types_igbinary_multi.phpt" role="test" />
@@ -131,7 +143,7 @@
    <file md5sum="8a4542d8276de516ec4624092d4b9a46" name="tests/incrdecr_invalid_key.phpt" role="test" />
    <file md5sum="87a62cc497a6b660a4a01d0cbf02ba35" name="tests/incrdecr_bykey.phpt" role="test" />
    <file md5sum="3925fe82126261b6589bd9cbf64a4568" name="tests/invalid_options.phpt" role="test" />
-   <file md5sum="3d4e8dc5099592914cbcd273efc93d6c" name="tests/keys_ascii.phpt" role="test" />
+   <file md5sum="16e38964cf1c1cc0ca2f4d5d769ef41a" name="tests/keys_ascii.phpt" role="test" />
    <file md5sum="5c51cc2837948891fb0c6e4c63a2e669" name="tests/keys_binary.phpt" role="test" />
    <file md5sum="a4058bd7f5993894fb867bafa57097c8" name="tests/testdata.res" role="test" />
    <file md5sum="cb4b22ed0a91765f3be48e66b28118c9" name="tests/config.inc" role="test" />
@@ -151,23 +163,23 @@
    <file md5sum="91401c7726d8fe32d303a472807f613c" name="tests/session_lock-php71.phpt" role="test" />
    <file md5sum="a4344764c217a1ebcc38c76a85e5697d" name="tests/server.inc" role="test" />
    <file md5sum="b03cb654128034ac234cc2132136081a" name="tests/server.php" role="test" />
-   <file md5sum="15b9597828a5e71c904f5d63b915217b" name="tests/memcachedserver.phpt" role="test" />
-   <file md5sum="83f16fd1ad3eb242330a599e45fb08a1" name="tests/memcachedserver6.phpt" role="test" />
-   <file md5sum="e363615c309e1ca265a16bee4b396540" name="README.markdown" role="doc" />
+   <file md5sum="e2277d14ca5ddef28317876772e16c29" name="tests/memcachedserver.phpt" role="test" />
+   <file md5sum="d90e26ff58c4e73518083bf9d2186f77" name="tests/memcachedserver6.phpt" role="test" />
+   <file md5sum="0bd2f010d5ae171e59cff0bb7ff89650" name="README.markdown" role="doc" />
    <file md5sum="f15b54956edc11e9bf1c995385b433b4" name="CREDITS" role="doc" />
    <file md5sum="cb564efdf78cce8ea6e4b5a4f7c05d97" name="LICENSE" role="doc" />
    <file md5sum="19715df9170f028156b4457cb2552050" name="ChangeLog" role="doc" />
    <file md5sum="aa4e3e907461b5ddb6dcd3a133dc393a" name="memcached-api.php" role="doc" />
-   <file md5sum="cde6e7130e5b0b245dd396b1bfdd63dd" name="memcached.ini" role="doc" />
+   <file md5sum="2ca8bb4739270ec832a2ee548cae54e4" name="memcached.ini" role="doc" />
    <file md5sum="543b3b1b8571c4b9c02eafee4a6f3fa3" name="fastlz/LICENSE" role="doc" />
-   <file md5sum="0f4f06353dc6831885e311b38d546a86" name="config.m4" role="src" />
-   <file md5sum="99852c597ceafb5429057b1e17bf7826" name="config.w32" role="src" />
-   <file md5sum="dbdaadc461126eaa9e69db72337d8afa" name="php_memcached.c" role="src" />
-   <file md5sum="0ff5c00ae1778b997a25bdfd572895d9" name="php_memcached.h" role="src" />
-   <file md5sum="dda2cf88fd462f452940e95f06609e78" name="php_memcached.stub.php" role="src" />
-   <file md5sum="760d9041d472520c09a6bcd4ce9ffab9" name="php_memcached_arginfo.h" role="src" />
-   <file md5sum="b03c1b12fdac77821097e2b7e3f11be1" name="php_memcached_legacy_arginfo.h" role="src" />
-   <file md5sum="ab8183a753b3291c30adf11872507652" name="php_memcached_private.h" role="src" />
+   <file md5sum="46c9d6eb5b0aa98b661f01713c83b9f7" name="config.m4" role="src" />
+   <file md5sum="213ab2f62bd432a52bca3613e1384289" name="config.w32" role="src" />
+   <file md5sum="18116fc48d0be39dd7b4dce5f3e3e9d7" name="php_memcached.c" role="src" />
+   <file md5sum="1a782697d4c8e9a9e2a1392333af8700" name="php_memcached.h" role="src" />
+   <file md5sum="8fdd66e2834d0ae00e20158b00094b55" name="php_memcached.stub.php" role="src" />
+   <file md5sum="124f4c1f771dafb0f8bed5630132807d" name="php_memcached_arginfo.h" role="src" />
+   <file md5sum="b7769fd4a3958cdf41903f2002363c52" name="php_memcached_legacy_arginfo.h" role="src" />
+   <file md5sum="6e26be8c7c8caba57ae48331615284cd" name="php_memcached_private.h" role="src" />
    <file md5sum="b1ecb6f476a9394e896f4a00db4a18d7" name="php_memcached_session.c" role="src" />
    <file md5sum="3c47c0ddad806318e44c4a0307179532" name="php_memcached_session.h" role="src" />
    <file md5sum="fdfd0d785240591e81437a91e5c341e3" name="php_libmemcached_compat.h" role="src" />
@@ -214,6 +226,25 @@
  </extsrcrelease>
  <changelog>
   <release>
+   <date>2022-03-24</date>
+   <version>
+    <release>3.2.0</release>
+    <api>3.2.0</api>
+   </version>
+   <stability>
+    <release>stable</release>
+    <api>stable</api>
+   </stability>
+   <license uri="http://www.php.net/license">PHP</license>
+   <notes>
+- PHP 8.0 and 8.1 support
+- store_retry_count is no more set explicitly (#452)
+- fix MemcachedServer (libmemcached-awesome is recommended)
+- code cleanup
+- fix windows build
+   </notes>
+  </release>
+  <release>
    <date>2019-12-03</date>
    <version>
     <release>3.1.5</release>