grpc 1.47.0 → 1.53.0

data/third_party/abseil-cpp/absl/strings/internal/str_format/output.h

@@ -22,6 +22,7 @@
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
 
 #include <cstdio>
+#include <ios>
 #include <ostream>
 #include <string>
 
@@ -71,7 +72,7 @@ inline void AbslFormatFlush(std::string* out, string_view s) {
   out->append(s.data(), s.size());
 }
 inline void AbslFormatFlush(std::ostream* out, string_view s) {
-  out->write(s.data(), s.size());
+  out->write(s.data(), static_cast<std::streamsize>(s.size()));
 }
 
 inline void AbslFormatFlush(FILERawSink* sink, string_view v) {

data/third_party/abseil-cpp/absl/strings/internal/str_format/parser.cc

@@ -31,207 +31,14 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
-using CC = FormatConversionCharInternal;
-using LM = LengthMod;
+// Define the array for non-constexpr uses.
+constexpr ConvTag ConvTagHolder::value[256];
 
-// Abbreviations to fit in the table below.
-constexpr auto f_sign = Flags::kSignCol;
-constexpr auto f_alt = Flags::kAlt;
-constexpr auto f_pos = Flags::kShowPos;
-constexpr auto f_left = Flags::kLeft;
-constexpr auto f_zero = Flags::kZero;
-
-ABSL_CONST_INIT const ConvTag kTags[256] = {
-    {},     {},    {},    {},    {},    {},     {},    {},     // 00-07
-    {},     {},    {},    {},    {},    {},     {},    {},     // 08-0f
-    {},     {},    {},    {},    {},    {},     {},    {},     // 10-17
-    {},     {},    {},    {},    {},    {},     {},    {},     // 18-1f
-    f_sign, {},    {},    f_alt, {},    {},     {},    {},     //  !"#$%&'
-    {},     {},    {},    f_pos, {},    f_left, {},    {},     // ()*+,-./
-    f_zero, {},    {},    {},    {},    {},     {},    {},     // 01234567
-    {},     {},    {},    {},    {},    {},     {},    {},     // 89:;<=>?
-    {},     CC::A, {},    {},    {},    CC::E,  CC::F, CC::G,  // @ABCDEFG
-    {},     {},    {},    {},    LM::L, {},     {},    {},     // HIJKLMNO
-    {},     {},    {},    {},    {},    {},     {},    {},     // PQRSTUVW
-    CC::X,  {},    {},    {},    {},    {},     {},    {},     // XYZ[\]^_
-    {},     CC::a, {},    CC::c, CC::d, CC::e,  CC::f, CC::g,  // `abcdefg
-    LM::h,  CC::i, LM::j, {},    LM::l, {},     CC::n, CC::o,  // hijklmno
-    CC::p,  LM::q, {},    CC::s, LM::t, CC::u,  {},    {},     // pqrstuvw
-    CC::x,  {},    LM::z, {},    {},    {},     {},    {},     // xyz{|}!
-    {},     {},    {},    {},    {},    {},     {},    {},     // 80-87
-    {},     {},    {},    {},    {},    {},     {},    {},     // 88-8f
-    {},     {},    {},    {},    {},    {},     {},    {},     // 90-97
-    {},     {},    {},    {},    {},    {},     {},    {},     // 98-9f
-    {},     {},    {},    {},    {},    {},     {},    {},     // a0-a7
-    {},     {},    {},    {},    {},    {},     {},    {},     // a8-af
-    {},     {},    {},    {},    {},    {},     {},    {},     // b0-b7
-    {},     {},    {},    {},    {},    {},     {},    {},     // b8-bf
-    {},     {},    {},    {},    {},    {},     {},    {},     // c0-c7
-    {},     {},    {},    {},    {},    {},     {},    {},     // c8-cf
-    {},     {},    {},    {},    {},    {},     {},    {},     // d0-d7
-    {},     {},    {},    {},    {},    {},     {},    {},     // d8-df
-    {},     {},    {},    {},    {},    {},     {},    {},     // e0-e7
-    {},     {},    {},    {},    {},    {},     {},    {},     // e8-ef
-    {},     {},    {},    {},    {},    {},     {},    {},     // f0-f7
-    {},     {},    {},    {},    {},    {},     {},    {},     // f8-ff
-};
-
-namespace {
-
-bool CheckFastPathSetting(const UnboundConversion& conv) {
-  bool width_precision_needed =
-      conv.width.value() >= 0 || conv.precision.value() >= 0;
-  if (width_precision_needed && conv.flags == Flags::kBasic) {
-    fprintf(stderr,
-            "basic=%d left=%d show_pos=%d sign_col=%d alt=%d zero=%d "
-            "width=%d precision=%d\n",
-            conv.flags == Flags::kBasic ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kLeft) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kShowPos) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kSignCol) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kAlt) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kZero) ? 1 : 0, conv.width.value(),
-            conv.precision.value());
-    return false;
-  }
-  return true;
-}
-
-template <bool is_positional>
-const char *ConsumeConversion(const char *pos, const char *const end,
-                              UnboundConversion *conv, int *next_arg) {
-  const char* const original_pos = pos;
-  char c;
-  // Read the next char into `c` and update `pos`. Returns false if there are
-  // no more chars to read.
-#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
-  do {                                                  \
-    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
-    c = *pos++;                                         \
-  } while (0)
-
-  const auto parse_digits = [&] {
-    int digits = c - '0';
-    // We do not want to overflow `digits` so we consume at most digits10
-    // digits. If there are more digits the parsing will fail later on when the
-    // digit doesn't match the expected characters.
-    int num_digits = std::numeric_limits<int>::digits10;
-    for (;;) {
-      if (ABSL_PREDICT_FALSE(pos == end)) break;
-      c = *pos++;
-      if (!std::isdigit(c)) break;
-      --num_digits;
-      if (ABSL_PREDICT_FALSE(!num_digits)) break;
-      digits = 10 * digits + c - '0';
-    }
-    return digits;
-  };
-
-  if (is_positional) {
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
-    conv->arg_position = parse_digits();
-    assert(conv->arg_position > 0);
-    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
-  }
-
-  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-
-  // We should start with the basic flag on.
-  assert(conv->flags == Flags::kBasic);
-
-  // Any non alpha character makes this conversion not basic.
-  // This includes flags (-+ #0), width (1-9, *) or precision (.).
-  // All conversion characters and length modifiers are alpha characters.
-  if (c < 'A') {
-    while (c <= '0') {
-      auto tag = GetTagForChar(c);
-      if (tag.is_flags()) {
-        conv->flags = conv->flags | tag.as_flags();
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-      } else {
-        break;
-      }
-    }
-
-    if (c <= '9') {
-      if (c >= '0') {
-        int maybe_width = parse_digits();
-        if (!is_positional && c == '$') {
-          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
-          // Positional conversion.
-          *next_arg = -1;
-          return ConsumeConversion<true>(original_pos, end, conv, next_arg);
-        }
-        conv->flags = conv->flags | Flags::kNonBasic;
-        conv->width.set_value(maybe_width);
-      } else if (c == '*') {
-        conv->flags = conv->flags | Flags::kNonBasic;
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
-          conv->width.set_from_arg(parse_digits());
-          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        } else {
-          conv->width.set_from_arg(++*next_arg);
-        }
-      }
-    }
-
-    if (c == '.') {
-      conv->flags = conv->flags | Flags::kNonBasic;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-      if (std::isdigit(c)) {
-        conv->precision.set_value(parse_digits());
-      } else if (c == '*') {
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
-          conv->precision.set_from_arg(parse_digits());
-          if (c != '$') return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        } else {
-          conv->precision.set_from_arg(++*next_arg);
-        }
-      } else {
-        conv->precision.set_value(0);
-      }
-    }
-  }
-
-  auto tag = GetTagForChar(c);
-
-  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
-    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
-
-    // It is a length modifier.
-    using str_format_internal::LengthMod;
-    LengthMod length_mod = tag.as_length();
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (c == 'h' && length_mod == LengthMod::h) {
-      conv->length_mod = LengthMod::hh;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    } else if (c == 'l' && length_mod == LengthMod::l) {
-      conv->length_mod = LengthMod::ll;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    } else {
-      conv->length_mod = length_mod;
-    }
-    tag = GetTagForChar(c);
-    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
-  }
-
-  assert(CheckFastPathSetting(*conv));
-  (void)(&CheckFastPathSetting);
-
-  conv->conv = tag.as_conv();
-  if (!is_positional) conv->arg_position = ++*next_arg;
-  return pos;
+ABSL_ATTRIBUTE_NOINLINE const char* ConsumeUnboundConversionNoInline(
+    const char* p, const char* end, UnboundConversion* conv, int* next_arg) {
+  return ConsumeUnboundConversion(p, end, conv, next_arg);
 }
 
