grpc 1.7.3 → 1.8.0

data/src/core/lib/support/{murmur_hash.c → murmur_hash.cc}

@@ -29,23 +29,20 @@
   (h) *= 0xc2b2ae35; \
   (h) ^= (h) >> 16;
 
-uint32_t gpr_murmur_hash3(const void *key, size_t len, uint32_t seed) {
-  const uint8_t *data = (const uint8_t *)key;
-  const size_t nblocks = len / 4;
-  int i;
-
+uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed) {
   uint32_t h1 = seed;
   uint32_t k1;
 
   const uint32_t c1 = 0xcc9e2d51;
   const uint32_t c2 = 0x1b873593;
 
-  const uint32_t *blocks = ((const uint32_t *)key) + nblocks;
-  const uint8_t *tail = (const uint8_t *)(data + nblocks * 4);
+  const uint8_t* keyptr = (const uint8_t*)key;
+  const size_t bsize = sizeof(k1);
+  const size_t nblocks = len / bsize;
 
   /* body */
-  for (i = -(int)nblocks; i; i++) {
-    memcpy(&k1, blocks + i, sizeof(uint32_t));
+  for (size_t i = 0; i < nblocks; i++, keyptr += bsize) {
+    memcpy(&k1, keyptr, bsize);
 
     k1 *= c1;
     k1 = ROTL32(k1, 15);
@@ -61,13 +58,13 @@ uint32_t gpr_murmur_hash3(const void *key, size_t len, uint32_t seed) {
   /* tail */
   switch (len & 3) {
     case 3:
-      k1 ^= ((uint32_t)tail[2]) << 16;
+      k1 ^= ((uint32_t)keyptr[2]) << 16;
     /* fallthrough */
     case 2:
-      k1 ^= ((uint32_t)tail[1]) << 8;
+      k1 ^= ((uint32_t)keyptr[1]) << 8;
     /* fallthrough */
     case 1:
-      k1 ^= tail[0];
+      k1 ^= keyptr[0];
       k1 *= c1;
       k1 = ROTL32(k1, 15);
       k1 *= c2;

data/src/core/lib/support/murmur_hash.h

@@ -23,7 +23,15 @@
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* compute the hash of key (length len) */
-uint32_t gpr_murmur_hash3(const void *key, size_t len, uint32_t seed);
+uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SUPPORT_MURMUR_HASH_H */

data/src/core/lib/support/spinlock.h

@@ -23,11 +23,18 @@
 
 /* Simple spinlock. No backoff strategy, gpr_spinlock_lock is almost always
    a concurrency code smell. */
-typedef struct { gpr_atm atm; } gpr_spinlock;
+typedef struct {
+  gpr_atm atm;
+} gpr_spinlock;
 
+#ifdef __cplusplus
+#define GPR_SPINLOCK_INITIALIZER (gpr_spinlock{0})
+#else
 #define GPR_SPINLOCK_INITIALIZER ((gpr_spinlock){0})
+#endif
 #define GPR_SPINLOCK_STATIC_INITIALIZER \
   { 0 }
+
 #define gpr_spinlock_trylock(lock) (gpr_atm_acq_cas(&(lock)->atm, 0, 1))
 #define gpr_spinlock_unlock(lock) (gpr_atm_rel_store(&(lock)->atm, 0))
 #define gpr_spinlock_lock(lock) \

data/src/core/lib/support/{string.c → string.cc}

@@ -27,18 +27,19 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
 
-char *gpr_strdup(const char *src) {
-  char *dst;
+char* gpr_strdup(const char* src) {
+  char* dst;
   size_t len;
 
   if (!src) {
-    return NULL;
+    return nullptr;
   }
 
   len = strlen(src) + 1;
-  dst = (char *)gpr_malloc(len);
+  dst = (char*)gpr_malloc(len);
 
   memcpy(dst, src, len);
 
@@ -48,28 +49,28 @@ char *gpr_strdup(const char *src) {
 typedef struct {
   size_t capacity;
   size_t length;
-  char *data;
+  char* data;
 } dump_out;
 
 static dump_out dump_out_create(void) {
-  dump_out r = {0, 0, NULL};
+  dump_out r = {0, 0, nullptr};
   return r;
 }
 
-static void dump_out_append(dump_out *out, char c) {
+static void dump_out_append(dump_out* out, char c) {
   if (out->length == out->capacity) {
     out->capacity = GPR_MAX(8, 2 * out->capacity);
-    out->data = (char *)gpr_realloc(out->data, out->capacity);
+    out->data = (char*)gpr_realloc(out->data, out->capacity);
   }
   out->data[out->length++] = c;
 }
 
-static void hexdump(dump_out *out, const char *buf, size_t len) {
-  static const char *hex = "0123456789abcdef";
+static void hexdump(dump_out* out, const char* buf, size_t len) {
+  static const char* hex = "0123456789abcdef";
 
-  const uint8_t *const beg = (const uint8_t *)buf;
-  const uint8_t *const end = beg + len;
-  const uint8_t *cur;
+  const uint8_t* const beg = (const uint8_t*)buf;
+  const uint8_t* const end = beg + len;
+  const uint8_t* cur;
 
   for (cur = beg; cur != end; ++cur) {
     if (cur != beg) dump_out_append(out, ' ');
@@ -78,24 +79,24 @@ static void hexdump(dump_out *out, const char *buf, size_t len) {
   }
 }
 
-static void asciidump(dump_out *out, const char *buf, size_t len) {
-  const uint8_t *const beg = (const uint8_t *)buf;
-  const uint8_t *const end = beg + len;
-  const uint8_t *cur;
+static void asciidump(dump_out* out, const char* buf, size_t len) {
+  const uint8_t* const beg = (const uint8_t*)buf;
+  const uint8_t* const end = beg + len;
+  const uint8_t* cur;
   int out_was_empty = (out->length == 0);
   if (!out_was_empty) {
     dump_out_append(out, ' ');
     dump_out_append(out, '\'');
   }
   for (cur = beg; cur != end; ++cur) {
-    dump_out_append(out, (char)(isprint(*cur) ? *(char *)cur : '.'));
+    dump_out_append(out, (char)(isprint(*cur) ? *(char*)cur : '.'));
   }
   if (!out_was_empty) {
     dump_out_append(out, '\'');
   }
 }
 
-char *gpr_dump(const char *buf, size_t len, uint32_t flags) {
+char* gpr_dump(const char* buf, size_t len, uint32_t flags) {
   dump_out out = dump_out_create();
   if (flags & GPR_DUMP_HEX) {
     hexdump(&out, buf, len);
@@ -107,7 +108,7 @@ char *gpr_dump(const char *buf, size_t len, uint32_t flags) {
   return out.data;
 }
 
-int gpr_parse_bytes_to_uint32(const char *buf, size_t len, uint32_t *result) {
+int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) {
   uint32_t out = 0;
   uint32_t new_val;
   size_t i;
@@ -125,7 +126,7 @@ int gpr_parse_bytes_to_uint32(const char *buf, size_t len, uint32_t *result) {
   return 1;
 }
 
-void gpr_reverse_bytes(char *str, int len) {
+void gpr_reverse_bytes(char* str, int len) {
   char *p1, *p2;
   for (p1 = str, p2 = str + len - 1; p2 > p1; ++p1, --p2) {
     char temp = *p1;
@@ -134,7 +135,7 @@ void gpr_reverse_bytes(char *str, int len) {
   }
 }
 
-int gpr_ltoa(long value, char *string) {
+int gpr_ltoa(long value, char* string) {
   long sign;
   int i = 0;
 
@@ -155,7 +156,7 @@ int gpr_ltoa(long value, char *string) {
   return i;
 }
 
-int int64_ttoa(int64_t value, char *string) {
+int int64_ttoa(int64_t value, char* string) {
   int64_t sign;
   int i = 0;
 
@@ -176,33 +177,33 @@ int int64_ttoa(int64_t value, char *string) {
   return i;
 }
 
-int gpr_parse_nonnegative_int(const char *value) {
-  char *end;
+int gpr_parse_nonnegative_int(const char* value) {
+  char* end;
   long result = strtol(value, &end, 0);
   if (*end != '\0' || result < 0 || result > INT_MAX) return -1;
   return (int)result;
 }
 
-char *gpr_leftpad(const char *str, char flag, size_t length) {
+char* gpr_leftpad(const char* str, char flag, size_t length) {
   const size_t str_length = strlen(str);
   const size_t out_length = str_length > length ? str_length : length;
-  char *out = (char *)gpr_malloc(out_length + 1);
+  char* out = (char*)gpr_malloc(out_length + 1);
   memset(out, flag, out_length - str_length);
   memcpy(out + out_length - str_length, str, str_length);
   out[out_length] = 0;
   return out;
 }
 
-char *gpr_strjoin(const char **strs, size_t nstrs, size_t *final_length) {
+char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length) {
   return gpr_strjoin_sep(strs, nstrs, "", final_length);
 }
 
-char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
-                      size_t *final_length) {
+char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
+                      size_t* final_length) {
   const size_t sep_len = strlen(sep);
   size_t out_length = 0;
   size_t i;
-  char *out;
+  char* out;
   for (i = 0; i < nstrs; i++) {
     out_length += strlen(strs[i]);
   }
@@ -210,7 +211,7 @@ char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
   if (nstrs > 0) {
     out_length += sep_len * (nstrs - 1); /* separators */
   }
-  out = (char *)gpr_malloc(out_length);
+  out = (char*)gpr_malloc(out_length);
   out_length = 0;
   for (i = 0; i < nstrs; i++) {
     const size_t slen = strlen(strs[i]);
@@ -222,15 +223,15 @@ char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
     out_length += slen;
   }
   out[out_length] = 0;
-  if (final_length != NULL) {
+  if (final_length != nullptr) {
     *final_length = out_length;
   }
   return out;
 }
 
-void gpr_strvec_init(gpr_strvec *sv) { memset(sv, 0, sizeof(*sv)); }
+void gpr_strvec_init(gpr_strvec* sv) { memset(sv, 0, sizeof(*sv)); }
 
-void gpr_strvec_destroy(gpr_strvec *sv) {
+void gpr_strvec_destroy(gpr_strvec* sv) {
   size_t i;
   for (i = 0; i < sv->count; i++) {
     gpr_free(sv->strs[i]);
@@ -238,19 +239,19 @@ void gpr_strvec_destroy(gpr_strvec *sv) {
   gpr_free(sv->strs);
 }
 
-void gpr_strvec_add(gpr_strvec *sv, char *str) {
+void gpr_strvec_add(gpr_strvec* sv, char* str) {
   if (sv->count == sv->capacity) {
     sv->capacity = GPR_MAX(sv->capacity + 8, sv->capacity * 2);
-    sv->strs = (char **)gpr_realloc(sv->strs, sizeof(char *) * sv->capacity);
+    sv->strs = (char**)gpr_realloc(sv->strs, sizeof(char*) * sv->capacity);
   }
   sv->strs[sv->count++] = str;
 }
 
-char *gpr_strvec_flatten(gpr_strvec *sv, size_t *final_length) {
-  return gpr_strjoin((const char **)sv->strs, sv->count, final_length);
+char* gpr_strvec_flatten(gpr_strvec* sv, size_t* final_length) {
+  return gpr_strjoin((const char**)sv->strs, sv->count, final_length);
 }
 
-int gpr_stricmp(const char *a, const char *b) {
+int gpr_stricmp(const char* a, const char* b) {
   int ca, cb;
   do {
     ca = tolower(*a);
@@ -261,23 +262,23 @@ int gpr_stricmp(const char *a, const char *b) {
   return ca - cb;
 }
 
-static void add_string_to_split(const char *beg, const char *end, char ***strs,
-                                size_t *nstrs, size_t *capstrs) {
-  char *out = (char *)gpr_malloc((size_t)(end - beg) + 1);
+static void add_string_to_split(const char* beg, const char* end, char*** strs,
+                                size_t* nstrs, size_t* capstrs) {
+  char* out = (char*)gpr_malloc((size_t)(end - beg) + 1);
   memcpy(out, beg, (size_t)(end - beg));
   out[end - beg] = 0;
   if (*nstrs == *capstrs) {
     *capstrs = GPR_MAX(8, 2 * *capstrs);
-    *strs = (char **)gpr_realloc(*strs, sizeof(*strs) * *capstrs);
+    *strs = (char**)gpr_realloc(*strs, sizeof(*strs) * *capstrs);
   }
   (*strs)[*nstrs] = out;
   ++*nstrs;
 }
 
-void gpr_string_split(const char *input, const char *sep, char ***strs,
-                      size_t *nstrs) {
-  const char *next;
-  *strs = NULL;
+void gpr_string_split(const char* input, const char* sep, char*** strs,
+                      size_t* nstrs) {
+  const char* next;
+  *strs = nullptr;
   *nstrs = 0;
   size_t capstrs = 0;
   while ((next = strstr(input, sep))) {
@@ -287,24 +288,24 @@ void gpr_string_split(const char *input, const char *sep, char ***strs,
   add_string_to_split(input, input + strlen(input), strs, nstrs, &capstrs);
 }
 
-void *gpr_memrchr(const void *s, int c, size_t n) {
-  if (s == NULL) return NULL;
-  char *b = (char *)s;
+void* gpr_memrchr(const void* s, int c, size_t n) {
+  if (s == nullptr) return nullptr;
+  char* b = (char*)s;
   size_t i;
   for (i = 0; i < n; i++) {
     if (b[n - i - 1] == c) {
       return &b[n - i - 1];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-bool gpr_is_true(const char *s) {
+bool gpr_is_true(const char* s) {
   size_t i;
-  if (s == NULL) {
+  if (s == nullptr) {
     return false;
   }
-  static const char *truthy[] = {"yes", "true", "1"};
+  static const char* truthy[] = {"yes", "true", "1"};
   for (i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
     if (0 == gpr_stricmp(s, truthy[i])) {
       return true;

data/src/core/lib/support/string.h

@@ -36,12 +36,12 @@ extern "C" {
 
 /* Converts array buf, of length len, into a C string  according to the flags.
    Result should be freed with gpr_free() */
-char *gpr_dump(const char *buf, size_t len, uint32_t flags);
+char* gpr_dump(const char* buf, size_t len, uint32_t flags);
 
 /* Parses an array of bytes into an integer (base 10). Returns 1 on success,
    0 on failure. */
-int gpr_parse_bytes_to_uint32(const char *data, size_t length,
-                              uint32_t *result);
+int gpr_parse_bytes_to_uint32(const char* data, size_t length,
+                              uint32_t* result);
 
 /* Minimum buffer size for calling ltoa */
 #define GPR_LTOA_MIN_BUFSIZE (3 * sizeof(long))
@@ -49,7 +49,7 @@ int gpr_parse_bytes_to_uint32(const char *data, size_t length,
 /* Convert a long to a string in base 10; returns the length of the
    output string (or 0 on failure).
    output must be at least GPR_LTOA_MIN_BUFSIZE bytes long. */
-int gpr_ltoa(long value, char *output);
+int gpr_ltoa(long value, char* output);
 
 /* Minimum buffer size for calling int64toa */
 #define GPR_INT64TOA_MIN_BUFSIZE (3 * sizeof(int64_t))
@@ -59,56 +59,56 @@ output string (or 0 on failure).
 output must be at least GPR_INT64TOA_MIN_BUFSIZE bytes long.
 NOTE: This function ensures sufficient bit width even on Win x64,
 where long is 32bit is size.*/
-int int64_ttoa(int64_t value, char *output);
+int int64_ttoa(int64_t value, char* output);
 
 // Parses a non-negative number from a value string.  Returns -1 on error.
-int gpr_parse_nonnegative_int(const char *value);
+int gpr_parse_nonnegative_int(const char* value);
 
 /* Reverse a run of bytes */
-void gpr_reverse_bytes(char *str, int len);
+void gpr_reverse_bytes(char* str, int len);
 
 /* Pad a string with flag characters. The given length specifies the minimum
    field width. The input string is never truncated. */
-char *gpr_leftpad(const char *str, char flag, size_t length);
+char* gpr_leftpad(const char* str, char flag, size_t length);
 
 /* Join a set of strings, returning the resulting string.
    Total combined length (excluding null terminator) is returned in total_length
    if it is non-null. */
-char *gpr_strjoin(const char **strs, size_t nstrs, size_t *total_length);
+char* gpr_strjoin(const char** strs, size_t nstrs, size_t* total_length);
 
 /* Join a set of strings using a separator, returning the resulting string.
    Total combined length (excluding null terminator) is returned in total_length
    if it is non-null. */
-char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
-                      size_t *total_length);
+char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
+                      size_t* total_length);
 
-void gpr_string_split(const char *input, const char *sep, char ***strs,
-                      size_t *nstrs);
+void gpr_string_split(const char* input, const char* sep, char*** strs,
+                      size_t* nstrs);
 
 /* A vector of strings... for building up a final string one piece at a time */
 typedef struct {
-  char **strs;
+  char** strs;
   size_t count;
   size_t capacity;
 } gpr_strvec;
 
 /* Initialize/destroy */
-void gpr_strvec_init(gpr_strvec *strs);
-void gpr_strvec_destroy(gpr_strvec *strs);
+void gpr_strvec_init(gpr_strvec* strs);
+void gpr_strvec_destroy(gpr_strvec* strs);
 /* Add a string to a strvec, takes ownership of the string */
-void gpr_strvec_add(gpr_strvec *strs, char *add);
+void gpr_strvec_add(gpr_strvec* strs, char* add);
 /* Return a joined string with all added substrings, optionally setting
    total_length as per gpr_strjoin */
-char *gpr_strvec_flatten(gpr_strvec *strs, size_t *total_length);
+char* gpr_strvec_flatten(gpr_strvec* strs, size_t* total_length);
 
 /** Case insensitive string comparison... return <0 if lower(a)<lower(b), ==0 if
     lower(a)==lower(b), >0 if lower(a)>lower(b) */
-int gpr_stricmp(const char *a, const char *b);
+int gpr_stricmp(const char* a, const char* b);
 
-void *gpr_memrchr(const void *s, int c, size_t n);
+void* gpr_memrchr(const void* s, int c, size_t n);
 
 /** Return true if lower(s) equals "true", "yes" or "1", otherwise false. */
-bool gpr_is_true(const char *s);
+bool gpr_is_true(const char* s);
 #ifdef __cplusplus
 }
 #endif