grpc 1.45.0 → 1.53.0

data/src/core/lib/gpr/string.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -35,6 +35,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 
 char* gpr_strdup(const char* src) {
   char* dst;
@@ -89,7 +90,7 @@ static dump_out dump_out_create(void) {
 
 static void dump_out_append(dump_out* out, char c) {
   if (out->length == out->capacity) {
-    out->capacity = std::max(size_t(8), 2 * out->capacity);
+    out->capacity = std::max(size_t{8}, 2 * out->capacity);
     out->data = static_cast<char*>(gpr_realloc(out->data, out->capacity));
   }
   out->data[out->length++] = c;
@@ -151,12 +152,12 @@ int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) {
   uint32_t new_val;
   size_t i;
 
-  if (len == 0) return 0; /* must have some bytes */
+  if (len == 0) return 0;  // must have some bytes
 
   for (i = 0; i < len; i++) {
-    if (buf[i] < '0' || buf[i] > '9') return 0; /* bad char */
+    if (buf[i] < '0' || buf[i] > '9') return 0;  // bad char
     new_val = 10 * out + static_cast<uint32_t>(buf[i] - '0');
-    if (new_val < out) return 0; /* overflow */
+    if (new_val < out) return 0;  // overflow
     out = new_val;
   }
 
@@ -245,9 +246,9 @@ char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
   for (i = 0; i < nstrs; i++) {
     out_length += strlen(strs[i]);
   }
-  out_length += 1; /* null terminator */
+  out_length += 1;  // null terminator
   if (nstrs > 0) {
-    out_length += sep_len * (nstrs - 1); /* separators */
+    out_length += sep_len * (nstrs - 1);  // separators
   }
   out = static_cast<char*>(gpr_malloc(out_length));
   out_length = 0;
@@ -290,7 +291,7 @@ static void add_string_to_split(const char* beg, const char* end, char*** strs,
   memcpy(out, beg, static_cast<size_t>(end - beg));
   out[end - beg] = 0;
   if (*nstrs == *capstrs) {
-    *capstrs = std::max(size_t(8), 2 * *capstrs);
+    *capstrs = std::max(size_t{8}, 2 * *capstrs);
     *strs = static_cast<char**>(gpr_realloc(*strs, sizeof(*strs) * *capstrs));
   }
   (*strs)[*nstrs] = out;

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

@@ -1,112 +1,112 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_GPR_STRING_H
-#define GRPC_CORE_LIB_GPR_STRING_H
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_GPR_STRING_H
+#define GRPC_SRC_CORE_LIB_GPR_STRING_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #include <string>
 
-#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/time.h>
 
-/* String utility functions */
+// String utility functions
 
-/* Flags for gpr_dump function. */
+// Flags for gpr_dump function.
 #define GPR_DUMP_HEX 0x00000001
 #define GPR_DUMP_ASCII 0x00000002
 
-/* Converts array buf, of length len, into a C string according to the flags.
-   Result should be freed with gpr_free() */
+// 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);
-/* Converts array buf, of length len, into a C string according to the flags.
-   The length of the returned buffer is stored in out_len.
-   Result should be freed with gpr_free() */
+// Converts array buf, of length len, into a C string according to the flags.
+// The length of the returned buffer is stored in out_len.
+// Result should be freed with gpr_free()
 char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
                           size_t* out_len);
 
-/* Parses an array of bytes into an integer (base 10). Returns 1 on success,
-   0 on failure. */
+// 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* buf, size_t len, uint32_t* result);
 
-/* Minimum buffer size for calling ltoa */
+// Minimum buffer size for calling ltoa
 #define GPR_LTOA_MIN_BUFSIZE (3 * sizeof(long))
 
-/* 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. */
+// 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);
 
-/* Minimum buffer size for calling int64toa */
+// Minimum buffer size for calling int64toa
 #define GPR_INT64TOA_MIN_BUFSIZE (3 * sizeof(int64_t))
 
-/* Convert an int64 to a string in base 10; returns the length of the
-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.*/
+// Convert an int64 to a string in base 10; returns the length of the
+// 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);
 
 // Parses a non-negative number from a value string.  Returns -1 on error.
 int gpr_parse_nonnegative_int(const char* value);
 
-/* Reverse a run of bytes */
+// Reverse a run of bytes
 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. */
+// 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);
 
-/* Join a set of strings, returning the resulting string.
-   Total combined length (excluding null terminator) is returned in final_length
-   if it is non-null. */
+// Join a set of strings, returning the resulting string.
+// Total combined length (excluding null terminator) is returned in final_length
+// if it is non-null.
 char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length);
 
-/* Join a set of strings using a separator, returning the resulting string.
-   Total combined length (excluding null terminator) is returned in final_length
-   if it is non-null. */
+// Join a set of strings using a separator, returning the resulting string.
+// Total combined length (excluding null terminator) is returned in final_length
+// if it is non-null.
 char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
                       size_t* final_length);
 
 void gpr_string_split(const char* input, const char* sep, char*** strs,
                       size_t* nstrs);
 
-/* Returns a string that represents tm according to RFC-3339, and,
-   more specifically, follows:
-   https://developers.google.com/protocol-buffers/docs/proto3#json
+// Returns a string that represents tm according to RFC-3339, and,
+// more specifically, follows:
+// https://developers.google.com/protocol-buffers/docs/proto3#json
 
-   Uses RFC 3339, where generated output will always be Z-normalized and uses
-   0, 3, 6 or 9 fractional digits. */
+// Uses RFC 3339, where generated output will always be Z-normalized and uses
+// 0, 3, 6 or 9 fractional digits.
 std::string gpr_format_timespec(gpr_timespec);
 
-/** Case insensitive string comparison... return <0 if lower(a)<lower(b), ==0 if
-    lower(a)==lower(b), >0 if lower(a)>lower(b) */
+/// 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_strincmp(const char* a, const char* b, size_t n);
 
 void* gpr_memrchr(const void* s, int c, size_t n);
 
-/* Try to parse given string into a boolean value.
-   When parsed successfully, dst will have the value and returns true.
-   Otherwise, it returns false. */
+// Try to parse given string into a boolean value.
+// When parsed successfully, dst will have the value and returns true.
+// Otherwise, it returns false.
 bool gpr_parse_bool_value(const char* value, bool* dst);
 
-#endif /* GRPC_CORE_LIB_GPR_STRING_H */
+#endif  // GRPC_SRC_CORE_LIB_GPR_STRING_H

data/src/core/lib/gpr/string_posix.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -33,7 +33,7 @@ int gpr_asprintf(char** strp, const char* format, ...) {
   char buf[64];
   size_t strp_buflen;
 
-  /* Use a constant-sized buffer to determine the length. */
+  // Use a constant-sized buffer to determine the length.
   va_start(args, format);
   ret = vsnprintf(buf, sizeof(buf), format, args);
   va_end(args);
@@ -42,20 +42,20 @@ int gpr_asprintf(char** strp, const char* format, ...) {
     return -1;
   }
 
-  /* Allocate a new buffer, with space for the NUL terminator. */
+  // Allocate a new buffer, with space for the NUL terminator.
   strp_buflen = static_cast<size_t>(ret) + 1;
   if ((*strp = static_cast<char*>(gpr_malloc(strp_buflen))) == nullptr) {
-    /* This shouldn't happen, because gpr_malloc() calls abort(). */
+    // This shouldn't happen, because gpr_malloc() calls abort().
     return -1;
   }
 
-  /* Return early if we have all the bytes. */
+  // Return early if we have all the bytes.
   if (strp_buflen <= sizeof(buf)) {
     memcpy(*strp, buf, strp_buflen);
     return ret;
   }
 
-  /* Try again using the larger buffer. */
+  // Try again using the larger buffer.
   va_start(args, format);
   ret = vsnprintf(*strp, strp_buflen, format, args);
   va_end(args);
@@ -63,10 +63,10 @@ int gpr_asprintf(char** strp, const char* format, ...) {
     return ret;
   }
 
-  /* This should never happen. */
+  // This should never happen.
   gpr_free(*strp);
   *strp = nullptr;
   return -1;
 }
 
-#endif /* GPR_POSIX_STRING */
+#endif  // GPR_POSIX_STRING

data/src/core/lib/gpr/string_util_windows.cc

@@ -1,29 +1,29 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/* Posix code for gpr snprintf support. */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+// Posix code for gpr snprintf support.
 
 #include <grpc/support/port_platform.h>
 
 #ifdef GPR_WINDOWS
 
-/* Some platforms (namely msys) need wchar to be included BEFORE
-   anything else, especially strsafe.h. */
+// Some platforms (namely msys) need wchar to be included BEFORE
+// anything else, especially strsafe.h.
 #include <wchar.h>
 
 #include <inttypes.h>
@@ -37,46 +37,19 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/string_windows.h"
-
-#if defined UNICODE || defined _UNICODE
-LPTSTR
-gpr_char_to_tchar(LPCSTR input) {
-  LPTSTR ret;
-  int needed = MultiByteToWideChar(CP_UTF8, 0, input, -1, NULL, 0);
-  if (needed <= 0) return NULL;
-  ret = (LPTSTR)gpr_malloc((unsigned)needed * sizeof(TCHAR));
-  MultiByteToWideChar(CP_UTF8, 0, input, -1, ret, needed);
-  return ret;
-}
-
-LPSTR
-gpr_tchar_to_char(LPCTSTR input) {
-  LPSTR ret;
-  int needed = WideCharToMultiByte(CP_UTF8, 0, input, -1, NULL, 0, NULL, NULL);
-  if (needed <= 0) return NULL;
-  ret = (LPSTR)gpr_malloc((unsigned)needed);
-  WideCharToMultiByte(CP_UTF8, 0, input, -1, ret, needed, NULL, NULL);
-  return ret;
-}
-#else
-LPSTR gpr_tchar_to_char(LPCTSTR input) { return (LPSTR)gpr_strdup(input); }
-
-LPTSTR gpr_char_to_tchar(LPCTSTR input) { return (LPTSTR)gpr_strdup(input); }
-#endif
+#include "src/core/lib/gprpp/tchar.h"
 
 char* gpr_format_message(int messageid) {
   LPTSTR tmessage;
-  char* message;
   DWORD status = FormatMessage(
       FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
           FORMAT_MESSAGE_IGNORE_INSERTS,
       NULL, (DWORD)messageid, MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
       (LPTSTR)(&tmessage), 0, NULL);
   if (status == 0) return gpr_strdup("Unable to retrieve error string");
-  message = gpr_tchar_to_char(tmessage);
+  auto message = grpc_core::TcharToChar(tmessage);
   LocalFree(tmessage);
-  return message;
+  return gpr_strdup(message.c_str());
 }
 
-#endif /* GPR_WINDOWS */
+#endif  // GPR_WINDOWS

data/src/core/lib/gpr/string_windows.cc

@@ -1,22 +1,22 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
-/* Windows code for gpr snprintf support. */
+// Windows code for gpr snprintf support.
 
 #include <grpc/support/port_platform.h>
 
@@ -36,7 +36,7 @@ int gpr_asprintf(char** strp, const char* format, ...) {
   int ret;
   size_t strp_buflen;
 
-  /* Determine the length. */
+  // Determine the length.
   va_start(args, format);
   ret = _vscprintf(format, args);
   va_end(args);
@@ -45,14 +45,14 @@ int gpr_asprintf(char** strp, const char* format, ...) {
     return -1;
   }
 
-  /* Allocate a new buffer, with space for the NUL terminator. */
+  // Allocate a new buffer, with space for the NUL terminator.
   strp_buflen = (size_t)ret + 1;
   if ((*strp = (char*)gpr_malloc(strp_buflen)) == NULL) {
-    /* This shouldn't happen, because gpr_malloc() calls abort(). */
+    // This shouldn't happen, because gpr_malloc() calls abort().
     return -1;
   }
 
-  /* Print to the buffer. */
+  // Print to the buffer.
   va_start(args, format);
   ret = vsnprintf_s(*strp, strp_buflen, _TRUNCATE, format, args);
   va_end(args);
@@ -60,10 +60,10 @@ int gpr_asprintf(char** strp, const char* format, ...) {
     return ret;
   }
 
-  /* This should never happen. */
+  // This should never happen.
   gpr_free(*strp);
   *strp = NULL;
   return -1;
 }
 
-#endif /* GPR_WINDOWS_STRING */
+#endif  // GPR_WINDOWS_STRING

data/src/core/lib/gpr/sync.cc

@@ -1,22 +1,22 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/* Generic implementation of synchronization primitives. */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+// Generic implementation of synchronization primitives.
 
 #include <grpc/support/port_platform.h>
 
@@ -26,17 +26,17 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-/* Number of mutexes to allocate for events, to avoid lock contention.
-   Should be a prime. */
+// Number of mutexes to allocate for events, to avoid lock contention.
+// Should be a prime.
 enum { event_sync_partitions = 31 };
 
-/* Events are partitioned by address to avoid lock contention. */
+// Events are partitioned by address to avoid lock contention.
 static struct sync_array_s {
   gpr_mu mu;
   gpr_cv cv;
 } sync_array[event_sync_partitions];
 
-/* This routine is executed once on first use, via event_once */
+// This routine is executed once on first use, via event_once
 static gpr_once event_once = GPR_ONCE_INIT;
 static void event_initialize(void) {
   int i;
@@ -46,7 +46,7 @@ static void event_initialize(void) {
   }
 }
 
-/* Hash ev into an element of sync_array[]. */
+// Hash ev into an element of sync_array[].
 static struct sync_array_s* hash(gpr_event* ev) {
   return &sync_array[reinterpret_cast<uintptr_t>(ev) % event_sync_partitions];
 }
@@ -119,6 +119,6 @@ void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc) {
 }
 
 intptr_t gpr_stats_read(const gpr_stats_counter* c) {
-  /* don't need acquire-load, but we have no no-barrier load yet */
+  // don't need acquire-load, but we have no no-barrier load yet
   return gpr_atm_acq_load(&c->value);
 }