grpc 1.7.3 → 1.8.0

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

@@ -29,17 +29,17 @@
 #include <grpc/support/string_util.h>
 #include "src/core/lib/support/string.h"
 
-const char *gpr_getenv_silent(const char *name, char **dst) {
+const char* gpr_getenv_silent(const char* name, char** dst) {
   *dst = gpr_getenv(name);
   return NULL;
 }
 
-char *gpr_getenv(const char *name) {
-  char *result = getenv(name);
+char* gpr_getenv(const char* name) {
+  char* result = getenv(name);
   return result == NULL ? result : gpr_strdup(result);
 }
 
-void gpr_setenv(const char *name, const char *value) {
+void gpr_setenv(const char* name, const char* value) {
   int res = setenv(name, value, 1);
   GPR_ASSERT(res == 0);
 }

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

@@ -30,13 +30,13 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-const char *gpr_getenv_silent(const char *name, char **dst) {
+const char* gpr_getenv_silent(const char* name, char** dst) {
   *dst = gpr_getenv(name);
   return NULL;
 }
 
-char *gpr_getenv(const char *name) {
-  char *result = NULL;
+char* gpr_getenv(const char* name) {
+  char* result = NULL;
   DWORD size;
   LPTSTR tresult = NULL;
   LPTSTR tname = gpr_char_to_tchar(name);
@@ -48,7 +48,7 @@ char *gpr_getenv(const char *name) {
     return NULL;
   }
   size = ret * (DWORD)sizeof(TCHAR);
-  tresult = gpr_malloc(size);
+  tresult = (LPTSTR)gpr_malloc(size);
   ret = GetEnvironmentVariable(tname, tresult, size);
   gpr_free(tname);
   if (ret == 0) {
@@ -60,7 +60,7 @@ char *gpr_getenv(const char *name) {
   return result;
 }
 
-void gpr_setenv(const char *name, const char *value) {
+void gpr_setenv(const char* name, const char* value) {
   LPTSTR tname = gpr_char_to_tchar(name);
   LPTSTR tvalue = gpr_char_to_tchar(value);
   BOOL res = SetEnvironmentVariable(tname, tvalue);

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

@@ -38,9 +38,9 @@ void grpc_fork_support_init() {
   fork_support_enabled = 1;
 #else
   fork_support_enabled = 0;
-  char *env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
+  char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
   if (env != NULL) {
-    static const char *truthy[] = {"yes",  "Yes",  "YES", "true",
+    static const char* truthy[] = {"yes",  "Yes",  "YES", "true",
                                    "True", "TRUE", "1"};
     for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
       if (0 == strcmp(env, truthy[i])) {

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

@@ -51,29 +51,29 @@ struct gpr_histogram {
   /* number of buckets */
   size_t num_buckets;
   /* the buckets themselves */
-  uint32_t *buckets;
+  uint32_t* buckets;
 };
 
 /* determine a bucket index given a value - does no bounds checking */
-static size_t bucket_for_unchecked(gpr_histogram *h, double x) {
+static size_t bucket_for_unchecked(gpr_histogram* h, double x) {
   return (size_t)(log(x) * h->one_on_log_multiplier);
 }
 
 /* bounds checked version of the above */
-static size_t bucket_for(gpr_histogram *h, double x) {
+static size_t bucket_for(gpr_histogram* h, double x) {
   size_t bucket = bucket_for_unchecked(h, GPR_CLAMP(x, 1.0, h->max_possible));
   GPR_ASSERT(bucket < h->num_buckets);
   return bucket;
 }
 
 /* at what value does a bucket start? */
-static double bucket_start(gpr_histogram *h, double x) {
+static double bucket_start(gpr_histogram* h, double x) {
   return pow(h->multiplier, x);
 }
 
-gpr_histogram *gpr_histogram_create(double resolution,
+gpr_histogram* gpr_histogram_create(double resolution,
                                     double max_bucket_start) {
-  gpr_histogram *h = (gpr_histogram *)gpr_malloc(sizeof(gpr_histogram));
+  gpr_histogram* h = (gpr_histogram*)gpr_malloc(sizeof(gpr_histogram));
   GPR_ASSERT(resolution > 0.0);
   GPR_ASSERT(max_bucket_start > resolution);
   h->sum = 0.0;
@@ -87,16 +87,16 @@ gpr_histogram *gpr_histogram_create(double resolution,
   h->num_buckets = bucket_for_unchecked(h, max_bucket_start) + 1;
   GPR_ASSERT(h->num_buckets > 1);
   GPR_ASSERT(h->num_buckets < 100000000);
-  h->buckets = (uint32_t *)gpr_zalloc(sizeof(uint32_t) * h->num_buckets);
+  h->buckets = (uint32_t*)gpr_zalloc(sizeof(uint32_t) * h->num_buckets);
   return h;
 }
 
-void gpr_histogram_destroy(gpr_histogram *h) {
+void gpr_histogram_destroy(gpr_histogram* h) {
   gpr_free(h->buckets);
   gpr_free(h);
 }
 
-void gpr_histogram_add(gpr_histogram *h, double x) {
+void gpr_histogram_add(gpr_histogram* h, double x) {
   h->sum += x;
   h->sum_of_squares += x * x;
   h->count++;
@@ -109,7 +109,7 @@ void gpr_histogram_add(gpr_histogram *h, double x) {
   h->buckets[bucket_for(h, x)]++;
 }
 
-int gpr_histogram_merge(gpr_histogram *dst, const gpr_histogram *src) {
+int gpr_histogram_merge(gpr_histogram* dst, const gpr_histogram* src) {
   if ((dst->num_buckets != src->num_buckets) ||
       (dst->multiplier != src->multiplier)) {
     /* Fail because these histograms don't match */
@@ -121,7 +121,7 @@ int gpr_histogram_merge(gpr_histogram *dst, const gpr_histogram *src) {
   return 1;
 }
 
-void gpr_histogram_merge_contents(gpr_histogram *dst, const uint32_t *data,
+void gpr_histogram_merge_contents(gpr_histogram* dst, const uint32_t* data,
                                   size_t data_count, double min_seen,
                                   double max_seen, double sum,
                                   double sum_of_squares, double count) {
@@ -141,7 +141,7 @@ void gpr_histogram_merge_contents(gpr_histogram *dst, const uint32_t *data,
   }
 }
 
-static double threshold_for_count_below(gpr_histogram *h, double count_below) {
+static double threshold_for_count_below(gpr_histogram* h, double count_below) {
   double count_so_far;
   double lower_bound;
   double upper_bound;
@@ -183,46 +183,45 @@ static double threshold_for_count_below(gpr_histogram *h, double count_below) {
        should lie */
     lower_bound = bucket_start(h, (double)lower_idx);
     upper_bound = bucket_start(h, (double)(lower_idx + 1));
-    return GPR_CLAMP(upper_bound -
-                         (upper_bound - lower_bound) *
-                             (count_so_far - count_below) /
-                             h->buckets[lower_idx],
+    return GPR_CLAMP(upper_bound - (upper_bound - lower_bound) *
+                                       (count_so_far - count_below) /
+                                       h->buckets[lower_idx],
                      h->min_seen, h->max_seen);
   }
 }
 
-double gpr_histogram_percentile(gpr_histogram *h, double percentile) {
+double gpr_histogram_percentile(gpr_histogram* h, double percentile) {
   return threshold_for_count_below(h, h->count * percentile / 100.0);
 }
 
-double gpr_histogram_mean(gpr_histogram *h) {
+double gpr_histogram_mean(gpr_histogram* h) {
   GPR_ASSERT(h->count != 0);
   return h->sum / h->count;
 }
 
-double gpr_histogram_stddev(gpr_histogram *h) {
+double gpr_histogram_stddev(gpr_histogram* h) {
   return sqrt(gpr_histogram_variance(h));
 }
 
-double gpr_histogram_variance(gpr_histogram *h) {
+double gpr_histogram_variance(gpr_histogram* h) {
   if (h->count == 0) return 0.0;
   return (h->sum_of_squares * h->count - h->sum * h->sum) /
          (h->count * h->count);
 }
 
-double gpr_histogram_maximum(gpr_histogram *h) { return h->max_seen; }
+double gpr_histogram_maximum(gpr_histogram* h) { return h->max_seen; }
 
-double gpr_histogram_minimum(gpr_histogram *h) { return h->min_seen; }
+double gpr_histogram_minimum(gpr_histogram* h) { return h->min_seen; }
 
-double gpr_histogram_count(gpr_histogram *h) { return h->count; }
+double gpr_histogram_count(gpr_histogram* h) { return h->count; }
 
-double gpr_histogram_sum(gpr_histogram *h) { return h->sum; }
+double gpr_histogram_sum(gpr_histogram* h) { return h->sum; }
 
-double gpr_histogram_sum_of_squares(gpr_histogram *h) {
+double gpr_histogram_sum_of_squares(gpr_histogram* h) {
   return h->sum_of_squares;
 }
 
-const uint32_t *gpr_histogram_get_contents(gpr_histogram *h, size_t *size) {
+const uint32_t* gpr_histogram_get_contents(gpr_histogram* h, size_t* size) {
   *size = h->num_buckets;
   return h->buckets;
 }

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

@@ -25,8 +25,8 @@
 #include <grpc/support/string_util.h>
 #include "src/core/lib/support/string.h"
 
-int gpr_join_host_port(char **out, const char *host, int port) {
-  if (host[0] != '[' && strchr(host, ':') != NULL) {
+int gpr_join_host_port(char** out, const char* host, int port) {
+  if (host[0] != '[' && strchr(host, ':') != nullptr) {
     /* IPv6 literals must be enclosed in brackets. */
     return gpr_asprintf(out, "[%s]:%d", host, port);
   } else {
@@ -35,24 +35,24 @@ int gpr_join_host_port(char **out, const char *host, int port) {
   }
 }
 
-int gpr_split_host_port(const char *name, char **host, char **port) {
-  const char *host_start;
+int gpr_split_host_port(const char* name, char** host, char** port) {
+  const char* host_start;
   size_t host_len;
-  const char *port_start;
+  const char* port_start;
 
-  *host = NULL;
-  *port = NULL;
+  *host = nullptr;
+  *port = nullptr;
 
   if (name[0] == '[') {
     /* Parse a bracketed host, typically an IPv6 literal. */
-    const char *rbracket = strchr(name, ']');
-    if (rbracket == NULL) {
+    const char* rbracket = strchr(name, ']');
+    if (rbracket == nullptr) {
       /* Unmatched [ */
       return 0;
     }
     if (rbracket[1] == '\0') {
       /* ]<end> */
-      port_start = NULL;
+      port_start = nullptr;
     } else if (rbracket[1] == ':') {
       /* ]:<port?> */
       port_start = rbracket + 2;
@@ -62,14 +62,14 @@ int gpr_split_host_port(const char *name, char **host, char **port) {
     }
     host_start = name + 1;
     host_len = (size_t)(rbracket - host_start);
-    if (memchr(host_start, ':', host_len) == NULL) {
+    if (memchr(host_start, ':', host_len) == nullptr) {
       /* Require all bracketed hosts to contain a colon, because a hostname or
          IPv4 address should never use brackets. */
       return 0;
     }
   } else {
-    const char *colon = strchr(name, ':');
-    if (colon != NULL && strchr(colon + 1, ':') == NULL) {
+    const char* colon = strchr(name, ':');
+    if (colon != nullptr && strchr(colon + 1, ':') == nullptr) {
       /* Exactly 1 colon.  Split into host:port. */
       host_start = name;
       host_len = (size_t)(colon - name);
@@ -78,16 +78,16 @@ int gpr_split_host_port(const char *name, char **host, char **port) {
       /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
       host_start = name;
       host_len = strlen(name);
-      port_start = NULL;
+      port_start = nullptr;
     }
   }
 
   /* Allocate return values. */
-  *host = (char *)gpr_malloc(host_len + 1);
+  *host = (char*)gpr_malloc(host_len + 1);
   memcpy(*host, host_start, host_len);
   (*host)[host_len] = '\0';
 
-  if (port_start != NULL) {
+  if (port_start != nullptr) {
     *port = gpr_strdup(port_start);
   }
 

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

@@ -27,11 +27,11 @@
 #include <stdio.h>
 #include <string.h>
 
-extern void gpr_default_log(gpr_log_func_args *args);
+extern "C" void gpr_default_log(gpr_log_func_args* args);
 static gpr_atm g_log_func = (gpr_atm)gpr_default_log;
 static gpr_atm g_min_severity_to_print = GPR_LOG_VERBOSITY_UNSET;
 
-const char *gpr_log_severity_string(gpr_log_severity severity) {
+const char* gpr_log_severity_string(gpr_log_severity severity) {
   switch (severity) {
     case GPR_LOG_SEVERITY_DEBUG:
       return "D";
@@ -43,8 +43,8 @@ const char *gpr_log_severity_string(gpr_log_severity severity) {
   GPR_UNREACHABLE_CODE(return "UNKNOWN");
 }
 
-void gpr_log_message(const char *file, int line, gpr_log_severity severity,
-                     const char *message) {
+void gpr_log_message(const char* file, int line, gpr_log_severity severity,
+                     const char* message) {
   if ((gpr_atm)severity < gpr_atm_no_barrier_load(&g_min_severity_to_print)) {
     return;
   }
@@ -64,11 +64,11 @@ void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print) {
 }
 
 void gpr_log_verbosity_init() {
-  char *verbosity = NULL;
-  const char *insecure_getenv = gpr_getenv_silent("GRPC_VERBOSITY", &verbosity);
+  char* verbosity = nullptr;
+  const char* insecure_getenv = gpr_getenv_silent("GRPC_VERBOSITY", &verbosity);
 
   gpr_atm min_severity_to_print = GPR_LOG_SEVERITY_ERROR;
-  if (verbosity != NULL) {
+  if (verbosity != nullptr) {
     if (gpr_stricmp(verbosity, "DEBUG") == 0) {
       min_severity_to_print = (gpr_atm)GPR_LOG_SEVERITY_DEBUG;
     } else if (gpr_stricmp(verbosity, "INFO") == 0) {
@@ -83,7 +83,7 @@ void gpr_log_verbosity_init() {
     gpr_atm_no_barrier_store(&g_min_severity_to_print, min_severity_to_print);
   }
 
-  if (insecure_getenv != NULL) {
+  if (insecure_getenv != nullptr) {
     gpr_log(GPR_DEBUG, "Warning: insecure environment read function '%s' used",
             insecure_getenv);
   }

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

@@ -39,9 +39,9 @@ static android_LogPriority severity_to_log_priority(gpr_log_severity severity) {
   return ANDROID_LOG_DEFAULT;
 }
 
-void gpr_log(const char *file, int line, gpr_log_severity severity,
-             const char *format, ...) {
-  char *message = NULL;
+extern "C" void gpr_log(const char* file, int line, gpr_log_severity severity,
+                        const char* format, ...) {
+  char* message = NULL;
   va_list args;
   va_start(args, format);
   vasprintf(&message, format, args);
@@ -50,10 +50,10 @@ void gpr_log(const char *file, int line, gpr_log_severity severity,
   free(message);
 }
 
-void gpr_default_log(gpr_log_func_args *args) {
-  char *final_slash;
-  const char *display_file;
-  char *output = NULL;
+extern "C" void gpr_default_log(gpr_log_func_args* args) {
+  const char* final_slash;
+  const char* display_file;
+  char* output = NULL;
 
   final_slash = strrchr(args->file, '/');
   if (final_slash == NULL)

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

@@ -41,9 +41,9 @@
 
 static long gettid(void) { return syscall(__NR_gettid); }
 
-void gpr_log(const char *file, int line, gpr_log_severity severity,
-             const char *format, ...) {
-  char *message = NULL;
+void gpr_log(const char* file, int line, gpr_log_severity severity,
+             const char* format, ...) {
+  char* message = nullptr;
   va_list args;
   va_start(args, format);
   if (vasprintf(&message, format, args) == -1) {
@@ -56,10 +56,10 @@ void gpr_log(const char *file, int line, gpr_log_severity severity,
   free(message);
 }
 
-void gpr_default_log(gpr_log_func_args *args) {
-  const char *final_slash;
-  char *prefix;
-  const char *display_file;
+extern "C" void gpr_default_log(gpr_log_func_args* args) {
+  const char* final_slash;
+  char* prefix;
+  const char* display_file;
   char time_buffer[64];
   time_t timer;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
@@ -69,7 +69,7 @@ void gpr_default_log(gpr_log_func_args *args) {
 
   timer = (time_t)now.tv_sec;
   final_slash = strrchr(args->file, '/');
-  if (final_slash == NULL)
+  if (final_slash == nullptr)
     display_file = args->file;
   else
     display_file = final_slash + 1;

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

@@ -27,17 +27,16 @@
 #include <pthread.h>
 #include <stdarg.h>
 #include <stdio.h>
-#include <stdio.h>
 #include <string.h>
 #include <time.h>
 
 static intptr_t gettid(void) { return (intptr_t)pthread_self(); }
 
-void gpr_log(const char *file, int line, gpr_log_severity severity,
-             const char *format, ...) {
+void gpr_log(const char* file, int line, gpr_log_severity severity,
+             const char* format, ...) {
   char buf[64];
-  char *allocated = NULL;
-  char *message = NULL;
+  char* allocated = NULL;
+  char* message = NULL;
   int ret;
   va_list args;
   va_start(args, format);
@@ -48,7 +47,7 @@ void gpr_log(const char *file, int line, gpr_log_severity severity,
   } else if ((size_t)ret <= sizeof(buf) - 1) {
     message = buf;
   } else {
-    message = allocated = gpr_malloc((size_t)ret + 1);
+    message = allocated = (char*)gpr_malloc((size_t)ret + 1);
     va_start(args, format);
     vsnprintf(message, (size_t)(ret + 1), format, args);
     va_end(args);
@@ -57,9 +56,9 @@ void gpr_log(const char *file, int line, gpr_log_severity severity,
   gpr_free(allocated);
 }
 
-void gpr_default_log(gpr_log_func_args *args) {
-  char *final_slash;
-  const char *display_file;
+extern "C" void gpr_default_log(gpr_log_func_args* args) {
+  const char* final_slash;
+  const char* display_file;
   char time_buffer[64];
   time_t timer;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
@@ -79,7 +78,7 @@ void gpr_default_log(gpr_log_func_args *args) {
     strcpy(time_buffer, "error:strftime");
   }
 
-  char *prefix;
+  char* prefix;
   gpr_asprintf(&prefix, "%s%s.%09d %7tu %s:%d]",
                gpr_log_severity_string(args->severity), time_buffer,
                (int)(now.tv_nsec), gettid(), display_file, args->line);