Hi!
-If you are getting this code from http://hg.tangent.org/libmemcached then
+If you are getting this code from http://launchpad.net/libmemcached then
continue reading. Otherwise these directions are not for you (well maybe...).
-To obtain code from http://hg.tangent.org/libmemcached you will need to issue
-the following command:
+To obtain code from http://bazaar.launchpad.net/libmemcached you will need to
+issue the following command:
-hg clone http://hg.tangent.org/libmemcached
+bzr branch lp:libmemcached
Once the tree is cloned you will need to build the "configure" script. You
can do this by running the script:
-./config/bootstrap
+./config/autogen.sh
It will set up all of the files you need to build libmemcached. At that
point it is just the typical "./configure; make; make test; make install"
For a tarball release do a "make dist" and for an RPM type "make rpm".
-For patches either send diffs or make use of hg's ability to do bundles. You
-can read more about this on the hg websites:
+For patches, we prefer you push a branch to launchpad and then submit that
+branch to be merged. For more information, see:
-http://www.selenic.com/mercurial/wiki/
+https://help.launchpad.net/Code/UploadingABranch
+https://help.launchpad.net/Code/Review
Thanks and keep hacking!
uint32_t flags;
unsigned int fetch_key;
- fetch_key= random() % number_of;
+ fetch_key= (unsigned int)(random() % number_of);
value= memcached_get(memc, pairs[fetch_key].key, pairs[fetch_key].key_length,
&value_length, &flags, &rc);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t)opt_binary);
while (optind < argc)
{
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t)opt_binary);
while (optind < argc)
{
ptr, opt_flags, (unsigned long long)opt_expires);
}
- if ((file_buffer_ptr= (char *)malloc(sizeof(char) * sbuf.st_size)) == NULL)
+ if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
{
fprintf(stderr, "malloc: %s\n", strerror(errno));
exit(1);
}
- if ((read_length= read(fd, file_buffer_ptr, sbuf.st_size)) == -1)
+ if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
{
fprintf(stderr, "read: %s\n", strerror(errno));
exit(1);
if (opt_method == OPT_ADD)
rc= memcached_add(memc, ptr, strlen(ptr),
- file_buffer_ptr, sbuf.st_size,
+ file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else if (opt_method == OPT_REPLACE)
rc= memcached_replace(memc, ptr, strlen(ptr),
- file_buffer_ptr, sbuf.st_size,
+ file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else
rc= memcached_set(memc, ptr, strlen(ptr),
- file_buffer_ptr, sbuf.st_size,
+ file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
if (rc != MEMCACHED_SUCCESS)
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t)opt_binary);
rc= memcached_dump(memc, callbacks, NULL, 1);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t) opt_binary);
rc = memcached_flush(memc, opt_expire);
if (rc != MEMCACHED_SUCCESS)
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t) opt_binary);
while (optind < argc)
{
memset(&conclusion, 0, sizeof(conclusions_st));
- srandom(time(NULL));
+ srandom((unsigned int)time(NULL));
options_parse(argc, argv);
if (!opt_servers)
/* We need to set udp behavior before adding servers to the client */
if (opt_udp_io)
{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, opt_udp_io);
- unsigned int x= 0;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,
+ (uint64_t)opt_udp_io);
for(x= 0; x < servers[0].count; x++ )
servers[x].type= MEMCACHED_CONNECTION_UDP;
}
memcached_server_push(memc, servers);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
+ (uint64_t)opt_binary);
if (opt_flush)
flush_all(memc);
}
break;
case OPT_SLAP_CONCURRENCY:
- opt_concurrency= strtol(optarg, (char **)NULL, 10);
+ opt_concurrency= (unsigned int)strtoul(optarg, (char **)NULL, 10);
break;
case OPT_SLAP_EXECUTE_NUMBER:
- opt_execute_number= strtol(optarg, (char **)NULL, 10);
+ opt_execute_number= (unsigned int)strtoul(optarg, (char **)NULL, 10);
break;
case OPT_SLAP_INITIAL_LOAD:
- opt_createial_load= strtol(optarg, (char **)NULL, 10);
+ opt_createial_load= (unsigned int)strtoul(optarg, (char **)NULL, 10);
break;
case '?':
/* getopt_long already printed an error message. */
case GET_TEST:
execute_get(memc, context->initial_pairs, context->initial_number);
break;
+ default:
+ WATCHPOINT_ASSERT(context->test);
+ break;
}
memcached_free(memc);
pairs_st *load_create_data(memcached_st *memc, unsigned int number_of,
unsigned int *actual_loaded)
{
- memcached_st *clone;
+ memcached_st *memc_clone;
pairs_st *pairs;
- clone= memcached_clone(NULL, memc);
+ memc_clone= memcached_clone(NULL, memc);
/* We always used non-blocking IO for load since it is faster */
- memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
pairs= pairs_generate(number_of, 400);
- *actual_loaded= execute_set(clone, pairs, number_of);
+ *actual_loaded= execute_set(memc_clone, pairs, number_of);
- memcached_free(clone);
+ memcached_free(memc_clone);
return pairs;
}
{
memcached_return rc;
memcached_st *memc;
- memcached_stat_st *stat;
+ memcached_stat_st *memc_stat;
memcached_server_st *servers;
memcached_server_st *server_list;
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
- stat= memcached_stat(memc, NULL, &rc);
+ memc_stat= memcached_stat(memc, NULL, &rc);
if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_SOME_ERRORS)
{
server_list= memcached_server_list(memc);
if (opt_analyze)
- run_analyzer(memc, stat, server_list);
+ run_analyzer(memc, memc_stat, server_list);
else
- print_server_listing(memc, stat, server_list);
+ print_server_listing(memc, memc_stat, server_list);
- free(stat);
+ free(memc_stat);
free(opt_servers);
memcached_free(memc);
return 0;
}
-static void run_analyzer(memcached_st *memc, memcached_stat_st *stat,
+static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
memcached_server_st *server_list)
{
memcached_return rc;
if (analyze_mode == NULL)
{
memcached_analysis_st *report;
- report= memcached_analyze(memc, stat, &rc);
+ report= memcached_analyze(memc, memc_stat, &rc);
if (rc != MEMCACHED_SUCCESS || report == NULL)
{
printf("Failure to analyze servers (%s)\n",
}
}
-static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
+static void print_server_listing(memcached_st *memc, memcached_stat_st *memc_stat,
memcached_server_st *server_list)
{
unsigned int x;
char **list;
char **ptr;
- list= memcached_stat_get_keys(memc, &stat[x], &rc);
+ list= memcached_stat_get_keys(memc, &memc_stat[x], &rc);
printf("Server: %s (%u)\n", memcached_server_name(memc, server_list[x]),
memcached_server_port(memc, server_list[x]));
for (ptr= list; *ptr; ptr++)
{
- memcached_return rc;
- char *value= memcached_stat_get_value(memc, &stat[x], *ptr, &rc);
+ char *value= memcached_stat_get_value(memc, &memc_stat[x], *ptr, &rc);
printf("\t %s: %s\n", *ptr, value);
free(value);
{
register int us, s;
- us = a.tv_usec - b.tv_usec;
+ us = (int)(a.tv_usec - b.tv_usec);
us /= 1000;
- s = a.tv_sec - b.tv_sec;
+ s = (int)(a.tv_sec - b.tv_sec);
s *= 1000;
return s + us;
}
case OPT_BINARY: return("Switch to binary protocol.");
case OPT_ANALYZE: return("Analyze the provided servers.");
case OPT_UDP: return("Use UDP protocol when communicating with server.");
+ default: WATCHPOINT_ASSERT(0);
};
WATCHPOINT_ASSERT(0);
--- /dev/null
+#!/usr/bin/env bash
+# Taken from lighthttpd server (BSD). Thanks Jan!
+# Run this to generate all the initial makefiles, etc.
+
+die() { echo "$@"; exit 1; }
+
+# LIBTOOLIZE=${LIBTOOLIZE:-libtoolize}
+LIBTOOLIZE_FLAGS=" --automake --copy --force"
+# ACLOCAL=${ACLOCAL:-aclocal}
+ACLOCAL_FLAGS="-I m4"
+# AUTOHEADER=${AUTOHEADER:-autoheader}
+# AUTOMAKE=${AUTOMAKE:-automake}
+AUTOMAKE_FLAGS="--add-missing --copy --force"
+# AUTOCONF=${AUTOCONF:-autoconf}
+
+ARGV0=$0
+ARGS="$@"
+
+
+run() {
+ echo "$ARGV0: running \`$@' $ARGS"
+ $@ $ARGS
+}
+
+## jump out if one of the programs returns 'false'
+set -e
+
+## We do not currently support glibtoolize
+if test x$LIBTOOLIZE = x; then
+ if test \! "x`which glibtoolize 2> /dev/null | grep -v '^no'`" = x; then
+ LIBTOOLIZE=glibtoolize
+ elif test \! "x`which libtoolize-1.5 2> /dev/null | grep -v '^no'`" = x; then
+ LIBTOOLIZE=libtoolize-1.5
+ elif test \! "x`which libtoolize 2> /dev/null | grep -v '^no'`" = x; then
+ LIBTOOLIZE=libtoolize
+ else
+ echo "libtoolize 1.5.x wasn't found, exiting"; exit 0
+ fi
+fi
+
+## suse has aclocal and aclocal-1.9
+if test x$ACLOCAL = x; then
+ if test \! "x`which aclocal-1.10 2> /dev/null | grep -v '^no'`" = x; then
+ ACLOCAL=aclocal-1.10
+ elif test \! "x`which aclocal-1.9 2> /dev/null | grep -v '^no'`" = x; then
+ ACLOCAL=aclocal-1.9
+ elif test \! "x`which aclocal19 2> /dev/null | grep -v '^no'`" = x; then
+ ACLOCAL=aclocal19
+ elif test \! "x`which aclocal 2> /dev/null | grep -v '^no'`" = x; then
+ ACLOCAL=aclocal
+ else
+ echo "automake 1.9.x (aclocal) wasn't found, exiting"; exit 0
+ fi
+fi
+
+if test x$AUTOMAKE = x; then
+ if test \! "x`which automake-1.10 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOMAKE=automake-1.10
+ elif test \! "x`which automake-1.9 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOMAKE=automake-1.9
+ elif test \! "x`which automake19 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOMAKE=automake19
+ elif test \! "x`which automake 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOMAKE=automake
+ else
+ echo "automake 1.9.x wasn't found, exiting"; exit 0
+ fi
+fi
+
+
+## macosx has autoconf-2.59 and autoconf-2.60
+if test x$AUTOCONF = x; then
+ if test \! "x`which autoconf-2.59 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOCONF=autoconf-2.59
+ elif test \! "x`which autoconf259 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOCONF=autoconf259
+ elif test \! "x`which autoconf 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOCONF=autoconf
+ else
+ echo "autoconf 2.59+ wasn't found, exiting"; exit 0
+ fi
+fi
+
+if test x$AUTOHEADER = x; then
+ if test \! "x`which autoheader-2.59 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOHEADER=autoheader-2.59
+ elif test \! "x`which autoheader259 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOHEADER=autoheader259
+ elif test \! "x`which autoheader 2> /dev/null | grep -v '^no'`" = x; then
+ AUTOHEADER=autoheader
+ else
+ echo "autoconf 2.59+ (autoheader) wasn't found, exiting"; exit 0
+ fi
+fi
+
+
+# --force means overwrite ltmain.sh script if it already exists
+run $LIBTOOLIZE $LIBTOOLIZE_FLAGS || die "Can't execute libtoolize"
+
+run $ACLOCAL $ACLOCAL_FLAGS || die "Can't execute aclocal"
+run $AUTOHEADER || die "Can't execute autoheader"
+
+# --add-missing instructs automake to install missing auxiliary files
+# and --force to overwrite them if they already exist
+run $AUTOMAKE $AUTOMAKE_FLAGS || die "Can't execute automake"
+run $AUTOCONF || die "Can't execute autoconf"
+
+echo -n "Automade with: "
+$AUTOMAKE --version | head -1
+echo -n "Configured with: "
+$AUTOCONF --version | head -1
+
+++ /dev/null
-#!/usr/bin/env bash
-# Taken from lighthttpd server (BSD). Thanks Jan!
-# Run this to generate all the initial makefiles, etc.
-
-die() { echo "$@"; exit 1; }
-
-# LIBTOOLIZE=${LIBTOOLIZE:-libtoolize}
-LIBTOOLIZE_FLAGS=" --automake --copy --force"
-# ACLOCAL=${ACLOCAL:-aclocal}
-ACLOCAL_FLAGS="-I m4"
-# AUTOHEADER=${AUTOHEADER:-autoheader}
-# AUTOMAKE=${AUTOMAKE:-automake}
-AUTOMAKE_FLAGS="--add-missing --copy --force"
-# AUTOCONF=${AUTOCONF:-autoconf}
-
-ARGV0=$0
-ARGS="$@"
-
-
-run() {
- echo "$ARGV0: running \`$@' $ARGS"
- $@ $ARGS
-}
-
-## jump out if one of the programs returns 'false'
-set -e
-
-## We do not currently support glibtoolize
-if test x$LIBTOOLIZE = x; then
- if test \! "x`which glibtoolize 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=glibtoolize
- elif test \! "x`which libtoolize-1.5 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=libtoolize-1.5
- elif test \! "x`which libtoolize 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=libtoolize
- else
- echo "libtoolize 1.5.x wasn't found, exiting"; exit 0
- fi
-fi
-
-## suse has aclocal and aclocal-1.9
-if test x$ACLOCAL = x; then
- if test \! "x`which aclocal-1.10 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal-1.10
- elif test \! "x`which aclocal-1.9 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal-1.9
- elif test \! "x`which aclocal19 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal19
- elif test \! "x`which aclocal 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal
- else
- echo "automake 1.9.x (aclocal) wasn't found, exiting"; exit 0
- fi
-fi
-
-if test x$AUTOMAKE = x; then
- if test \! "x`which automake-1.10 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake-1.10
- elif test \! "x`which automake-1.9 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake-1.9
- elif test \! "x`which automake19 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake19
- elif test \! "x`which automake 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake
- else
- echo "automake 1.9.x wasn't found, exiting"; exit 0
- fi
-fi
-
-
-## macosx has autoconf-2.59 and autoconf-2.60
-if test x$AUTOCONF = x; then
- if test \! "x`which autoconf-2.59 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf-2.59
- elif test \! "x`which autoconf259 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf259
- elif test \! "x`which autoconf 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf
- else
- echo "autoconf 2.59+ wasn't found, exiting"; exit 0
- fi
-fi
-
-if test x$AUTOHEADER = x; then
- if test \! "x`which autoheader-2.59 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader-2.59
- elif test \! "x`which autoheader259 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader259
- elif test \! "x`which autoheader 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader
- else
- echo "autoconf 2.59+ (autoheader) wasn't found, exiting"; exit 0
- fi
-fi
-
-
-# --force means overwrite ltmain.sh script if it already exists
-run $LIBTOOLIZE $LIBTOOLIZE_FLAGS || die "Can't execute libtoolize"
-
-run $ACLOCAL $ACLOCAL_FLAGS || die "Can't execute aclocal"
-run $AUTOHEADER || die "Can't execute autoheader"
-
-# --add-missing instructs automake to install missing auxiliary files
-# and --force to overwrite them if they already exist
-run $AUTOMAKE $AUTOMAKE_FLAGS || die "Can't execute automake"
-run $AUTOCONF || die "Can't execute autoconf"
--- /dev/null
+autorun.sh
\ No newline at end of file
+# libmemcached
+# Copyright (C) 2008 Brian Aker
+# All rights reserved.
+#
+# Use and distribution licensed under the BSD license. See
+# the COPYING file in this directory for full text.
+
+AC_PREREQ(2.59)
AC_INIT([libmemcached],[0.30],[http://tangent.org/552/libmemcached.html])
-AC_CONFIG_SRCDIR([clients/memcat.c])
+AC_CONFIG_SRCDIR([libmemcached/memcached.c])
AC_CONFIG_AUX_DIR(config)
AM_CONFIG_HEADER(libmemcached/libmemcached_config.h)
-
-# Setting CFLAGS here prevents AC_CANONICAL_TARGET from injecting them
-SAVE_CFLAGS=${CFLAGS}
-SAVE_CXXFLAGS=${CXXFLAGS}
-CFLAGS=
-CXXFLAGS=
-
-AC_CANONICAL_TARGET
-
-CFLAGS=${SAVE_CFLAGS}
-CXXFLAGS=${SAVE_CXXFLAGS}
+AC_CONFIG_MACRO_DIR([m4])
#shared library versioning
MEMCACHED_LIBRARY_VERSION=2:0:0
MEMCACHEDUTIL_LIBRARY_VERSION=0:0:0
AC_SUBST(MEMCACHEDUTIL_LIBRARY_VERSION)
-AM_INIT_AUTOMAKE(nostdinc no-define -Wall -Werror)
-AC_USE_SYSTEM_EXTENSIONS
+# Setting CFLAGS here prevents AC_CANONICAL_TARGET from injecting them
+SAVE_CFLAGS=${CFLAGS}
+SAVE_CXXFLAGS=${CXXFLAGS}
+CFLAGS=
+CXXFLAGS=
+
+AC_CANONICAL_TARGET
+
+CFLAGS=${SAVE_CFLAGS}
+CXXFLAGS=${SAVE_CXXFLAGS}
+
+AM_INIT_AUTOMAKE([-Wall -Werror nostdinc subdir-objects])
+
+if test "x${enable_dependency_tracking}" = "x"
+then
+ enable_dependency_tracking=yes
+fi
+
+if test -d "${srcdir}/.bzr"
+then
+ building_from_bzr=yes
+else
+ building_from_bzr=no
+fi
-AC_PROG_CC
-AC_PROG_CC_C99
AC_PROG_CXX
-AC_PROG_LIBTOOL
-AM_SANITY_CHECK
+
+ACX_USE_SYSTEM_EXTENSIONS
+
+AC_PROG_CPP
+AM_PROG_CC_C_O
+
+FORCE_MAC_GCC42
+dnl Once we can use a modern autoconf, we can use this
+dnl AC_PROG_CC_C99
+
+AC_C_BIGENDIAN
+AC_C_CONST
+AC_HEADER_TIME
+AC_TYPE_SIZE_T
+AC_FUNC_MALLOC
+AC_FUNC_REALLOC
AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
+# We use libtool
+AC_PROG_LIBTOOL
+
+AC_MSG_CHECKING("C Compiler version")
+if test "$GCC" = "yes"
+then
+ CC_VERSION=`$CC --version | sed 1q`
+elif test "$SUNCC" = "yes"
+then
+ CC_VERSION=`$CC -V 2>&1 | sed 1q`
+else
+ CC_VERSION=""
+fi
+AC_MSG_RESULT("$CC_VERSION")
+AC_SUBST(CC_VERSION)
# libmemcached versioning when linked with GNU ld.
if test "$lt_cv_prog_gnu_ld" = "yes"
AC_SUBST(LD_VERSION_SCRIPT)
AC_SUBST(LD_UTIL_VERSION_SCRIPT)
-AC_C_CONST
-AC_HEADER_TIME
-AC_TYPE_SIZE_T
+# Build optimized or debug version ?
+# First check for gcc and g++
+if test "$GCC" = "yes"
+then
+
+ dnl Once we can use a modern autoconf, we can replace the std=gnu99 here
+ dnl with using AC_CC_STD_C99 above
+ CC="${CC} -std=gnu99"
+
+ CFLAGS="-ggdb3 ${CFLAGS}"
+ CXXFLAGS="-ggdb3 ${CXXFLAGS}"
+
+ DEBUG_CFLAGS="-O0"
+ DEBUG_CXXFLAGS="-O0"
+
+ OPTIMIZE_CFLAGS="-O3"
+ OPTIMIZE_CXXFLAGS="-O3"
+fi
+if test "x$SUNCC" = "xyes"
+then
+ dnl Once we can use a modern autoconf, we can replace the -xc99=all here
+ dnl with using AC_CC_STD_C99 above
+ CC="${CC} -xc99=all"
+
+ CFLAGS="-g -mt ${CFLAGS}"
+ CXXFLAGS="-xlang=c99 -g -mt -compat=5 -library=stlport4 -template=no%extdef ${CXXFLAGS}"
+
+ OPTIMIZE_FLAGS="-xO4 -xlibmil -xdepend -xbuiltin"
+ OPTIMIZE_CFLAGS="${OPTIMIZE_FLAGS} -Xa -xstrconst"
+ OPTIMIZE_CXXFLAGS="${OPTIMIZE_FLAGS}"
+
+fi
+
+ENABLE_64BIT
+
+#--------------------------------------------------------------------
+# Check for libpthread
+#--------------------------------------------------------------------
+
+ACX_PTHREAD(,AC_MSG_ERROR(could not find libpthread))
+LIBS="${PTHREAD_LIBS} ${LIBS}"
+CFLAGS="${PTHREAD_CFLAGS} ${CFLAGS}"
+CC="$PTHREAD_CC"
+
+
AC_SEARCH_LIBS(getopt_long, gnugetopt)
AC_SEARCH_LIBS(socket, socket)
AC_SEARCH_LIBS(gethostbyname, nsl)
AC_SUBST(LIBM)
LIBS="$save_LIBS"
+
AC_SEARCH_LIBS(floorf, m)
+dnl Specialty checks
+DETECT_BYTEORDER
+ENABLE_UTILLIB
+ENABLE_DTRACE
+SETSOCKOPT_SANITY
+ENABLE_HSIEH_HASH
+REQUIRE_POD2MAN
+PROTOCOL_BINARY_TEST
+WITH_MEMCACHED
+ENABLE_DEPRECATED
+
+dnl TODO: Remove this define once we are using 2.61 across the board.
+# AX_HEADER_ASSERT
+# ----------------
+# Check whether to enable assertions.
+AC_DEFUN([AX_HEADER_ASSERT],
+[
+ AC_MSG_CHECKING([whether to enable assertions])
+ AC_ARG_ENABLE([assert],
+ [AS_HELP_STRING([--disable-assert],
+ [Turn off assertions])],
+ [ac_cv_assert="no"],
+ [ac_cv_assert="yes"])
+ AC_MSG_RESULT([$ac_cv_assert])
+])
+AX_HEADER_ASSERT
+
-sinclude(m4/pod2man.m4)
-sinclude(m4/debug.m4)
-sinclude(m4/dtrace.m4)
-sinclude(m4/byteorder.m4)
-sinclude(m4/64bit.m4)
-sinclude(m4/protocol_binary.m4)
-sinclude(m4/memcached.m4)
-sinclude(m4/setsockopt.m4)
-sinclude(m4/hsieh.m4)
-sinclude(m4/util.m4)
-sinclude(m4/deprecated.m4)
-
-dnl This is likely subverted by vpath builds. How do we find the original
-dnl source dir in the configure step of a vpath build?
-if test -d ".hg"
+AC_ARG_WITH([debug],
+ [AS_HELP_STRING([--with-debug],
+ [Add debug code/turns off optimizations (yes|no) @<:@default=no@:>@])],
+ [with_debug=$withval],
+ [with_debug=no])
+if test "$with_debug" = "yes"
then
- building_from_hg=yes
+ # Debugging. No optimization.
+ CFLAGS="${DEBUG_CFLAGS} -DDEBUG ${CFLAGS}"
+ CXXFLAGS="${DEBUG_CXXFLAGS} -DDEBUG ${CXXFLAGS}"
else
- building_from_hg=no
+ # Optimized version. No debug
+ CFLAGS="${OPTIMIZE_CFLAGS} ${CFLAGS}"
+ CXXFLAGS="${OPTIMIZE_CXXFLAGS} ${CXXFLAGS}"
fi
+AC_ARG_ENABLE([profiling],
+ [AS_HELP_STRING([--enable-profiling],
+ [Toggle profiling @<:@default=off@:>@])],
+ [ac_profiling="$enableval"],
+ [ac_profiling="no"])
+
+AC_ARG_ENABLE([coverage],
+ [AS_HELP_STRING([--enable-coverage],
+ [Toggle coverage @<:@default=off@:>@])],
+ [ac_coverage="$enableval"],
+ [ac_coverage="no"])
-# We only support GCC and Sun's forte at the moment
if test "$GCC" = "yes"
then
- if test "$ENABLE_DEBUG" = "yes"
- then
- CFLAGS="-O0 -DHAVE_DEBUG $CFLAGS"
- CXXFLAGS="-O0 -DHAVE_DEBUG $CXXFLAGS"
- else
- CFLAGS="-O3 $CFLAGS"
- CXXFLAGS="-O3 $CXXFLAGS"
- fi
- if test "$building_from_hg" = "yes"
- then
- CFLAGS="-Werror $CFLAGS"
- CXXFLAGS="-Werror $CXXFLAGS"
- fi
-
- CFLAGS="-W -std=iso9899:1999 -Wall -Wextra -Wno-strict-aliasing -pedantic -Wundef -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls -ggdb3 $CFLAGS"
- CXXFLAGS="-W -Wall -Wextra -Wno-strict-aliasing -pedantic -Wundef -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wold-style-cast -Weffc++ -Wconversion -Wmissing-declarations -Wredundant-decls -ggdb3 $CXXFLAGS"
+ AC_CACHE_CHECK([whether it is safe to use -fdiagnostics-show-option],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="-fdiagnostics-show-option ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([],[])],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_=yes],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_=no])
+ CFLAGS="$save_CFLAGS"])
-fi
+ AS_IF([test "$ac_cv_safe_to_use_fdiagnostics_show_option_" = "yes"],
+ [
+ F_DIAGNOSTICS_SHOW_OPTION="-fdiagnostics-show-option"
+ ])
+
+ AC_CACHE_CHECK([whether it is safe to use -Wconversion],
+ [ac_cv_safe_to_use_wconversion_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="-Werror -Wconversion ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([[
+#include <stdbool.h>
+void foo(bool a)
+{
+ (void)a;
+}
+ ]],[[
+foo(0);
+ ]])],
+ [ac_cv_safe_to_use_wconversion_=yes],
+ [ac_cv_safe_to_use_wconversion_=no])
+ CFLAGS="$save_CFLAGS"])
+
+ AS_IF([test "$ac_cv_safe_to_use_wconversion_" = "yes"],
+ [W_CONVERSION="-Wconversion"
+ AC_CACHE_CHECK([whether it is safe to use -Wconversion with htons],
+ [ac_cv_safe_to_use_Wconversion_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="-Werror -Wconversion ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM(
+ [[
+#include <netinet/in.h>
+ ]],[[
+uint16_t x= htons(80);
+ ]])],
+ [ac_cv_safe_to_use_Wconversion_=yes],
+ [ac_cv_safe_to_use_Wconversion_=no])
+ CFLAGS="$save_CFLAGS"])
+
+ AS_IF([test "$ac_cv_safe_to_use_Wconversion_" = "no"],
+ [
+ NO_CONVERSION="-Wno-conversion"
+ ])
+ ])
+
+ AS_IF([test "$ac_profiling" = "yes"],
+ [CC_PROFILING="-pg"])
+
+ AS_IF([test "$ac_coverage" = "yes"],
+ [CC_COVERAGE="-fprofile-arcs -ftest-coverage"])
+
+ AS_IF([test "$building_from_bzr" = "yes"],
+ [W_FAIL="-Werror"])
+ BASE_WARNINGS="-pedantic -Wall -Wextra ${W_FAIL} -Wundef -Wshadow -Wmissing-declarations -Wstrict-aliasing -Wformat=2 ${F_DIAGNOSTICS_SHOW_OPTION} ${W_CONVERSION}"
+ CC_WARNINGS="${BASE_WARNINGS} -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wswitch-default -Wswitch-enum -Wcast-align"
+ CXX_WARNINGS="${BASE_WARNINGS} -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wold-style-cast -Weffc++ -Wno-long-long"
+
+ AC_CACHE_CHECK([whether it is safe to use -Wlogical-op],
+ [ac_cv_safe_to_use_Wlogical_op_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="-Wlogical-op"
+ AC_COMPILE_IFELSE([
+ AC_LANG_PROGRAM(
+ [[
+#include <stdio>
+ ]], [[]])
+ ],
+ [ac_cv_safe_to_use_Wlogical_op_=yes],
+ [ac_cv_safe_to_use_Wlogical_op_=no])
+ CFLAGS="$save_CFLAGS"])
+ AS_IF([test "$ac_cv_safe_to_use_Wlogical_op_" = "yes"],
+ [CC_WARNINGS="${CC_WARNINGS} -Wlogical-op"])
+
+ AC_CACHE_CHECK([whether it is safe to use -Wredundant-decls from C++],
+ [ac_cv_safe_to_use_Wredundant_decls_],
+ [AC_LANG_PUSH(C++)
+ save_CXXFLAGS="${CXXFLAGS}"
+ CXXFLAGS="${CXXFLAGS} ${W_FAIL} -Wredundant-decls"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([
+template <typename E> struct C { void foo(); };
+template <typename E> void C<E>::foo() { }
+template <> void C<int>::foo();
+ AC_INCLUDES_DEFAULT])],
+ [ac_cv_safe_to_use_Wredundant_decls_=yes],
+ [ac_cv_safe_to_use_Wredundant_decls_=no])
+ CXXFLAGS="${save_CXXFLAGS}"
+ AC_LANG_POP()])
+ AS_IF([test "$ac_cv_safe_to_use_Wredundant_decls_" = "yes"],
+ [CXX_WARNINGS="${CXX_WARNINGS} -Wredundant-decls"],
+ [CXX_WARNINGS="${CXX_WARNINGS} -Wno-redundant-decls"])
+
+ NO_REDUNDANT_DECLS="-Wno-redundant-decls"
+fi
if test "$SUNCC" = "yes"
then
- if test "$ENABLE_DEBUG" = "yes"
- then
- CFLAGS="-xO0 -DHAVE_DEBUG $CFLAGS"
- CXXFLAGS="-xO0 -DHAVE_DEBUG $CXXFLAGS"
- else
- CFLAGS="-xO4 -xlibmil -xdepend $CFLAGS"
- CXXFLAGS="-xO4 -xlibmil -xdepend $CXXFLAGS"
- fi
- if test "$building_from_hg" = "yes"
- then
- CFLAGS="-errwarn $CFLAGS"
- CXXFLAGS="-errwarn $CXXFLAGS"
- fi
- CFLAGS="-Xa -xstrconst -mt -errfmt=error -errshort=tags ${CFLAGS}"
- CXXFLAGS="+w +w2 -xwe -mt ${CXXFLAGS}"
+ AS_IF([test "$ac_profiling" = "yes"],
+ [CC_PROFILING="-xinstrument=datarace"])
+
+ AS_IF([test "$building_from_bzr" = "yes"],
+ [W_FAIL="-errwarn=%all"])
+
+ AC_CACHE_CHECK([whether E_PASTE_RESULT_NOT_TOKEN is usable],
+ [ac_cv_paste_result],
+ [
+ save_CFLAGS="${CFLAGS}"
+ CFLAGS="-errwarn=%all -erroff=E_PASTE_RESULT_NOT_TOKEN ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([
+ AC_INCLUDES_DEFAULT
+ ],[
+ int x= 0;])],
+ [ac_cv_paste_result=yes],
+ [ac_cv_paste_result=no])
+ CFLAGS="${save_CFLAGS}"
+ ])
+ AS_IF([test $ac_cv_paste_result = yes],
+ [W_PASTE_RESULT=",E_PASTE_RESULT_NOT_TOKEN"])
+
+
+ CC_WARNINGS="-v -errtags=yes ${W_FAIL} -erroff=E_INTEGER_OVERFLOW_DETECTED${W_PASTE_RESULT}"
+ CXX_WARNINGS="+w +w2 -xwe -xport64 -errtags=yes ${W_FAIL}"
fi
+AC_SUBST(NO_CONVERSION)
+AC_SUBST(NO_REDUNDANT_DECLS)
AM_CPPFLAGS="-I\$(top_srcdir) -I\$(top_builddir) ${CPPFLAGS}"
-AM_CFLAGS="${CFLAGS}"
-AM_CXXFLAGS="${CXXFLAGS}"
+AM_CFLAGS="${CC_WARNINGS} ${CC_PROFILING} ${CC_COVERAGE} ${CFLAGS}"
+AM_CXXFLAGS="${CXX_WARNING} ${CC_PROFILING} ${CC_COVERAGE} ${CXXFLAGS}"
AC_SUBST([AM_CPPFLAGS])
AC_SUBST([AM_CFLAGS])
support/libmemcached-fc.spec
])
AC_OUTPUT
+
+echo "---"
+echo "Configuration summary for $PACKAGE_NAME version $VERSION"
+echo ""
+echo " * Installation prefix: $prefix"
+echo " * System type: $host_vendor-$host_os"
+echo " * Host CPU: $host_cpu"
+echo " * C Compiler: $CC_VERSION"
+echo " * Assertions enabled: $ac_cv_assert"
+echo " * Debug enabled: $with_debug"
+echo " * Warnings as failure: $building_from_bzr"
+echo ""
+echo "---"
+
libmemcached.3: libmemcached.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/libmemcached.pod > libmemcached.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/libmemcached.pod > libmemcached.3
libmemcachedutil.3: libmemcachedutil.pod
- @POD2MAN@ -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/libmemcachedutil.pod > libmemcachedutil.3
+ ${POD2MAN} -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/libmemcachedutil.pod > libmemcachedutil.3
libmemcached_examples.3: libmemcached_examples.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/libmemcached_examples.pod > libmemcached_examples.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/libmemcached_examples.pod > libmemcached_examples.3
memcached_create.3: memcached_create.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_create.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_create.3
memcached_free.3: memcached_create.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_free.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_free.3
memcached_clone.3: memcached_create.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_clone.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_create.pod > memcached_clone.3
memcached_set.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_set.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_set.3
memcached_set_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_set_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_set_by_key.3
memcached_cas.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_cas.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_cas.3
memcached_cas_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_cas_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_cas_by_key.3
memcached_replace.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_replace.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_replace.3
memcached_replace_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_replace_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_replace_by_key.3
memcached_add.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_add.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_add.3
memcached_add_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_add_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_add_by_key.3
memcached_prepend.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_prepend.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_prepend.3
memcached_prepend_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_prepend_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_prepend_by_key.3
memcached_append.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_append.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_append.3
memcached_append_by_key.3: memcached_set.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_append_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_set.pod > memcached_append_by_key.3
memcached_delete.3: memcached_delete.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_delete.pod > memcached_delete.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_delete.pod > memcached_delete.3
memcached_delete_by_key.3: memcached_delete.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_delete.pod > memcached_delete_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_delete.pod > memcached_delete_by_key.3
memcached_increment.3:
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_increment.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_increment.3
memcached_increment_with_initial.3:
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_increment_with_initial.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_increment_with_initial.3
memcached_decrement.3:
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_decrement.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_decrement.3
memcached_decrement_with_initial.3:
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_decrement_with_initial.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_auto.pod > memcached_decrement_with_initial.3
memcached_dump.3: memcached_dump.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_dump.pod > memcached_dump.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_dump.pod > memcached_dump.3
memcached_flush.3: memcached_flush.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_flush.pod > memcached_flush.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_flush.pod > memcached_flush.3
memcached_get.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_get.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_get.3
memcached_get_by_key.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_get_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_get_by_key.3
memcached_fetch_result.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch_result.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch_result.3
memcached_fetch_execute.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch_execute.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch_execute.3
memcached_mget.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_mget.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_mget.3
memcached_mget_by_key.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_mget_by_key.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_mget_by_key.3
memcached_fetch.3: memcached_get.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_get.pod > memcached_fetch.3
memcached_quit.3: memcached_quit.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_quit.pod > memcached_quit.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_quit.pod > memcached_quit.3
memcached_strerror.3: memcached_strerror.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_strerror.pod > memcached_strerror.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_strerror.pod > memcached_strerror.3
memcached_server_count.3: memcached_servers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_count.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_count.3
memcached_server_list.3: memcached_servers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_list.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_list.3
memcached_server_add.3: memcached_servers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_add.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_add.3
memcached_server_add_unix_socket.3: memcached_servers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_add_unix_socket.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_add_unix_socket.3
memcached_server_push.3: memcached_servers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_push.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_servers.pod > memcached_server_push.3
memcached_server_list_free.3: memcached_server_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_free.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_free.3
memcached_server_list_count.3: memcached_server_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_count.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_count.3
memcached_server_list_append.3: memcached_server_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_append.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_server_list_append.3
memcached_servers_parse.3: memcached_server_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_servers_parse.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_server_st.pod > memcached_servers_parse.3
memcached_verbosity.3: memcached_verbosity.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_verbosity.pod > memcached_verbosity.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_verbosity.pod > memcached_verbosity.3
memcached_behavior_get.3: memcached_behavior.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_behavior.pod > memcached_behavior_get.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_behavior.pod > memcached_behavior_get.3
memcached_behavior_set.3: memcached_behavior.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_behavior.pod > memcached_behavior_set.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_behavior.pod > memcached_behavior_set.3
memcached_callback_get.3: memcached_callback.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_callback.pod > memcached_callback_get.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_callback.pod > memcached_callback_get.3
memcached_callback_set.3: memcached_callback.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_callback.pod > memcached_callback_set.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_callback.pod > memcached_callback_set.3
memcached_stat.3: memcached_stats.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat.3
memcached_stat_servername.3: memcached_stats.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_servername.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_servername.3
memcached_stat_get_value.3: memcached_stats.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_get_value.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_get_value.3
memcached_stat_get_keys.3: memcached_stats.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_get_keys.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_stats.pod > memcached_stat_get_keys.3
memcached_result_st.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_st.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_st.3
memcached_result_create.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_create.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_create.3
memcached_result_free.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_free.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_free.3
memcached_result_key_value.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_key_value.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_key_value.3
memcached_result_key_length.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_key_length.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_key_length.3
memcached_result_value.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_value.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_value.3
memcached_result_length.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_length.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_length.3
memcached_result_flags.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_flags.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_flags.3
memcached_result_cas.3: memcached_result_st.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_cas.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_result_st.pod > memcached_result_cas.3
memcached_version.3: memcached_version.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_version.pod > memcached_version.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_version.pod > memcached_version.3
memcached_lib_version.3: memcached_version.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_version.pod > memcached_lib_version.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_version.pod > memcached_lib_version.3
memcached_flush_buffers.3: memcached_flush_buffers.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_flush_buffers.pod > memcached_flush_buffers.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_flush_buffers.pod > memcached_flush_buffers.3
memcached_analyze.3: memcached_analyze.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_analyze.pod > memcached_analyze.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_analyze.pod > memcached_analyze.3
memcached_generate_hash_value.3: memcached_generate_hash_value.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_generate_hash_value.pod > memcached_generate_hash_value.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_generate_hash_value.pod > memcached_generate_hash_value.3
memcached_get_memory_allocators.3: memcached_memory_allocators.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_memory_allocators.pod > memcached_get_memory_allocators.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_memory_allocators.pod > memcached_get_memory_allocators.3
memcached_set_memory_allocators.3: memcached_memory_allocators.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_memory_allocators.pod > memcached_set_memory_allocators.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_memory_allocators.pod > memcached_set_memory_allocators.3
memcached_get_user_data.3: memcached_user_data.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_user_data.pod > memcached_get_user_data.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_user_data.pod > memcached_get_user_data.3
memcached_set_user_data.3: memcached_user_data.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_user_data.pod > memcached_set_user_data.3
+ ${POD2MAN} -c "libmemcached" -r "" -s 3 ${top_srcdir}/docs/memcached_user_data.pod > memcached_set_user_data.3
memcached_pool_create.3: memcached_pool.pod
- @POD2MAN@ -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_create.3
+ ${POD2MAN} -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_create.3
memcached_pool_destroy.3: memcached_pool.pod
- @POD2MAN@ -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_destroy.3
+ ${POD2MAN} -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_destroy.3
memcached_pool_pop.3: memcached_pool.pod
- @POD2MAN@ -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_pop.3
+ ${POD2MAN} -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_pop.3
memcached_pool_push.3: memcached_pool.pod
- @POD2MAN@ -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_push.3
+ ${POD2MAN} -c "libmemcachedutil" -r "" -s 3 ${top_srcdir}/docs/memcached_pool.pod > memcached_pool_push.3
memcp.1: memcp.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memcp.pod > memcp.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memcp.pod > memcp.1
memslap.1: memslap.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memslap.pod > memslap.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memslap.pod > memslap.1
memcat.1: memcat.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memcat.pod > memcat.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memcat.pod > memcat.1
memstat.1: memstat.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memstat.pod > memstat.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memstat.pod > memstat.1
memrm.1: memrm.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memrm.pod > memrm.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memrm.pod > memrm.1
memerror.1: memerror.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memerror.pod > memerror.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memerror.pod > memerror.1
memdump.1: memdump.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memdump.pod > memdump.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memdump.pod > memdump.1
memflush.1: memflush.pod
- @POD2MAN@ -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memflush.pod > memflush.1
+ ${POD2MAN} -c "libmemcached" -r "" -s 1 ${top_srcdir}/docs/memflush.pod > memflush.1
test:
podchecker $(top_srcdir)/docs/libmemcached.pod
lib_LTLIBRARIES = libmemcached.la
+libmemcached_la_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
libmemcached_la_SOURCES = crc.c \
memcached.c \
memcached_auto.c \
uint32_t hash_crc32(const char *key, size_t key_length)
{
uint32_t x;
- uint32_t crc;
- crc= ~0;
+ uint32_t crc= UINT32_MAX;
for (x= 0; x < key_length; x++)
crc= (crc >> 8) ^ crc32tab[(crc ^ (key[x])) & 0xff];
case 2 : a+=k[0]&0xffff; break;
case 1 : a+=k[0]&0xff; break;
case 0 : return c; /* zero length strings require no mixing */
+ default: return c;
}
}
case 1 : a+=k8[0];
break;
case 0 : return c; /* zero length requires no mixing */
+ default: return c;
}
}
case 1 : a+=k[0];
break;
case 0 : return c;
+ default : return c;
}
#ifdef BYTEORDER_LITTLE_ENDIAN
}
}
memcached_analysis_st *memcached_analyze(memcached_st *memc,
- memcached_stat_st *stat,
+ memcached_stat_st *memc_stat,
memcached_return *error)
{
uint64_t total_items= 0, total_bytes= 0;
for (x= 0; x < server_count; x++)
{
- calc_largest_consumption(result, x, stat[x].bytes);
- calc_oldest_node(result, x, stat[x].uptime);
- calc_least_free_node(result, x, stat[x].limit_maxbytes, stat[x].bytes);
+ calc_largest_consumption(result, x, memc_stat[x].bytes);
+ calc_oldest_node(result, x, memc_stat[x].uptime);
+ calc_least_free_node(result, x,
+ memc_stat[x].limit_maxbytes, memc_stat[x].bytes);
- total_get_hits+= stat[x].get_hits;
- total_get_cmds+= stat[x].cmd_get;
- total_items+= stat[x].curr_items;
- total_bytes+= stat[x].bytes;
+ total_get_hits+= memc_stat[x].get_hits;
+ total_get_cmds+= memc_stat[x].cmd_get;
+ total_items+= memc_stat[x].curr_items;
+ total_bytes+= memc_stat[x].bytes;
}
calc_average_item_size(result, total_items, total_bytes);
server_key= memcached_generate_hash(ptr, key, key_length);
- send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
- "%s %s%.*s %u%s\r\n", verb,
- ptr->prefix_key,
- (int)key_length, key,
- offset, no_reply ? " noreply" : "");
+ send_length= (size_t)snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
+ "%s %s%.*s %u%s\r\n", verb,
+ ptr->prefix_key,
+ (int)key_length, key,
+ offset, no_reply ? " noreply" : "");
unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
return MEMCACHED_WRITE_FAILURE;
request.message.header.request.magic= PROTOCOL_BINARY_REQ;
request.message.header.request.opcode= cmd;
- request.message.header.request.keylen= htons((uint16_t)key_length);
+ request.message.header.request.keylen= htons(key_length);
request.message.header.request.extlen= 20;
request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
request.message.header.request.bodylen= htonl(key_length + request.message.header.request.extlen);
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
set_behavior_flag(ptr, MEM_AUTO_EJECT_HOSTS, data);
break;
+ default:
+ /* Shouldn't get here */
+ WATCHPOINT_ASSERT(flag);
+ break;
}
return MEMCACHED_SUCCESS;
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
temp_flag= MEM_AUTO_EJECT_HOSTS;
break;
+ default:
+ WATCHPOINT_ASSERT(flag);
+ break;
}
WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
{
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
- for (int x= 0; x < ptr->number_of_replicas; ++x)
+ for (uint32_t x= 0; x < ptr->number_of_replicas; ++x)
{
++server_key;
if (server_key == ptr->number_of_hosts)
int flush= number_of_keys == 1;
- for (int replica = 0; replica <= ptr->number_of_replicas; ++replica)
+ for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
{
bool success= true;
- for (uint32_t x= 0; x < number_of_keys; ++x)
+ for (x= 0; x < number_of_keys; ++x)
{
if (hash[x] == ptr->number_of_hosts)
continue; /* Already successfully sent */
memcached_server_response_increment(&ptr->hosts[x]);
/* mark all of the messages bound for this server as sent! */
- for (uint32_t x= 0; x < number_of_keys; ++x)
+ for (x= 0; x < number_of_keys; ++x)
if (hash[x] == x)
hash[x]= ptr->number_of_hosts;
}
/* Defines */
-static uint64_t FNV_64_INIT= 0xcbf29ce484222325LL;
-static uint64_t FNV_64_PRIME= 0x100000001b3LL;
+static uint64_t FNV_64_INIT= UINT64_C(0xcbf29ce484222325);
+static uint64_t FNV_64_PRIME= UINT64_C(0x100000001b3);
static uint32_t FNV_32_INIT= 2166136261UL;
static uint32_t FNV_32_PRIME= 16777619;
hash=jenkins_hash(key, key_length, 13);
break;
}
+ default:
+ {
+ WATCHPOINT_ASSERT(hash_algorithm);
+ break;
+ }
}
return hash;
}
right= begin;
return right->index;
}
- break;
case MEMCACHED_DISTRIBUTION_MODULA:
return hash % ptr->number_of_hosts;
case MEMCACHED_DISTRIBUTION_RANDOM:
memcached_return update_continuum(memcached_st *ptr)
{
- uint32_t index;
uint32_t host_index;
uint32_t continuum_index= 0;
uint32_t value;
memcached_server_st *list;
+ uint32_t pointer_index;
uint32_t pointer_counter= 0;
uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
uint32_t pointer_per_hash= 1;
float pct = (float)list[host_index].weight / (float)total_weight;
pointer_per_server= floorf(pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001) * 4;
pointer_per_hash= 4;
-#ifdef HAVE_DEBUG
+#ifdef DEBUG
printf("ketama_weighted:%s|%d|%llu|%u\n",
list[host_index].hostname,
list[host_index].port,
pointer_per_server);
#endif
}
- for (index= 1; index <= pointer_per_server / pointer_per_hash; ++index)
+ for (pointer_index= 1;
+ pointer_index <= pointer_per_server / pointer_per_hash;
+ ++pointer_index)
{
char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
size_t sort_host_length;
if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
{
- sort_host_length= snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH, "%s-%d",
- list[host_index].hostname, index - 1);
+ sort_host_length= snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
+ "%s-%d",
+ list[host_index].hostname,
+ pointer_index - 1);
}
else
{
- sort_host_length= snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH, "%s:%d-%d",
- list[host_index].hostname, list[host_index].port, index - 1);
+ sort_host_length= snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
+ "%s:%d-%d",
+ list[host_index].hostname,
+ list[host_index].port, pointer_index - 1);
}
WATCHPOINT_ASSERT(sort_host_length);
ptr->continuum_points_counter= pointer_counter;
qsort(ptr->continuum, ptr->continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
-#ifdef HAVE_DEBUG
- for (index= 0; ptr->number_of_hosts && index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); index++)
+#ifdef DEBUG
+ for (pointer_index= 0; ptr->number_of_hosts && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
{
- WATCHPOINT_ASSERT(ptr->continuum[index].value <= ptr->continuum[index + 1].value);
+ WATCHPOINT_ASSERT(ptr->continuum[pointer_index].value <= ptr->continuum[pointer_index + 1].value);
}
#endif
memcached_return memcached_server_remove(memcached_server_st *st_ptr)
{
- uint32_t x, index;
+ uint32_t x, host_index;
memcached_st *ptr= st_ptr->root;
memcached_server_st *list= ptr->hosts;
- for (x= 0, index= 0; x < ptr->number_of_hosts; x++)
+ for (x= 0, host_index= 0; x < ptr->number_of_hosts; x++)
{
if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port)
{
- if (index != x)
- memcpy(list+index, list+x, sizeof(memcached_server_st));
- index++;
+ if (host_index != x)
+ memcpy(list+host_index, list+x, sizeof(memcached_server_st));
+ host_index++;
}
}
- ptr->number_of_hosts= index;
+ ptr->number_of_hosts= host_index;
if (st_ptr->address_info)
{
const size_t size);
void *libmemcached_realloc(memcached_st *ptr __attribute__((unused)),
void *mem, const size_t size);
-
+void *libmemcached_calloc(memcached_st *ptr __attribute__((unused)),
+ size_t nelem, size_t size);
#ifdef __cplusplus
}
#endif
{
r= shutdown(ptr->fd, SHUT_RDWR);
-#ifdef HAVE_DEBUG
+#ifdef DEBUG
if (r && errno != ENOTCONN)
{
WATCHPOINT_NUMBER(ptr->fd);
}
r= close(ptr->fd);
-#ifdef HAVE_DEBUG
+#ifdef DEBUG
if (r != 0)
WATCHPOINT_ERRNO(errno);
#endif
{
#define MAX_SERVERS_TO_POLL 100
struct pollfd fds[MAX_SERVERS_TO_POLL];
- unsigned int index= 0;
+ unsigned int host_index= 0;
for (unsigned int x= 0;
- x< memc->number_of_hosts && index < MAX_SERVERS_TO_POLL;
+ x< memc->number_of_hosts && host_index < MAX_SERVERS_TO_POLL;
++x)
{
if (memc->hosts[x].read_buffer_length > 0) /* I have data in the buffer */
if (memcached_server_response_count(&memc->hosts[x]) > 0)
{
- fds[index].events = POLLIN;
- fds[index].revents = 0;
- fds[index].fd = memc->hosts[x].fd;
- ++index;
+ fds[host_index].events = POLLIN;
+ fds[host_index].revents = 0;
+ fds[host_index].fd = memc->hosts[x].fd;
+ ++host_index;
}
}
- if (index < 2)
+ if (host_index < 2)
{
/* We have 0 or 1 server with pending events.. */
for (unsigned int x= 0; x< memc->number_of_hosts; ++x)
return NULL;
}
- int err= poll(fds, index, memc->poll_timeout);
+ int err= poll(fds, host_index, memc->poll_timeout);
switch (err) {
case -1:
memc->cached_errno = errno;
case 0:
break;
default:
- for (unsigned int x= 0; x < index; ++x)
+ for (unsigned int x= 0; x < host_index; ++x)
if (fds[x].revents & POLLIN)
for (unsigned int y= 0; y < memc->number_of_hosts; ++y)
if (memc->hosts[y].fd == fds[x].fd)
return 0;
/* Looking for memory overflows */
-#if defined(HAVE_DEBUG)
+#if defined(DEBUG)
if (write_length == MEMCACHED_MAX_BUFFER)
WATCHPOINT_ASSERT(ptr->write_buffer == local_write_ptr);
WATCHPOINT_ASSERT((ptr->write_buffer + MEMCACHED_MAX_BUFFER) >= (local_write_ptr + write_length));
WATCHPOINT_ASSERT(bodylen == 0);
return MEMCACHED_SUCCESS;
}
- break;
case PROTOCOL_BINARY_CMD_NOOP:
{
WATCHPOINT_ASSERT(bodylen == 0);
return MEMCACHED_END;
}
- break;
case PROTOCOL_BINARY_CMD_STAT:
{
if (bodylen == 0)
};
-static memcached_return set_data(memcached_stat_st *stat, char *key, char *value)
+static memcached_return set_data(memcached_stat_st *memc_stat, char *key, char *value)
{
if(strlen(key) < 1)
}
else if (!strcmp("pid", key))
{
- stat->pid= strtol(value, (char **)NULL, 10);
+ memc_stat->pid= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("uptime", key))
{
- stat->uptime= strtol(value, (char **)NULL, 10);
+ memc_stat->uptime= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("time", key))
{
- stat->time= strtol(value, (char **)NULL, 10);
+ memc_stat->time= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("version", key))
{
- memcpy(stat->version, value, strlen(value));
- stat->version[strlen(value)]= 0;
+ memcpy(memc_stat->version, value, strlen(value));
+ memc_stat->version[strlen(value)]= 0;
}
else if (!strcmp("pointer_size", key))
{
- stat->pointer_size= strtol(value, (char **)NULL, 10);
+ memc_stat->pointer_size= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("rusage_user", key))
{
for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++);
*walk_ptr= 0;
walk_ptr++;
- stat->rusage_user_seconds= strtol(value, (char **)NULL, 10);
- stat->rusage_user_microseconds= strtol(walk_ptr, (char **)NULL, 10);
+ memc_stat->rusage_user_seconds= strtol(value, (char **)NULL, 10);
+ memc_stat->rusage_user_microseconds= strtol(walk_ptr, (char **)NULL, 10);
}
else if (!strcmp("rusage_system", key))
{
for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++);
*walk_ptr= 0;
walk_ptr++;
- stat->rusage_system_seconds= strtol(value, (char **)NULL, 10);
- stat->rusage_system_microseconds= strtol(walk_ptr, (char **)NULL, 10);
+ memc_stat->rusage_system_seconds= strtol(value, (char **)NULL, 10);
+ memc_stat->rusage_system_microseconds= strtol(walk_ptr, (char **)NULL, 10);
}
else if (!strcmp("curr_items", key))
{
- stat->curr_items= strtol(value, (char **)NULL, 10);
+ memc_stat->curr_items= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("total_items", key))
{
- stat->total_items= strtol(value, (char **)NULL, 10);
+ memc_stat->total_items= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("bytes_read", key))
{
- stat->bytes_read= strtoll(value, (char **)NULL, 10);
+ memc_stat->bytes_read= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("bytes_written", key))
{
- stat->bytes_written= strtoll(value, (char **)NULL, 10);
+ memc_stat->bytes_written= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("bytes", key))
{
- stat->bytes= strtoll(value, (char **)NULL, 10);
+ memc_stat->bytes= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("curr_connections", key))
{
- stat->curr_connections= strtoll(value, (char **)NULL, 10);
+ memc_stat->curr_connections= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("total_connections", key))
{
- stat->total_connections= strtoll(value, (char **)NULL, 10);
+ memc_stat->total_connections= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("connection_structures", key))
{
- stat->connection_structures= strtol(value, (char **)NULL, 10);
+ memc_stat->connection_structures= strtol(value, (char **)NULL, 10);
}
else if (!strcmp("cmd_get", key))
{
- stat->cmd_get= strtoll(value, (char **)NULL, 10);
+ memc_stat->cmd_get= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("cmd_set", key))
{
- stat->cmd_set= strtoll(value, (char **)NULL, 10);
+ memc_stat->cmd_set= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("get_hits", key))
{
- stat->get_hits= strtoll(value, (char **)NULL, 10);
+ memc_stat->get_hits= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("get_misses", key))
{
- stat->get_misses= (uint64_t)strtoll(value, (char **)NULL, 10);
+ memc_stat->get_misses= (uint64_t)strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("evictions", key))
{
- stat->evictions= (uint64_t)strtoll(value, (char **)NULL, 10);
+ memc_stat->evictions= (uint64_t)strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("limit_maxbytes", key))
{
- stat->limit_maxbytes= strtoll(value, (char **)NULL, 10);
+ memc_stat->limit_maxbytes= strtoll(value, (char **)NULL, 10);
}
else if (!strcmp("threads", key))
{
- stat->threads= strtol(value, (char **)NULL, 10);
+ memc_stat->threads= strtol(value, (char **)NULL, 10);
}
else if (!(strcmp("delete_misses", key) == 0 ||/* New stats in the 1.3 beta */
strcmp("delete_hits", key) == 0 ||/* Just swallow them for now.. */
return MEMCACHED_SUCCESS;
}
-char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat,
+char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *memc_stat,
const char *key, memcached_return *error)
{
char buffer[SMALL_STRING_LEN];
*error= MEMCACHED_SUCCESS;
if (!memcmp("pid", key, strlen("pid")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->pid);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->pid);
else if (!memcmp("uptime", key, strlen("uptime")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->uptime);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->uptime);
else if (!memcmp("time", key, strlen("time")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->time);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->time);
else if (!memcmp("version", key, strlen("version")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%s", stat->version);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%s", memc_stat->version);
else if (!memcmp("pointer_size", key, strlen("pointer_size")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->pointer_size);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->pointer_size);
else if (!memcmp("rusage_user", key, strlen("rusage_user")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", stat->rusage_user_seconds, stat->rusage_user_microseconds);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", memc_stat->rusage_user_seconds, memc_stat->rusage_user_microseconds);
else if (!memcmp("rusage_system", key, strlen("rusage_system")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", stat->rusage_system_seconds, stat->rusage_system_microseconds);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", memc_stat->rusage_system_seconds, memc_stat->rusage_system_microseconds);
else if (!memcmp("curr_items", key, strlen("curr_items")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->curr_items);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->curr_items);
else if (!memcmp("total_items", key, strlen("total_items")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->total_items);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->total_items);
else if (!memcmp("bytes", key, strlen("bytes")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->bytes);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes);
else if (!memcmp("curr_connections", key, strlen("curr_connections")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->curr_connections);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->curr_connections);
else if (!memcmp("total_connections", key, strlen("total_connections")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->total_connections);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->total_connections);
else if (!memcmp("connection_structures", key, strlen("connection_structures")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->connection_structures);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->connection_structures);
else if (!memcmp("cmd_get", key, strlen("cmd_get")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->cmd_get);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->cmd_get);
else if (!memcmp("cmd_set", key, strlen("cmd_set")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->cmd_set);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->cmd_set);
else if (!memcmp("get_hits", key, strlen("get_hits")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->get_hits);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->get_hits);
else if (!memcmp("get_misses", key, strlen("get_misses")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->get_misses);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->get_misses);
else if (!memcmp("evictions", key, strlen("evictions")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->evictions);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->evictions);
else if (!memcmp("bytes_read", key, strlen("bytes_read")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->bytes_read);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes_read);
else if (!memcmp("bytes_written", key, strlen("bytes_written")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->bytes_written);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->bytes_written);
else if (!memcmp("limit_maxbytes", key, strlen("limit_maxbytes")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)stat->limit_maxbytes);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%llu", (unsigned long long)memc_stat->limit_maxbytes);
else if (!memcmp("threads", key, strlen("threads")))
- length= snprintf(buffer, SMALL_STRING_LEN,"%u", stat->threads);
+ length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->threads);
else
{
*error= MEMCACHED_NOTFOUND;
}
static memcached_return binary_stats_fetch(memcached_st *ptr,
- memcached_stat_st *stat,
+ memcached_stat_st *memc_stat,
char *args,
unsigned int server_key)
{
return rc;
}
- unlikely((set_data(stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
+ unlikely((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
{
WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
WATCHPOINT_ASSERT(0);
}
static memcached_return ascii_stats_fetch(memcached_st *ptr,
- memcached_stat_st *stat,
+ memcached_stat_st *memc_stat,
char *args,
unsigned int server_key)
{
value= string_ptr;
value[(size_t)(end_ptr-string_ptr)]= 0;
string_ptr= end_ptr + 2;
- unlikely((set_data(stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
+ unlikely((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
{
WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
WATCHPOINT_ASSERT(0);
return stats;
}
-memcached_return memcached_stat_servername(memcached_stat_st *stat, char *args,
+memcached_return memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
char *hostname, unsigned int port)
{
memcached_return rc;
memcached_server_add(&memc, hostname, port);
if (memc.flags & MEM_BINARY_PROTOCOL)
- rc= binary_stats_fetch(&memc, stat, args, 0);
+ rc= binary_stats_fetch(&memc, memc_stat, args, 0);
else
- rc= ascii_stats_fetch(&memc, stat, args, 0);
+ rc= ascii_stats_fetch(&memc, memc_stat, args, 0);
memcached_free(&memc);
We make a copy of the keys since at some point in the not so distant future
we will add support for "found" keys.
*/
-char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *stat __attribute__((unused)),
+char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *memc_stat,
memcached_return *error)
{
+ (void) memc_stat;
char **list;
size_t length= sizeof(memcached_stat_keys);
return list;
}
-void memcached_stat_free(memcached_st *ptr, memcached_stat_st *stat)
+void memcached_stat_free(memcached_st *ptr, memcached_stat_st *memc_stat)
{
- if (stat == NULL)
+ if (memc_stat == NULL)
{
WATCHPOINT_ASSERT(0); /* Be polite, but when debugging catch this as an error */
return;
}
if (ptr)
- ptr->call_free(ptr, stat);
+ ptr->call_free(ptr, memc_stat);
else
- free(stat);
+ free(memc_stat);
}
return "cas ";
default:
return "tosserror"; /* This is impossible, fixes issue for compiler warning in VisualStudio */
- };
+ }
/* NOTREACHED */
}
case PREPEND_OP:
ret=PROTOCOL_BINARY_CMD_PREPENDQ;
break;
+ default:
+ WATCHPOINT_ASSERT(verb);
+ break;
}
else
switch (verb)
case PREPEND_OP:
ret=PROTOCOL_BINARY_CMD_PREPEND;
break;
+ default:
+ WATCHPOINT_ASSERT(verb);
+ break;
}
return ret;
{
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_SETQ;
- for (int x= 0; x < ptr->number_of_replicas; ++x)
+ for (uint32_t x= 0; x < ptr->number_of_replicas; x++)
{
++server_key;
if (server_key == ptr->number_of_hosts)
return "SERVER VALUE";
case MEMCACHED_STAT:
return "STAT VALUE";
+ case MEMCACHED_ITEM:
+ return "ITEM VALUE";
case MEMCACHED_ERRNO:
return "SYSTEM ERROR";
case MEMCACHED_FAIL_UNIX_SOCKET:
return "Gibberish returned!";
default:
return "Gibberish returned!";
- };
+ }
}
#endif
/* Some personal debugging functions */
-#if defined(MEMCACHED_INTERNAL) && defined(HAVE_DEBUG)
+#if defined(MEMCACHED_INTERNAL) && defined(DEBUG)
#include <assert.h>
#define WATCHPOINT fprintf(stderr, "\nWATCHPOINT %s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
#define WATCHPOINT_ASSERT_PRINT(A,B,C)
#define WATCHPOINT_ASSERT(A)
-#endif /* MEMCACHED_INTERNAL && HAVE_DEBUG */
+#endif /* MEMCACHED_INTERNAL && DEBUG */
#ifdef __cplusplus
}
case 2: h ^= data[1] << 8;
case 1: h ^= data[0];
h *= m;
+ default: break;
};
/*
memcached_st *master;
memcached_st **mmc;
int firstfree;
- int size;
- int current_size;
+ uint32_t size;
+ uint32_t current_size;
};
static memcached_return mutex_enter(pthread_mutex_t *mutex)
dnl ---------------------------------------------------------------------------
-dnl Macro: 64BIT
+dnl Macro: ENABLE_64BIT
dnl ---------------------------------------------------------------------------
-AC_ARG_ENABLE(64bit,
- [ --enable-64bit Build 64bit library.],
- [
- org_cflags=$CFLAGS
- CFLAGS=-m64
- AC_LANG(C)
- AC_RUN_IFELSE([
- AC_LANG_PROGRAM([], [ if (sizeof(void*) != 8) return 1;])
- ],[
- CFLAGS="$CFLAGS $org_cflags"
- ],[
- AC_MSG_ERROR([Don't know how to build a 64-bit object.])
- ])
- org_cxxflags=$CXXFLAGS
- CXXFLAGS=-m64
- AC_LANG(C++)
- AC_RUN_IFELSE([
- AC_LANG_PROGRAM([], [ if (sizeof(void*) != 8) return 1;])
- ],[
- CXXFLAGS="$CXXFLAGS $org_cxxflags"
- ],[
- AC_MSG_ERROR([Don't know how to build a 64-bit object.])
- ])
+AC_DEFUN([ENABLE_64BIT],[
- ])
+ AC_CHECK_PROGS(ISAINFO, [isainfo], [no])
+ AS_IF([test "x$ISAINFO" != "xno"],
+ [isainfo_b=`${ISAINFO} -b`],
+ [isainfo_b="x"])
+
+ AS_IF([test "$isainfo_b" != "x"],
+ [AC_ARG_ENABLE([64bit],
+ [AS_HELP_STRING([--disable-64bit],
+ [Build 64 bit binary @<:@default=on@:>@])],
+ [ac_enable_64bit="$enableval"],
+ [ac_enable_64bit="yes"])])
+
+ AS_IF([test "x$ac_enable_64bit" = "xyes"],[
+ if test "x$libdir" = "x\${exec_prefix}/lib" ; then
+ # The user hasn't overridden the default libdir, so we'll
+ # the dir suffix to match solaris 32/64-bit policy
+ isainfo_k=`${ISAINFO} -k`
+ libdir="${libdir}/${isainfo_k}"
+ fi
+ CFLAGS="-m64 $CFLAGS"
+ CXXFLAGS="-m64 $CXXFLAGS"
+ if test "$target_cpu" = "sparc" -a "x$SUNCC" = "xyes"
+ then
+ CFLAGS="-xmemalign=8s $CFLAGS"
+ CXXFLAGS="-xmemalign=8s $CXXFLAGS"
+ fi
+ ])
+])
dnl ---------------------------------------------------------------------------
-dnl End Macro: 64BIT
+dnl End Macro: ENABLE_64BIT
dnl ---------------------------------------------------------------------------
--- /dev/null
+##### http://autoconf-archive.cryp.to/acx_pthread.html
+#
+# SYNOPSIS
+#
+# ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+# This macro figures out how to build C programs using POSIX threads.
+# It sets the PTHREAD_LIBS output variable to the threads library and
+# linker flags, and the PTHREAD_CFLAGS output variable to any special
+# C compiler flags that are needed. (The user can also force certain
+# compiler flags/libs to be tested by setting these environment
+# variables.)
+#
+# Also sets PTHREAD_CC to any special C compiler that is needed for
+# multi-threaded programs (defaults to the value of CC otherwise).
+# (This is necessary on AIX to use the special cc_r compiler alias.)
+#
+# NOTE: You are assumed to not only compile your program with these
+# flags, but also link it with them as well. e.g. you should link
+# with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS
+# $LIBS
+#
+# If you are only building threads programs, you may wish to use
+# these variables in your default LIBS, CFLAGS, and CC:
+#
+# LIBS="$PTHREAD_LIBS $LIBS"
+# CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+# CC="$PTHREAD_CC"
+#
+# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute
+# constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to
+# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+# ACTION-IF-FOUND is a list of shell commands to run if a threads
+# library is found, and ACTION-IF-NOT-FOUND is a list of commands to
+# run it if it is not found. If ACTION-IF-FOUND is not specified, the
+# default action will define HAVE_PTHREAD.
+#
+# Please let the authors know if this macro fails on any platform, or
+# if you have any other suggestions or comments. This macro was based
+# on work by SGJ on autoconf scripts for FFTW (http://www.fftw.org/)
+# (with help from M. Frigo), as well as ac_pthread and hb_pthread
+# macros posted by Alejandro Forero Cuervo to the autoconf macro
+# repository. We are also grateful for the helpful feedback of
+# numerous users.
+#
+# LAST MODIFICATION
+#
+# 2006-05-29
+#
+# COPYLEFT
+#
+# Copyright (c) 2006 Steven G. Johnson <stevenj@alum.mit.edu>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+#
+# As a special exception, the respective Autoconf Macro's copyright
+# owner gives unlimited permission to copy, distribute and modify the
+# configure scripts that are the output of Autoconf when processing
+# the Macro. You need not follow the terms of the GNU General Public
+# License when using or distributing such scripts, even though
+# portions of the text of the Macro appear in them. The GNU General
+# Public License (GPL) does govern all other use of the material that
+# constitutes the Autoconf Macro.
+#
+# This special exception to the GPL applies to versions of the
+# Autoconf Macro released by the Autoconf Macro Archive. When you
+# make and distribute a modified version of the Autoconf Macro, you
+# may extend this special exception to the GPL to apply to your
+# modified version as well.
+
+AC_DEFUN([ACX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_LANG_PUSH([C])
+acx_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on True64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
+ save_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+ save_LIBS="$LIBS"
+ LIBS="$PTHREAD_LIBS $LIBS"
+ AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+ AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
+ AC_MSG_RESULT($acx_pthread_ok)
+ if test x"$acx_pthread_ok" = xno; then
+ PTHREAD_LIBS=""
+ PTHREAD_CFLAGS=""
+ fi
+ LIBS="$save_LIBS"
+ CFLAGS="$save_CFLAGS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try. Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important. Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+# other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+# doesn't hurt to check since this sometimes defines pthreads too;
+# also defines -D_REENTRANT)
+# ... -mt is also the pthreads flag for HP/aCC
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case "${host_cpu}-${host_os}" in
+ *solaris*)
+
+ # On Solaris (at least, for some versions), libc contains stubbed
+ # (non-functional) versions of the pthreads routines, so link-based
+ # tests will erroneously succeed. (We need to link with -pthreads/-mt/
+ # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather
+ # a function called by this macro, so we could check for that, but
+ # who knows whether they'll stub that too in a future libc.) So,
+ # we'll just look for -pthreads and -lpthread first:
+
+ acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags"
+ ;;
+esac
+
+if test x"$acx_pthread_ok" = xno; then
+for flag in $acx_pthread_flags; do
+
+ case $flag in
+ none)
+ AC_MSG_CHECKING([whether pthreads work without any flags])
+ ;;
+
+ -*)
+ AC_MSG_CHECKING([whether pthreads work with $flag])
+ PTHREAD_CFLAGS="$flag"
+ ;;
+
+ pthread-config)
+ AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
+ if test x"$acx_pthread_config" = xno; then continue; fi
+ PTHREAD_CFLAGS="`pthread-config --cflags`"
+ PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+ ;;
+
+ *)
+ AC_MSG_CHECKING([for the pthreads library -l$flag])
+ PTHREAD_LIBS="-l$flag"
+ ;;
+ esac
+
+ save_LIBS="$LIBS"
+ save_CFLAGS="$CFLAGS"
+ LIBS="$PTHREAD_LIBS $LIBS"
+ CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+ # Check for various functions. We must include pthread.h,
+ # since some functions may be macros. (On the Sequent, we
+ # need a special flag -Kthread to make this header compile.)
+ # We check for pthread_join because it is in -lpthread on IRIX
+ # while pthread_create is in libc. We check for pthread_attr_init
+ # due to DEC craziness with -lpthreads. We check for
+ # pthread_cleanup_push because it is one of the few pthread
+ # functions on Solaris that doesn't have a non-functional libc stub.
+ # We try pthread_create on general principles.
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t th; pthread_join(th, 0);
+ pthread_attr_init(0); pthread_cleanup_push(0, 0);
+ pthread_create(0,0,0,0); pthread_cleanup_pop(0); ]])],[acx_pthread_ok=yes],[])
+
+ LIBS="$save_LIBS"
+ CFLAGS="$save_CFLAGS"
+
+ AC_MSG_RESULT($acx_pthread_ok)
+ if test "x$acx_pthread_ok" = xyes; then
+ break;
+ fi
+
+ PTHREAD_LIBS=""
+ PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$acx_pthread_ok" = xyes; then
+ save_LIBS="$LIBS"
+ LIBS="$PTHREAD_LIBS $LIBS"
+ save_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+ # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+ AC_MSG_CHECKING([for joinable pthread attribute])
+ attr_name=unknown
+ for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]], [[int attr=$attr; return attr;]])],[attr_name=$attr; break],[])
+ done
+ AC_MSG_RESULT($attr_name)
+ if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+ AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+ [Define to necessary symbol if this constant
+ uses a non-standard name on your system.])
+ fi
+
+ AC_MSG_CHECKING([if more special flags are required for pthreads])
+ flag=no
+ case "${host_cpu}-${host_os}" in
+ *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
+ *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
+ esac
+ AC_MSG_RESULT(${flag})
+ if test "x$flag" != xno; then
+ PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+ fi
+
+ LIBS="$save_LIBS"
+ CFLAGS="$save_CFLAGS"
+
+ # More AIX lossage: must compile with xlc_r or cc_r
+ if test x"$GCC" != xyes; then
+ AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
+ else
+ PTHREAD_CC=$CC
+ fi
+else
+ PTHREAD_CC="$CC"
+fi
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test x"$acx_pthread_ok" = xyes; then
+ ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
+ :
+else
+ acx_pthread_ok=no
+ $2
+fi
+AC_LANG_POP([])
+])dnl ACX_PTHREAD
--- /dev/null
+AC_DEFUN([FORCE_MAC_GCC42],
+ [AS_IF([test "$GCC" = "yes"],[
+ dnl If you're on a Mac, and you didn't ask for a specific compiler
+ dnl You're gonna get 4.2.
+ AS_IF([test "$host_vendor" = "apple" -a "x${ac_cv_env_CC_set}" = "x"],[
+ AS_IF([test -f /usr/bin/gcc-4.2],
+ [
+ CPP="/usr/bin/gcc-4.2 -E"
+ CC=/usr/bin/gcc-4.2
+ CXX=/usr/bin/g++-4.2
+ ])
+ ])
+ ])
+])
+
+AC_DEFUN([CHECK_GCC_VERSION],[
+ AC_REQUIRE([FORCE_MAC_GCC42])
+ AC_CACHE_CHECK([if GCC is recent enough], [ac_cv_gcc_recent],
+ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#if !defined(__GNUC__) || (__GNUC__ < 4) || ((__GNUC__ >= 4) && (__GNUC_MINOR__ < 1))
+# error GCC is Too Old!
+#endif
+ ]])],
+ [ac_cv_gcc_recent=yes],
+ [ac_cv_gcc_recent=no])])
+ AS_IF([test "$ac_cv_gcc_recent" = "no" -a "$host_vendor" = "apple"],
+ AC_MSG_ERROR([Your version of GCC is too old. At least version 4.2 is required on OSX. You may need to install a version of XCode >= 3.1.2]))
+ AS_IF([test "$drizzle_cv_gcc_recent" = "no"],
+ AC_MSG_ERROR([Your version of GCC is too old. At least version 4.1 is required]))
+])
+++ /dev/null
-dnl ---------------------------------------------------------------------------
-dnl Macro: DEBUG_TEST
-dnl ---------------------------------------------------------------------------
-AC_ARG_ENABLE(debug,
- [ --enable-debug Build with support for the DEBUG.],
- [
- AC_DEFINE([HAVE_DEBUG], [1], [Enables DEBUG Support])
- AC_CHECK_PROGS(DEBUG, debug)
- ENABLE_DEBUG="yes"
- AC_SUBST(DEBUGFLAGS)
- AC_SUBST(HAVE_DEBUG)
- ],
- [
- ENABLE_DEBUG="no"
- ]
- )
-AM_CONDITIONAL([HAVE_DEBUG], [ test "$ENABLE_DEBUG" = "yes" ])
-dnl ---------------------------------------------------------------------------
-dnl End Macro: DEBUG_TEST
-dnl ---------------------------------------------------------------------------
dnl ---------------------------------------------------------------------------
dnl Macro: deprecated
dnl ---------------------------------------------------------------------------
-AC_ARG_ENABLE([deprecated],
- [AS_HELP_STRING([--enable-deprecated],
- [Enable deprecated interface @<:@default=off@:>@])],
- [ac_enable_deprecated="$enableval"],
- [ac_enable_deprecated="no"])
+AC_DEFUN([ENABLE_DEPRECATED],[
+ AC_ARG_ENABLE([deprecated],
+ [AS_HELP_STRING([--enable-deprecated],
+ [Enable deprecated interface @<:@default=off@:>@])],
+ [ac_enable_deprecated="$enableval"],
+ [ac_enable_deprecated="no"])
-if test "x$ac_enable_deprecated" = "xyes"
-then
- DEPRECATED="#define MEMCACHED_ENABLE_DEPRECATED 1"
-fi
-
-AC_SUBST(DEPRECATED)
+ AS_IF([test "$ac_enable_deprecated" = "yes"],
+ [DEPRECATED="#define MEMCACHED_ENABLE_DEPRECATED 1"])
+ AC_SUBST([DEPRECATED])
+])
dnl ---------------------------------------------------------------------------
dnl End Macro: deprecated
dnl ---------------------------------------------------------------------------
dnl ---------------------------------------------------------------------------
-dnl Macro: DTRACE_TEST
+dnl Macro: ENABLE_DTRACE
dnl ---------------------------------------------------------------------------
-AC_ARG_ENABLE(dtrace,
- [ --enable-dtrace Build with support for the DTRACE.],
- [
+AC_DEFUN([ENABLE_DTRACE],[
+ AC_ARG_ENABLE([dtrace],
+ [AS_HELP_STRING([--enable-dtrace],
+ [Build with support for the DTRACE. @<:@default=off@:>@])],
+ [ac_cv_enable_dtrace="yes"],
+ [ac_cv_enable_dtrace="no"])
+
+ if test "$ac_cv_enable_dtrace" = "yes"
+ then
AC_PATH_PROG([DTRACE], [dtrace], "no", [/usr/sbin:$PATH])
if test "x$DTRACE" != "xno"; then
AC_DEFINE([HAVE_DTRACE], [1], [Enables DTRACE Support])
rm conftest.$$
fi
- ENABLE_DTRACE="yes"
+ ac_cv_enable_dtrace="yes"
AC_SUBST(HAVE_DTRACE)
else
AC_MSG_ERROR([Need dtrace binary and OS support.])
fi
- ],
- [
- ENABLE_DTRACE="no"
- ]
- )
+ fi
-AC_SUBST(DTRACEFLAGS)
-AC_SUBST(DTRACE_HEADER)
-AC_SUBST(DTRACE_OBJ)
-AM_CONDITIONAL([HAVE_DTRACE], [ test "$ENABLE_DTRACE" = "yes" ])
+ AC_SUBST(DTRACEFLAGS)
+ AC_SUBST(DTRACE_HEADER)
+ AC_SUBST(DTRACE_OBJ)
+ AM_CONDITIONAL([HAVE_DTRACE], [ test "$ac_cv_enable_dtrace" = "yes" ])
+])
dnl ---------------------------------------------------------------------------
-dnl End Macro: DTRACE_TEST
+dnl End Macro: ENABLE_DTRACE
dnl ---------------------------------------------------------------------------
--- /dev/null
+AC_DEFUN([ENABLE_UTILLIB],[
+ AC_ARG_ENABLE([utils],
+ [AS_HELP_STRING([--disable-utils],
+ [Disable libmemcachedutils @<:@default=on@:>@])],
+ [BUILD_UTILLIB="$enableval"],
+ [BUILD_UTILLIB="yes"])
+
+ if test "x$BUILD_UTILLIB" = "xyes"; then
+ if test x"$acx_pthread_ok" != "xyes"; then
+ AC_MSG_ERROR([Sorry you need POSIX thread library to build libmemcachedutil.])
+ fi
+ AC_DEFINE([HAVE_LIBMEMCACHEDUTIL], [1], [Enables libmemcachedutil Support])
+ fi
+
+ AM_CONDITIONAL([BUILD_LIBMEMCACHEDUTIL],[test "x$BUILD_UTILLIB" = "xyes"])
+])
# AC_DEFINE. The goal here is to define all known feature-enabling
# macros, then, if reports of conflicts are made, disable macros that
# cause problems on some platforms (such as __EXTENSIONS__).
-AC_DEFUN([AC_USE_SYSTEM_EXTENSIONS],
+AC_DEFUN([ACX_USE_SYSTEM_EXTENSIONS],
[AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl
AC_BEFORE([$0], [AC_RUN_IFELSE])dnl
dnl ---------------------------------------------------------------------------
-dnl Macro: HSIEH_HASH
+dnl Macro: ENABLE_HSIEH_HASH
dnl ---------------------------------------------------------------------------
-AC_ARG_ENABLE(hsieh_hash,
- [ --enable-hsieh_hash build with support for hsieh hashing.],
- [
- if test "x$enableval" != "xno"; then
- ENABLE_HSIEH="true"
- AC_DEFINE([HAVE_HSIEH_HASH], [1], [Enables hsieh hashing support])
- else
- ENABLE_HSIEH="false"
- fi
- ],
- [
- ENABLE_HSIEH="false"
- ]
-)
+AC_DEFUN([ENABLE_HSIEH_HASH],
+ [AC_ARG_ENABLE([hsieh_hash],
+ [AS_HELP_STRING([--enable-hsieh_hash],
+ [build with support for hsieh hashing. @<:default=off@:>@])],
+ [ac_cv_enable_hsieh_hash=yes],
+ [ac_cv_enable_hsieh_hash=no])
-AM_CONDITIONAL([INCLUDE_HSIEH_SRC], [test "x$ENABLE_HSIEH" = "xtrue"])
+ AS_IF([test "$ac_cv_enable_hsieh_hash" = "yes"],
+ [AC_DEFINE([HAVE_HSIEH_HASH], [1], [Enables hsieh hashing support])])
+
+ AM_CONDITIONAL([INCLUDE_HSIEH_SRC], [test "$ac_cv_enable_hsieh_hash" = "yes"])
+])
dnl ---------------------------------------------------------------------------
-dnl End Macro: HSIEH_HASH
+dnl End Macro: ENABLE_HSIEH_HASH
dnl ---------------------------------------------------------------------------
-AC_ARG_WITH(memcached,
-[[ --with-memcached[=memcached binary]
- Memcached binary to use for make test]],
-[
- if test -n "$withval"
- then
- MEMC_BINARY="$withval"
- fi
-
- if test x$withval = xyes
- then
- MEMC_BINARY=memcached
- fi
+AC_DEFUN([WITH_MEMCACHED],
+ [AC_ARG_WITH([memcached],
+ [AS_HELP_STRING([--with-memcached],
+ [Memcached binary to use for make test])],
+ [ac_cv_with_memcached="$withval"],
+ [ac_cv_with_memcached=memcached])
# just ignore the user if --without-memcached is passed.. it is
# only used by make test
- if test x$withval = xno
- then
- MEMC_BINARY=memcached
- fi
-],
-[
- AC_PATH_PROG([MEMC_BINARY], [memcached], "no", [$PATH])
-])
+ AS_IF([test "x$withval" = "xno"],
+ [ac_cv_with_memcached=memcached])
-if test x$MEMC_BINARY = "xno"
-then
- AC_MSG_ERROR(["could not find memcached binary"])
-fi
+ AC_PATH_PROG([MEMC_BINARY], [$ac_cv_with_memcached], "no")
-AC_DEFINE_UNQUOTED([MEMCACHED_BINARY], "$MEMC_BINARY",
+ AS_IF([test "x$MEMC_BINARY" = "xno"],
+ AC_MSG_ERROR(["could not find memcached binary"]))
+
+ AC_DEFINE_UNQUOTED([MEMCACHED_BINARY], "$MEMC_BINARY",
[Name of the memcached binary used in make test])
+])
-AC_PATH_PROG([POD2MAN], [pod2man], "no", [$PATH:/usr/bin:/usr/local/bin:/usr/perl5/bin])
-if test "x$POD2MAN" = "xno"; then
- AC_MSG_ERROR(["Could not find pod2man anywhere in path"])
-fi
-AC_SUBST(POD2MAN)
+AC_DEFUN([REQUIRE_POD2MAN],[
+ AC_PATH_PROG([POD2MAN], [pod2man],
+ "no", [$PATH:/usr/bin:/usr/local/bin:/usr/perl5/bin])
+ AS_IF([test "x$POD2MAN" = "xno"],
+ AC_MSG_ERROR(["Could not find pod2man anywhere in path"]))
+ AC_SUBST(POD2MAN)
+])
dnl ---------------------------------------------------------------------------
dnl Macro: PROTOCOL_BINARY_TEST
dnl ---------------------------------------------------------------------------
-save_CFLAGS="$CFLAGS"
-CFLAGS="$CFLAGS -I${srcdir}"
-AC_RUN_IFELSE([
- AC_LANG_PROGRAM([
- #include "libmemcached/memcached/protocol_binary.h"
- ], [
+AC_DEFUN([PROTOCOL_BINARY_TEST],
+ [AC_LANG_PUSH([C])
+ save_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -I${srcdir}"
+ AC_RUN_IFELSE([
+ AC_LANG_PROGRAM([[
+#include "libmemcached/memcached/protocol_binary.h"
+ ]],[[
protocol_binary_request_set request;
if (sizeof(request) != sizeof(request.bytes)) {
return 1;
}
- ])
-],, AC_MSG_ERROR([Unsupported struct padding done by compiler.]))
-CFLAGS="$save_CFLAGS"
+ ]])],, AC_MSG_ERROR([Unsupported struct padding done by compiler.]))
+ CFLAGS="$save_CFLAGS"
+ AC_LANG_POP
+])
dnl ---------------------------------------------------------------------------
dnl End Macro: PROTOCOL_BINARY_TEST
dnl ---------------------------------------------------------------------------
-dnl Macro: SETSOCKOPT_TEST
+dnl Macro: SETSOCKOPT_SANITY
dnl ---------------------------------------------------------------------------
-AC_LANG(C)
-AC_RUN_IFELSE([
- AC_LANG_PROGRAM([
+AC_DEFUN([SETSOCKOPT_SANITY],[
+ AC_LANG_PUSH([C])
+ AC_RUN_IFELSE([
+ AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/socket.h>
#include <time.h>
#include <sys/time.h>
#include <errno.h>
- ], [
+ ]],[[
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct timeval waittime;
}
}
return 0;
- ])
- ], AC_DEFINE(HAVE_SNDTIMEO, 1, [Define to 1 if you have a working SO_SNDTIMEO]))
+ ]])],
+ [AC_DEFINE(HAVE_SNDTIMEO, 1, [Define to 1 if you have a working SO_SNDTIMEO])])
-AC_RUN_IFELSE([
- AC_LANG_PROGRAM([
+ AC_RUN_IFELSE([
+ AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/socket.h>
#include <time.h>
#include <sys/time.h>
#include <errno.h>
- ], [
+ ]],[[
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct timeval waittime;
}
}
return 0;
- ])
- ], AC_DEFINE(HAVE_RCVTIMEO, 1, [Define to 1 if you have a working SO_RCVTIMEO]))
+ ]])], [AC_DEFINE(HAVE_RCVTIMEO, 1, [Define to 1 if you have a working SO_RCVTIMEO])])
+ AC_LANG_POP
+])
dnl ---------------------------------------------------------------------------
-dnl End Macro: SETSOCKOPT_TEST
+dnl End Macro: SETSOCKOPT_SANITY
dnl ---------------------------------------------------------------------------
+++ /dev/null
-BUILD_UTILLIB=yes
-
-AC_ARG_ENABLE(utils,
- [ --enable-utils Build libmemcachedutils [[default=yes]]],
- [
- if test "x$enableval" = "xno"; then
- BUILD_UTILLIB="no"
- fi
- ]
- )
-
-if test "x$BUILD_UTILLIB" = "xyes"; then
- AC_SEARCH_LIBS(pthread_create, pthread)
- if test "x$ac_cv_search_pthread_create" = "xno"; then
- AC_MSG_ERROR([Sorry you need POSIX thread library to build libmemcachedutil.])
- fi
- AC_DEFINE([HAVE_LIBMEMCACHEDUTIL], [1], [Enables libmemcachedutil Support])
-fi
-
-AM_CONDITIONAL([BUILD_LIBMEMCACHEDUTIL],[test "x$BUILD_UTILLIB" = "xyes"])
noinst_HEADERS = test.h server.h ketama_test_cases.h
noinst_PROGRAMS = testapp testplus udptest atomsmasher startservers
+testapp_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
testapp_SOURCES = test.c function.c server.c ../clients/generator.c ../clients/execute.c
testapp_LDADD = $(LDADDS)
uint32_t test_bit;
uint8_t which;
- test_bit= random() % GLOBAL_COUNT;
- which= random() % 2;
+ test_bit= (uint32_t)(random() % GLOBAL_COUNT);
+ which= (uint8_t)(random() % 2);
if (which == 0)
{
for (x= 0; x < TEST_PORT_COUNT; x++)
{
- test_ports[x]= random() % 64000;
+ test_ports[x]= (uint32_t)random() % 64000;
rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
assert(local_memc->number_of_hosts == x + 1);
assert(local_memc->hosts[0].count == x+1);
for (x= 0; x < TEST_PORT_COUNT; x++)
{
- test_ports[x]= random() % 64000;
+ test_ports[x]= (uint32_t)(random() % 64000);
rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
assert(local_memc->number_of_hosts == x+1);
assert(local_memc->hosts[0].count == x+1);
{
/* All null? */
{
- memcached_st *clone;
- clone= memcached_clone(NULL, NULL);
- assert(clone);
- memcached_free(clone);
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, NULL);
+ assert(memc_clone);
+ memcached_free(memc_clone);
}
/* Can we init from null? */
{
- memcached_st *clone;
- clone= memcached_clone(NULL, memc);
- assert(clone);
-
- assert(clone->call_free == memc->call_free);
- assert(clone->call_malloc == memc->call_malloc);
- assert(clone->call_realloc == memc->call_realloc);
- assert(clone->call_calloc == memc->call_calloc);
- assert(clone->connect_timeout == memc->connect_timeout);
- assert(clone->delete_trigger == memc->delete_trigger);
- assert(clone->distribution == memc->distribution);
- assert(clone->flags == memc->flags);
- assert(clone->get_key_failure == memc->get_key_failure);
- assert(clone->hash == memc->hash);
- assert(clone->hash_continuum == memc->hash_continuum);
- assert(clone->io_bytes_watermark == memc->io_bytes_watermark);
- assert(clone->io_msg_watermark == memc->io_msg_watermark);
- assert(clone->io_key_prefetch == memc->io_key_prefetch);
- assert(clone->on_cleanup == memc->on_cleanup);
- assert(clone->on_clone == memc->on_clone);
- assert(clone->poll_timeout == memc->poll_timeout);
- assert(clone->rcv_timeout == memc->rcv_timeout);
- assert(clone->recv_size == memc->recv_size);
- assert(clone->retry_timeout == memc->retry_timeout);
- assert(clone->send_size == memc->send_size);
- assert(clone->server_failure_limit == memc->server_failure_limit);
- assert(clone->snd_timeout == memc->snd_timeout);
- assert(clone->user_data == memc->user_data);
- assert(clone->number_of_replicas == memc->number_of_replicas);
-
- memcached_free(clone);
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone);
+
+ assert(memc_clone->call_free == memc->call_free);
+ assert(memc_clone->call_malloc == memc->call_malloc);
+ assert(memc_clone->call_realloc == memc->call_realloc);
+ assert(memc_clone->call_calloc == memc->call_calloc);
+ assert(memc_clone->connect_timeout == memc->connect_timeout);
+ assert(memc_clone->delete_trigger == memc->delete_trigger);
+ assert(memc_clone->distribution == memc->distribution);
+ assert(memc_clone->flags == memc->flags);
+ assert(memc_clone->get_key_failure == memc->get_key_failure);
+ assert(memc_clone->hash == memc->hash);
+ assert(memc_clone->hash_continuum == memc->hash_continuum);
+ assert(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
+ assert(memc_clone->io_msg_watermark == memc->io_msg_watermark);
+ assert(memc_clone->io_key_prefetch == memc->io_key_prefetch);
+ assert(memc_clone->on_cleanup == memc->on_cleanup);
+ assert(memc_clone->on_clone == memc->on_clone);
+ assert(memc_clone->poll_timeout == memc->poll_timeout);
+ assert(memc_clone->rcv_timeout == memc->rcv_timeout);
+ assert(memc_clone->recv_size == memc->recv_size);
+ assert(memc_clone->retry_timeout == memc->retry_timeout);
+ assert(memc_clone->send_size == memc->send_size);
+ assert(memc_clone->server_failure_limit == memc->server_failure_limit);
+ assert(memc_clone->snd_timeout == memc->snd_timeout);
+ assert(memc_clone->user_data == memc->user_data);
+
+ memcached_free(memc_clone);
}
/* Can we init from struct? */
{
memcached_st declared_clone;
- memcached_st *clone;
+ memcached_st *memc_clone;
memset(&declared_clone, 0 , sizeof(memcached_st));
- clone= memcached_clone(&declared_clone, NULL);
- assert(clone);
- memcached_free(clone);
+ memc_clone= memcached_clone(&declared_clone, NULL);
+ assert(memc_clone);
+ memcached_free(memc_clone);
}
/* Can we init from struct? */
{
memcached_st declared_clone;
- memcached_st *clone;
+ memcached_st *memc_clone;
memset(&declared_clone, 0 , sizeof(memcached_st));
- clone= memcached_clone(&declared_clone, memc);
- assert(clone);
- memcached_free(clone);
+ memc_clone= memcached_clone(&declared_clone, memc);
+ assert(memc_clone);
+ memcached_free(memc_clone);
}
return 0;
static test_return userdata_test(memcached_st *memc)
{
- void* foo;
+ void* foo= NULL;
assert(memcached_set_user_data(memc, foo) == NULL);
assert(memcached_get_user_data(memc) == foo);
assert(memcached_set_user_data(memc, NULL) == foo);
char *string;
size_t string_length;
uint32_t flags;
- memcached_st *clone;
+ memcached_st *memc_clone;
unsigned int set= 1;
size_t max_keylen= 0xffff;
- clone= memcached_clone(NULL, memc);
- assert(clone);
+ memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone);
- rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
assert(rc == MEMCACHED_SUCCESS);
/* All keys are valid in the binary protocol (except for length) */
- if (memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
+ if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
{
- string= memcached_get(clone, key, strlen(key),
+ string= memcached_get(memc_clone, key, strlen(key),
&string_length, &flags, &rc);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
assert(string_length == 0);
assert(!string);
set= 0;
- rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
assert(rc == MEMCACHED_SUCCESS);
- string= memcached_get(clone, key, strlen(key),
+ string= memcached_get(memc_clone, key, strlen(key),
&string_length, &flags, &rc);
assert(rc == MEMCACHED_NOTFOUND);
assert(string_length == 0);
char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
size_t key_lengths[] = { 7, 7, 7 };
set= 1;
- rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
assert(rc == MEMCACHED_SUCCESS);
- rc= memcached_mget(clone, keys, key_lengths, 3);
+ rc= memcached_mget(memc_clone, keys, key_lengths, 3);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
- rc= memcached_mget_by_key(clone, "foo daddy", 9, keys, key_lengths, 1);
+ rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
max_keylen= 250;
memcached server is updated to allow max size length of the keys in the
binary protocol
*/
- rc= memcached_callback_set(clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
+ rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
assert(rc == MEMCACHED_SUCCESS);
char *longkey= malloc(max_keylen + 1);
if (longkey != NULL)
{
memset(longkey, 'a', max_keylen + 1);
- string= memcached_get(clone, longkey, max_keylen,
+ string= memcached_get(memc_clone, longkey, max_keylen,
&string_length, &flags, &rc);
assert(rc == MEMCACHED_NOTFOUND);
assert(string_length == 0);
assert(!string);
- string= memcached_get(clone, longkey, max_keylen + 1,
+ string= memcached_get(memc_clone, longkey, max_keylen + 1,
&string_length, &flags, &rc);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
assert(string_length == 0);
/* Make sure zero length keys are marked as bad */
set= 1;
- rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
assert(rc == MEMCACHED_SUCCESS);
- string= memcached_get(clone, key, 0,
+ string= memcached_get(memc_clone, key, 0,
&string_length, &flags, &rc);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
assert(string_length == 0);
assert(!string);
- memcached_free(clone);
+ memcached_free(memc_clone);
return 0;
}
static test_return stats_servername_test(memcached_st *memc)
{
memcached_return rc;
- memcached_stat_st stat;
- rc= memcached_stat_servername(&stat, NULL,
+ memcached_stat_st memc_stat;
+ rc= memcached_stat_servername(&memc_stat, NULL,
memc->hosts[0].hostname,
memc->hosts[0].port);
{
char **list;
char **ptr;
- memcached_stat_st stat;
+ memcached_stat_st memc_stat;
memcached_return rc;
- list= memcached_stat_get_keys(memc, &stat, &rc);
+ list= memcached_stat_get_keys(memc, &memc_stat, &rc);
assert(rc == MEMCACHED_SUCCESS);
for (ptr= list; *ptr; ptr++)
assert(*ptr);
char **list;
char **ptr;
memcached_return rc;
- memcached_stat_st *stat;
+ memcached_stat_st *memc_stat;
- stat= memcached_stat(memc, NULL, &rc);
+ memc_stat= memcached_stat(memc, NULL, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(rc == MEMCACHED_SUCCESS);
- assert(stat);
+ assert(memc_stat);
for (x= 0; x < memcached_server_count(memc); x++)
{
- list= memcached_stat_get_keys(memc, stat+x, &rc);
+ list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
assert(rc == MEMCACHED_SUCCESS);
for (ptr= list; *ptr; ptr++);
free(list);
}
- memcached_stat_free(NULL, stat);
+ memcached_stat_free(NULL, memc_stat);
return 0;
}
return 0;
}
-static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *clone __attribute__((unused)))
+static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
{
return MEMCACHED_SUCCESS;
}
{
unsigned int j= 0;
- size= (rand() % ( 5 * 1024 ) ) + 400;
+ size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
memset(randomstuff, 0, 6 * 1024);
assert(size < 6 * 1024); /* Being safe here */
for (j= 0 ; j < size ;j++)
- randomstuff[j] = (char) (rand() % 26) + 97;
+ randomstuff[j] = (signed char) ((rand() % 26) + 97);
total += size;
sprintf(key, "%d", x);
char insert_data[VALUE_SIZE_BUG5];
for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= rand();
+ insert_data[x]= (signed char)rand();
memcached_flush(memc, 0);
value= memcached_get(memc, keys[0], key_length[0],
char insert_data[VALUE_SIZE_BUG5];
for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= rand();
+ insert_data[x]= (signed char)rand();
memcached_flush(memc, 0);
value= memcached_get(memc, keys[0], key_length[0],
{
memcached_return rc;
memcached_st *mine;
- memcached_st *clone;
+ memcached_st *memc_clone;
memcached_server_st *servers;
char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
memcached_server_list_free(servers);
assert(mine);
- clone= memcached_clone(NULL, mine);
+ memc_clone= memcached_clone(NULL, mine);
memcached_quit(mine);
- memcached_quit(clone);
+ memcached_quit(memc_clone);
memcached_free(mine);
- memcached_free(clone);
+ memcached_free(memc_clone);
return 0;
}
char insert_data[VALUE_SIZE_BUG5];
for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= rand();
+ insert_data[x]= (signed char)rand();
memcached_flush(memc, 0);
char *value;
size_t value_length= 512;
unsigned int x;
- int key_len= 3;
+ size_t key_len= 3;
memcached_return rc;
unsigned int set= 1;
memcached_st *mclone= memcached_clone(NULL, memc);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
timeout= 2;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+ (uint64_t)timeout);
value = (char*)malloc(value_length * sizeof(char));
char *value;
size_t value_length= 512;
unsigned int x;
- int key_len= 3;
+ size_t key_len= 3;
memcached_return rc;
unsigned int set= 1;
int32_t timeout;
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
timeout= -1;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+ (size_t)timeout);
timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
*/
static test_return user_supplied_bug14(memcached_st *memc)
{
- int setter= 1;
+ size_t setter= 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
memcached_return rc;
char *key= "foo";
static test_return user_supplied_bug18(memcached_st *trash)
{
memcached_return rc;
- int value;
+ uint64_t value;
int x;
memcached_server_st *server_pool;
memcached_st *memc;
}
static test_return generate_buffer_data(memcached_st *memc)
{
- int latch= 0;
+ size_t latch= 0;
latch= 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
{
unsigned int x;
memcached_return rc;
- memcached_st *clone;
+ memcached_st *memc_clone;
- clone= memcached_clone(NULL, memc);
- assert(clone);
+ memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone);
- memcached_server_add_with_weight(clone, "localhost", 6666, 0);
+ memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
{
char *return_value;
for (x= count= 0; x < global_count; x++)
{
- return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
+ return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
&return_value_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
{
fprintf(stderr, "\t%u -> %u", global_count, count);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return 0;
}
static test_return delete_buffer_generate(memcached_st *memc)
{
- int latch= 0;
+ size_t latch= 0;
unsigned int x;
latch= 1;
static memcached_return pre_nonblock_binary(memcached_st *memc)
{
memcached_return rc= MEMCACHED_FAILURE;
- memcached_st *clone;
+ memcached_st *memc_clone;
- clone= memcached_clone(NULL, memc);
- assert(clone);
+ memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
- memcached_version(clone);
+ memcached_version(memc_clone);
- if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
+ if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return rc;
}
static memcached_return pre_binary(memcached_st *memc)
{
memcached_return rc= MEMCACHED_FAILURE;
- memcached_st *clone;
+ memcached_st *memc_clone;
- clone= memcached_clone(NULL, memc);
- assert(clone);
+ memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
- memcached_version(clone);
+ memcached_version(memc_clone);
- if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
+ if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
assert(rc == MEMCACHED_SUCCESS);
assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return rc;
}
static memcached_return poll_timeout(memcached_st *memc)
{
- int32_t timeout;
+ size_t timeout;
timeout= 100;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
- timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+ timeout= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
assert(timeout == 100);
for (int x=0; x < 100; ++x)
{
char key[10];
- size_t len= sprintf(key, "%d", x);
+ size_t len= (size_t)sprintf(key, "%d", x);
switch (count)
{
case 0:
case 4:
ret=memcached_prepend(memc, key, len, key, len, 0, 0);
break;
+ default:
+ assert(count);
+ break;
}
assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
}
*/
int no_msg=0;
for (uint32_t x=0; x < memc->number_of_hosts; ++x)
- no_msg+=memc->hosts[x].cursor_active;
+ no_msg+=(int)(memc->hosts[x].cursor_active);
assert(no_msg == 0);
assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
for (int x=0; x < 100; ++x)
{
char key[10];
- size_t len= sprintf(key, "%d", x);
+ size_t len= (size_t)sprintf(key, "%d", x);
size_t length;
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
case 4:
assert(length == len * 3);
break;
+ default:
+ assert(count);
+ break;
}
free(value);
}
static test_return analyzer_test(memcached_st *memc)
{
memcached_return rc;
- memcached_stat_st *stat;
+ memcached_stat_st *memc_stat;
memcached_analysis_st *report;
- stat= memcached_stat(memc, NULL, &rc);
+ memc_stat= memcached_stat(memc, NULL, &rc);
assert(rc == MEMCACHED_SUCCESS);
- assert(stat);
+ assert(memc_stat);
- report= memcached_analyze(memc, stat, &rc);
+ report= memcached_analyze(memc, memc_stat, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(report);
free(report);
- memcached_stat_free(NULL, stat);
+ memcached_stat_free(NULL, memc_stat);
return TEST_SUCCESS;
}
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library
*/
- for (int host= 0; host < memc->number_of_hosts; ++host) {
+ for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
+ {
memcached_st *clone= memcached_clone(NULL, memc);
clone->hosts[host].port= 0;
* This is to verify correct behavior in the library
*/
memcached_result_st result_obj;
- for (int host= 0; host < clone->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < clone->number_of_hosts; host++)
{
- memcached_st *clone= memcached_clone(NULL, memc);
- clone->hosts[host].port= 0;
+ memcached_st *new_clone= memcached_clone(NULL, memc);
+ new_clone->hosts[host].port= 0;
for (int x= 'a'; x <= 'z'; ++x)
{
char key[2]= { [0]= (char)x };
- rc= memcached_mget_by_key(clone, key, 1, keys, len, 4);
+ rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
- memcached_result_st *results= memcached_result_create(clone, &result_obj);
+ memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
assert(results);
int hits= 0;
- while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+ while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
{
hits++;
}
memcached_result_free(&result_obj);
}
- memcached_free(clone);
+ memcached_free(new_clone);
}
return TEST_SUCCESS;
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library
*/
- int hash= memcached_generate_hash(memc, keys[0], len[0]);
- for (int x= 0; x < (repl + 1); ++x) {
+ uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
+ for (uint32_t x= 0; x < (repl + 1); ++x)
+ {
clone->hosts[hash].port= 0;
if (++hash == clone->number_of_hosts)
hash= 0;
}
memcached_result_st result_obj;
- for (int host= 0; host < clone->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < clone->number_of_hosts; ++host)
{
for (int x= 'a'; x <= 'z'; ++x)
{
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
Error 22 -> SERVER DELETE
Error 23 -> SERVER VALUE
Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
-Error 26 -> SYSTEM ERROR
-Error 27 -> COULD NOT OPEN UNIX SOCKET
-Error 28 -> ACTION NOT SUPPORTED
-Error 29 -> A KEY LENGTH OF ZERO WAS PROVIDED
-Error 30 -> FETCH WAS NOT COMPLETED
-Error 31 -> A TIMEOUT OCCURRED
-Error 32 -> ACTION QUEUED
-Error 33 -> A BAD KEY WAS PROVIDED/CHARACTERS OUT OF RANGE
-Error 34 -> THE HOST TRANSPORT PROTOCOL DOES NOT MATCH THAT OF THE CLIENT
-Error 35 -> SERVER IS MARKED DEAD
-Error 36 -> ENCOUNTERED AN UNKNOWN STAT KEY
-Error 0 -> SUCCESS
-Error 1 -> FAILURE
-Error 2 -> HOSTNAME LOOKUP FAILURE
-Error 3 -> CONNECTION FAILURE
-Error 4 -> CONNECTION BIND FAILURE
-Error 5 -> WRITE FAILURE
-Error 6 -> READ FAILURE
-Error 7 -> UNKNOWN READ FAILURE
-Error 8 -> PROTOCOL ERROR
-Error 9 -> CLIENT ERROR
-Error 10 -> SERVER ERROR
-Error 11 -> CONNECTION SOCKET CREATE FAILURE
-Error 12 -> CONNECTION DATA EXISTS
-Error 13 -> CONNECTION DATA DOES NOT EXIST
-Error 14 -> NOT STORED
-Error 15 -> STORED
-Error 16 -> NOT FOUND
-Error 17 -> MEMORY ALLOCATION FAILURE
-Error 18 -> PARTIAL READ
-Error 19 -> SOME ERRORS WERE REPORTED
-Error 20 -> NO SERVERS DEFINED
-Error 21 -> SERVER END
-Error 22 -> SERVER DELETE
-Error 23 -> SERVER VALUE
-Error 24 -> STAT VALUE
-Error 25 -> Gibberish returned!
+Error 25 -> ITEM VALUE
Error 26 -> SYSTEM ERROR
Error 27 -> COULD NOT OPEN UNIX SOCKET
Error 28 -> ACTION NOT SUPPORTED
{
if (fgets(buffer, sizeof(buffer), fp) != NULL)
{
- pid_t pid = atol(buffer);
+ pid_t pid = (pid_t)atol(buffer);
if (pid != 0)
kill(pid, SIGTERM);
}
assert(construct->servers);
- srandom(time(NULL));
+ srandom((unsigned int)time(NULL));
for (x= 0; x < memcached_server_list_count(construct->servers); x++)
{
{
register int us, s;
- us = a.tv_usec - b.tv_usec;
+ us = (int)(a.tv_usec - b.tv_usec);
us /= 1000;
- s = a.tv_sec - b.tv_sec;
+ s = (int)(a.tv_sec - b.tv_sec);
s *= 1000;
return s + us;
}
if (next->pre)
{
- memcached_return rc;
rc= next->pre(memc);
if (rc != MEMCACHED_SUCCESS)
projects / m6w6 / libmemcached / commitdiff
