From: Brian Aker <brian@tangent.org>
Date: Wed, 30 Nov 2011 16:43:24 +0000 (-0800)
Subject: Merge in work to test return types.
X-Git-Tag: 1.0.3~4^2
X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=c3136bce4decf4259ebb60ea2425b47017ad7bb1;hp=07affbd49a702e4dd9db927d9f19ffe3e3854038;p=awesomized%2Flibmemcached

Merge in work to test return types.
---

diff --git a/libmemcached-1.0/types.h b/libmemcached-1.0/types.h
index 3a4ae3bd..2781321e 100644
--- a/libmemcached-1.0/types.h
+++ b/libmemcached-1.0/types.h
@@ -38,6 +38,28 @@
 
 #pragma once
 
+#ifdef __cplusplus
+struct memcached_st;
+struct memcached_stat_st;
+struct memcached_analysis_st;
+struct memcached_result_st;
+struct memcached_array_st;
+struct memcached_error_t;
+
+// All of the flavors of memcache_server_st
+struct memcached_server_st;
+typedef const struct memcached_server_st *memcached_server_instance_st;
+typedef struct memcached_server_st *memcached_server_list_st;
+
+struct memcached_callback_st;
+
+// The following two structures are internal, and never exposed to users.
+struct memcached_string_st;
+struct memcached_string_t;
+struct memcached_continuum_item_st;
+
+#else
+
 typedef struct memcached_st memcached_st;
 typedef struct memcached_stat_st memcached_stat_st;
 typedef struct memcached_analysis_st memcached_analysis_st;
@@ -57,6 +79,8 @@ typedef struct memcached_string_st memcached_string_st;
 typedef struct memcached_string_t memcached_string_t;
 typedef struct memcached_continuum_item_st memcached_continuum_item_st;
 
+#endif
+
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/libmemcached/allocators.cc b/libmemcached/allocators.cc
index d18372b4..98c87591 100644
--- a/libmemcached/allocators.cc
+++ b/libmemcached/allocators.cc
@@ -60,7 +60,7 @@ void *_libmemcached_calloc(const memcached_st *self, size_t nelem, size_t size,
   if (self->allocators.malloc != _libmemcached_malloc)
   {
      void *ret = _libmemcached_malloc(self, nelem * size, context);
-     if (not ret)
+     if (ret == NULL)
      {
        memset(ret, 0, nelem * size);
      }
diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index e22871cd..f7764d0f 100644
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -62,7 +62,7 @@ static void _set(memcached_server_st& server, memcached_st& memc)
     return;
   }
 
-  memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
+  memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
   if (error == NULL) // Bad business if this happens
   {
     return;
@@ -112,7 +112,7 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t
     rc= MEMCACHED_CONNECTION_FAILURE;
   }
 
-  memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
+  memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
   if (error == NULL) // Bad business if this happens
   {
     return;
@@ -533,7 +533,7 @@ memcached_error_t *memcached_error_copy(const memcached_server_st& server)
     return NULL;
   }
 
-  memcached_error_t *error= (memcached_error_t *)libmemcached_malloc(server.root, sizeof(memcached_error_t));
+  memcached_error_t *error= libmemcached_xmalloc(server.root, memcached_error_t);
   memcpy(error, server.error_messages, sizeof(memcached_error_t));
   error->next= NULL;
 
diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index 4ad49a41..c10f2341 100644
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -680,8 +680,8 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr,
                               keys, key_length, number_of_keys, mget_mode);
   }
 