-}  // namespace
-
 std::string LengthModToString(LengthMod v) {
   switch (v) {
     case LengthMod::h:
@@ -258,12 +65,6 @@ std::string LengthModToString(LengthMod v) {
   return "";
 }
 
-const char *ConsumeUnboundConversion(const char *p, const char *end,
-                                     UnboundConversion *conv, int *next_arg) {
-  if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
-  return ConsumeConversion<false>(p, end, conv, next_arg);
-}
-
 struct ParsedFormatBase::ParsedFormatConsumer {
   explicit ParsedFormatConsumer(ParsedFormatBase *parsedformat)
       : parsed(parsedformat), data_pos(parsedformat->data_.get()) {}
@@ -312,11 +113,11 @@ bool ParsedFormatBase::MatchesConversions(
     std::initializer_list<FormatConversionCharSet> convs) const {
   std::unordered_set<int> used;
   auto add_if_valid_conv = [&](int pos, char c) {
-      if (static_cast<size_t>(pos) > convs.size() ||
-          !Contains(convs.begin()[pos - 1], c))
-        return false;
-      used.insert(pos);
-      return true;
+    if (static_cast<size_t>(pos) > convs.size() ||
+        !Contains(convs.begin()[pos - 1], c))
+      return false;
+    used.insert(pos);
+    return true;
   };
   for (const ConversionItem &item : items_) {
     if (!item.is_conversion) continue;

data/third_party/abseil-cpp/absl/strings/internal/str_format/parser.h

@@ -29,111 +29,18 @@
 #include <vector>
 
 #include "absl/strings/internal/str_format/checker.h"
+#include "absl/strings/internal/str_format/constexpr_parser.h"
 #include "absl/strings/internal/str_format/extension.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
-enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
-
 std::string LengthModToString(LengthMod v);
 
-// The analyzed properties of a single specified conversion.
-struct UnboundConversion {
-  UnboundConversion() {}
-
-  class InputValue {
-   public:
-    void set_value(int value) {
-      assert(value >= 0);
-      value_ = value;
-    }
-    int value() const { return value_; }
-
-    // Marks the value as "from arg". aka the '*' format.
-    // Requires `value >= 1`.
-    // When set, is_from_arg() return true and get_from_arg() returns the
-    // original value.
-    // `value()`'s return value is unspecfied in this state.
-    void set_from_arg(int value) {
-      assert(value > 0);
-      value_ = -value - 1;
-    }
-    bool is_from_arg() const { return value_ < -1; }
-    int get_from_arg() const {
-      assert(is_from_arg());
-      return -value_ - 1;
-    }
-
-   private:
-    int value_ = -1;
-  };
-
-  // No need to initialize. It will always be set in the parser.
-  int arg_position;
-
-  InputValue width;
-  InputValue precision;
-
-  Flags flags = Flags::kBasic;
-  LengthMod length_mod = LengthMod::none;
-  FormatConversionChar conv = FormatConversionCharInternal::kNone;
-};
-
-// Consume conversion spec prefix (not including '%') of [p, end) if valid.
-// Examples of valid specs would be e.g.: "s", "d", "-12.6f".
-// If valid, it returns the first character following the conversion spec,
-// and the spec part is broken down and returned in 'conv'.
-// If invalid, returns nullptr.
-const char* ConsumeUnboundConversion(const char* p, const char* end,
-                                     UnboundConversion* conv, int* next_arg);
-
-// Helper tag class for the table below.
-// It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
-// conversions.
-class ConvTag {
- public:
-  constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
-      : tag_(static_cast<uint8_t>(conversion_char)) {}
-  constexpr ConvTag(LengthMod length_mod)  // NOLINT
-      : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
-  constexpr ConvTag(Flags flags)  // NOLINT
-      : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
-  constexpr ConvTag() : tag_(0xFF) {}
-
-  bool is_conv() const { return (tag_ & 0x80) == 0; }
-  bool is_length() const { return (tag_ & 0xC0) == 0x80; }
-  bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
-
-  FormatConversionChar as_conv() const {
-    assert(is_conv());
-    assert(!is_length());
-    assert(!is_flags());
-    return static_cast<FormatConversionChar>(tag_);
-  }
-  LengthMod as_length() const {
-    assert(!is_conv());
-    assert(is_length());
-    assert(!is_flags());
-    return static_cast<LengthMod>(tag_ & 0x3F);
-  }
-  Flags as_flags() const {
-    assert(!is_conv());
-    assert(!is_length());
-    assert(is_flags());
-    return static_cast<Flags>(tag_ & 0x1F);
-  }
-
- private:
-  uint8_t tag_;
-};
-
-extern const ConvTag kTags[256];
-// Keep a single table for all the conversion chars and length modifiers.
-inline ConvTag GetTagForChar(char c) {
-  return kTags[static_cast<unsigned char>(c)];
-}
+const char* ConsumeUnboundConversionNoInline(const char* p, const char* end,
+                                             UnboundConversion* conv,
+                                             int* next_arg);
 
 // Parse the format string provided in 'src' and pass the identified items into
 // 'consumer'.
@@ -151,13 +58,15 @@ bool ParseFormatString(string_view src, Consumer consumer) {
   const char* p = src.data();
   const char* const end = p + src.size();
   while (p != end) {
-    const char* percent = static_cast<const char*>(memchr(p, '%', end - p));
+    const char* percent =
+        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
     if (!percent) {
       // We found the last substring.
-      return consumer.Append(string_view(p, end - p));
+      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
     }
     // We found a percent, so push the text run then process the percent.
-    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
+    if (ABSL_PREDICT_FALSE(!consumer.Append(
+            string_view(p, static_cast<size_t>(percent - p))))) {
       return false;
     }
     if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
@@ -185,10 +94,11 @@ bool ParseFormatString(string_view src, Consumer consumer) {
       }
     } else if (percent[1] != '%') {
       UnboundConversion conv;
-      p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
+      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
       if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
       if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
-          conv, string_view(percent + 1, p - (percent + 1))))) {
+              conv, string_view(percent + 1,
+                                static_cast<size_t>(p - (percent + 1)))))) {
         return false;
       }
     } else {
@@ -242,7 +152,8 @@ class ParsedFormatBase {
     string_view text(base, 0);
     for (const auto& item : items_) {
       const char* const end = text.data() + text.size();
-      text = string_view(end, (base + item.text_end) - end);
+      text =
+          string_view(end, static_cast<size_t>((base + item.text_end) - end));
       if (item.is_conversion) {
         if (!consumer.ConvertOne(item.conv, text)) return false;
       } else {

data/third_party/abseil-cpp/absl/strings/internal/str_join_internal.h

@@ -229,10 +229,11 @@ std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
   std::string result;
   if (start != end) {
     // Sums size
-    size_t result_size = start->size();
+    auto&& start_value = *start;
+    size_t result_size = start_value.size();
     for (Iterator it = start; ++it != end;) {
       result_size += s.size();
-      result_size += it->size();
+      result_size += (*it).size();
     }
 
     if (result_size > 0) {
@@ -240,13 +241,15 @@ std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
 
       // Joins strings
       char* result_buf = &*result.begin();
-      memcpy(result_buf, start->data(), start->size());
-      result_buf += start->size();
+
+      memcpy(result_buf, start_value.data(), start_value.size());
+      result_buf += start_value.size();
       for (Iterator it = start; ++it != end;) {
         memcpy(result_buf, s.data(), s.size());
         result_buf += s.size();
-        memcpy(result_buf, it->data(), it->size());
-        result_buf += it->size();
+        auto&& value = *it;
+        memcpy(result_buf, value.data(), value.size());
+        result_buf += value.size();
       }
     }
   }

data/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h

@@ -132,7 +132,8 @@ class SplitIterator {
       const absl::string_view text = splitter_->text();
       const absl::string_view d = delimiter_.Find(text, pos_);
       if (d.data() == text.data() + text.size()) state_ = kLastState;
-      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+      curr_ = text.substr(pos_,
+                          static_cast<size_t>(d.data() - (text.data() + pos_)));
       pos_ += curr_.size() + d.size();
     } while (!predicate_(curr_));
     return *this;

data/third_party/abseil-cpp/absl/strings/internal/string_constant.h

@@ -35,17 +35,25 @@ namespace strings_internal {
 // below.
 template <typename T>
 struct StringConstant {
+ private:
+  static constexpr bool TryConstexprEval(absl::string_view view) {
+    return view.empty() || 2 * view[0] != 1;
+  }
+
+ public:
   static constexpr absl::string_view value = T{}();
   constexpr absl::string_view operator()() const { return value; }
 
   // Check to be sure `view` points to constant data.
   // Otherwise, it can't be constant evaluated.
-  static_assert(value.empty() || 2 * value[0] != 1,
+  static_assert(TryConstexprEval(value),
                 "The input string_view must point to constant data.");
 };
 
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
 template <typename T>
-constexpr absl::string_view StringConstant<T>::value;  // NOLINT
+constexpr absl::string_view StringConstant<T>::value;
+#endif
 
 // Factory function for `StringConstant` instances.
 // It supports callables that have a constexpr default constructor and a

data/third_party/abseil-cpp/absl/strings/internal/stringify_sink.cc

@@ -0,0 +1,28 @@
+// Copyright 2022 The Abseil 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
+//
+//     https://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 "absl/strings/internal/stringify_sink.h"
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+void StringifySink::Append(size_t count, char ch) { buffer_.append(count, ch); }
+
+void StringifySink::Append(string_view v) {
+  buffer_.append(v.data(), v.size());
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/strings/internal/stringify_sink.h

@@ -0,0 +1,57 @@
+// Copyright 2022 The Abseil 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
+//
+//     https://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 ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
+#define ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace strings_internal {
+class StringifySink {
+ public:
+  void Append(size_t count, char ch);
+
+  void Append(string_view v);
+
+  // Support `absl::Format(&sink, format, args...)`.
+  friend void AbslFormatFlush(StringifySink* sink, absl::string_view v) {
+    sink->Append(v);
+  }
+
+ private:
+  template <typename T>
+  friend string_view ExtractStringification(StringifySink& sink, const T& v);
+
+  std::string buffer_;
+};
+
+template <typename T>
+string_view ExtractStringification(StringifySink& sink, const T& v) {
+  AbslStringify(sink, v);
+  return sink.buffer_;
+}
+
+}  // namespace strings_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_

data/third_party/abseil-cpp/absl/strings/internal/utf8.cc

@@ -25,25 +25,25 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
     *buffer = static_cast<char>(utf8_char);
     return 1;
   } else if (utf8_char <= 0x7FF) {
-    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[0] = 0xC0 | utf8_char;
+    buffer[0] = static_cast<char>(0xC0 | utf8_char);
     return 2;
   } else if (utf8_char <= 0xFFFF) {
-    buffer[2] = 0x80 | (utf8_char & 0x3F);
+    buffer[2] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[0] = 0xE0 | utf8_char;
+    buffer[0] = static_cast<char>(0xE0 | utf8_char);
     return 3;
   } else {
-    buffer[3] = 0x80 | (utf8_char & 0x3F);
+    buffer[3] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[2] = 0x80 | (utf8_char & 0x3F);
+    buffer[2] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    buffer[1] = static_cast<char>(0x80 | (utf8_char & 0x3F));
     utf8_char >>= 6;
-    buffer[0] = 0xF0 | utf8_char;
+    buffer[0] = static_cast<char>(0xF0 | utf8_char);
     return 4;
   }
 }