-  uint32_t* hash= static_cast<uint32_t*>(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys));
-  bool* dead_servers= static_cast<bool*>(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool)));
+  uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t);
+  bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool);
 
   if (hash == NULL || dead_servers == NULL)
   {
diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index fe3c977a..ac6b03ad 100644
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -184,8 +184,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
   {
     memcached_continuum_item_st *new_ptr;
 
-    new_ptr= static_cast<memcached_continuum_item_st*>(libmemcached_realloc(ptr, ptr->ketama.continuum,
-                                                                            sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server));
+    new_ptr= libmemcached_xrealloc(ptr, ptr->ketama.continuum, (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server, memcached_continuum_item_st);
 
     if (new_ptr == 0)
     {
@@ -353,8 +352,7 @@ static memcached_return_t server_add(memcached_st *ptr,
 {
   assert_msg(ptr, "Programmer mistake, somehow server_add() was passed a NULL memcached_st");
 
-  memcached_server_st *new_host_list= static_cast<memcached_server_st*>(libmemcached_realloc(ptr, memcached_server_list(ptr),
-                                                                                             sizeof(memcached_server_st) * (ptr->number_of_hosts + 1)));
+  memcached_server_st *new_host_list= libmemcached_xrealloc(ptr, memcached_server_list(ptr), (ptr->number_of_hosts + 1), memcached_server_st);
 
   if (new_host_list == NULL)
   {
@@ -396,8 +394,7 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
   uint32_t count= memcached_server_list_count(list);
 
   memcached_server_st *new_host_list;
-  new_host_list= static_cast<memcached_server_st*>(libmemcached_realloc(ptr, memcached_server_list(ptr),
-									sizeof(memcached_server_st) * (count + memcached_server_count(ptr))));
+  new_host_list= libmemcached_xrealloc(ptr, memcached_server_list(ptr), (count + memcached_server_count(ptr)), memcached_server_st);
 
   if (new_host_list == NULL)
   {
diff --git a/libmemcached/memory.h b/libmemcached/memory.h
index 65d06b8c..89ad6984 100644
--- a/libmemcached/memory.h
+++ b/libmemcached/memory.h
@@ -57,16 +57,19 @@ static inline void *libmemcached_malloc(const memcached_st *self, const size_t s
 
   return malloc(size);
 }
+#define libmemcached_xmalloc(__memcachd_st, __type) ((__type *)libmemcached_malloc((__memcachd_st), sizeof(__type)))
 
-static inline void *libmemcached_realloc(const memcached_st *self, void *mem, const size_t size)
+static inline void *libmemcached_realloc(const memcached_st *self, void *mem, size_t nmemb,  const size_t size)
 {
   if (self)
   {
-    return self->allocators.realloc(self, mem, size, self->allocators.context);
+    return self->allocators.realloc(self, mem, nmemb * size, self->allocators.context);
   }
 
   return realloc(mem, size);
 }
+#define libmemcached_xrealloc(__memcachd_st, __mem, __nelem, __type) ((__type *)libmemcached_realloc((__memcachd_st), (__mem), (__nelem), sizeof(__type)))
+#define libmemcached_xvalloc(__memcachd_st, __nelem, __type) ((__type *)libmemcached_realloc((__memcachd_st), NULL, (__nelem), sizeof(__type)))
 
 static inline void *libmemcached_calloc(const memcached_st *self, size_t nelem, size_t size)
 {
@@ -77,3 +80,4 @@ static inline void *libmemcached_calloc(const memcached_st *self, size_t nelem,
 
   return calloc(nelem, size);
 }
+#define libmemcached_xcalloc(__memcachd_st, __nelem, __type) ((__type *)libmemcached_calloc((__memcachd_st), (__nelem), sizeof(__type)))
diff --git a/libmemcached/result.cc b/libmemcached/result.cc
index 1a5095af..a3438c08 100644
--- a/libmemcached/result.cc
+++ b/libmemcached/result.cc
@@ -68,7 +68,7 @@ memcached_result_st *memcached_result_create(const memcached_st *memc,
   }
   else
   {
-    ptr= static_cast<memcached_result_st *>(libmemcached_malloc(memc, sizeof(memcached_result_st)));
+    ptr= libmemcached_xmalloc(memc, memcached_result_st);
 
     if (not ptr)
     {
diff --git a/libmemcached/sasl.cc b/libmemcached/sasl.cc
index 32906cc8..2e9bdc63 100644
--- a/libmemcached/sasl.cc
+++ b/libmemcached/sasl.cc
@@ -321,7 +321,7 @@ memcached_return_t memcached_set_sasl_auth_data(memcached_st *ptr,
 
   memcached_destroy_sasl_auth_data(ptr);
 
-  sasl_callback_t *callbacks= (sasl_callback_t*)libmemcached_calloc(ptr, 4, sizeof(sasl_callback_t));
+  sasl_callback_t *callbacks= libmemcached_xcalloc(ptr, 4, sasl_callback_t);
   size_t password_length= strlen(password);
   size_t username_length= strlen(username);
   char *name= (char *)libmemcached_malloc(ptr, username_length +1);
@@ -441,7 +441,7 @@ memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st
     ++total;
   }
 
-  sasl_callback_t *callbacks= (sasl_callback_t*)libmemcached_calloc(clone, total +1, sizeof(sasl_callback_t));
+  sasl_callback_t *callbacks= libmemcached_xcalloc(clone, total +1, sasl_callback_t);
   if (callbacks == NULL)
   {
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
diff --git a/libmemcached/server.cc b/libmemcached/server.cc
index e1b91b94..7011fd24 100644
--- a/libmemcached/server.cc
+++ b/libmemcached/server.cc
@@ -90,7 +90,7 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc
 {
   if (not self)
   {
-   self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st));
+   self= libmemcached_xmalloc(memc, struct memcached_server_st);
 
     if (not self)
     {
diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc
index 78fed03d..239c789d 100644
--- a/libmemcached/stats.cc
+++ b/libmemcached/stats.cc
@@ -486,7 +486,7 @@ memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_retu
     return NULL;
   }
 
-  memcached_stat_st *stats= static_cast<memcached_stat_st *>(libmemcached_calloc(self, memcached_server_count(self), sizeof(memcached_stat_st)));
+  memcached_stat_st *stats= libmemcached_xcalloc(self, memcached_server_count(self), memcached_stat_st);
 
   if (not stats)
   {
diff --git a/libmemcached/string.cc b/libmemcached/string.cc
index d482d4cd..a94d4421 100644
--- a/libmemcached/string.cc
+++ b/libmemcached/string.cc
@@ -43,7 +43,6 @@ inline static memcached_return_t _string_check(memcached_string_st *string, size
   if (need && need > (size_t)(string->current_size - (size_t)(string->end - string->string)))
   {
     size_t current_offset= (size_t) (string->end - string->string);
-    char *new_value;
     size_t adjust;
     size_t new_size;
 
@@ -56,9 +55,9 @@ inline static memcached_return_t _string_check(memcached_string_st *string, size
     if (new_size < need)
       return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
 
-    new_value= static_cast<char *>(libmemcached_realloc(string->root, string->string, new_size));
+    char *new_value= libmemcached_xrealloc(string->root, string->string, new_size, char);
 
-    if (not new_value)
+    if (new_value == NULL)
     {
       return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
     }
@@ -91,7 +90,7 @@ memcached_string_st *memcached_string_create(memcached_st *memc, memcached_strin
   }
   else
   {
-    self= static_cast<memcached_string_st *>(libmemcached_malloc(memc, sizeof(memcached_string_st)));
+    self= libmemcached_xmalloc(memc, memcached_string_st);
 
     if (self == NULL)
     {