ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/required_fields.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_UTIL_REQUIRED_FIELDS_H_
+#define UPB_UTIL_REQUIRED_FIELDS_H_
+
+#include "upb/def.h"
+#include "upb/reflection.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// A FieldPath can be encoded as an array of upb_FieldPathEntry, in the
+// following format:
+//    { {.field = f1}, {.field = f2} }                      # f1.f2
+//    { {.field = f1}, {.index = 5}, {.field = f2} }        # f1[5].f2
+//    { {.field = f1}, {.key = "abc"}, {.field = f2} }      # f1["abc"].f2
+//
+// Users must look at the type of `field` to know if an index or map key
+// follows.
+//
+// A field path may be NULL-terminated, in which case a NULL field indicates
+// the end of the field path.
+typedef union {
+  const upb_FieldDef* field;
+  size_t array_index;
+  upb_MessageValue map_key;
+} upb_FieldPathEntry;
+
+// Writes a string representing `*path` to `buf` in the following textual
+// format:
+//    foo.bar                    # Regular fields
+//    repeated_baz[2].bar        # Repeated field
+//    int32_msg_map[5].bar       # Integer-keyed map
+//    string_msg_map["abc"]      # String-keyed map
+//    bool_msg_map[true]         # Bool-keyed map
+//
+// The input array `*path` must be NULL-terminated.  The pointer `*path` will be
+// updated to point to one past the terminating NULL pointer of the input array.
+//
+// The output buffer `buf` will always be NULL-terminated. If the output data
+// (including NULL terminator) exceeds `size`, the result will be truncated.
+// Returns the string length of the data we attempted to write, excluding the
+// terminating NULL.
+size_t upb_FieldPath_ToText(upb_FieldPathEntry** path, char* buf, size_t size);
+
+// Checks whether `msg` or any of its children has unset required fields,
+// returning `true` if any are found.  `msg` may be NULL, in which case the
+// message will be treated as empty.
+//
+// When this function returns true, `fields` is updated (if non-NULL) to point
+// to a heap-allocated array encoding the field paths of the required fields
+// that are missing.  Each path is terminated with {.field = NULL}, and a final
+// {.field = NULL} terminates the list of paths.  The caller is responsible for
+// freeing this array.
+bool upb_util_HasUnsetRequired(const upb_Message* msg, const upb_MessageDef* m,
+                               const upb_DefPool* ext_pool,
+                               upb_FieldPathEntry** fields);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_UTIL_REQUIRED_FIELDS_H_ */

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/required_fields_test.cc

@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "upb/util/required_fields.h"
+
+#include "absl/strings/string_view.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "upb/def.hpp"
+#include "upb/json_decode.h"
+#include "upb/upb.hpp"
+#include "upb/util/required_fields_test.upb.h"
+#include "upb/util/required_fields_test.upbdefs.h"
+
+std::vector<std::string> PathsToText(upb_FieldPathEntry* entry) {
+  std::vector<std::string> ret;
+  char buf[1024];  // Larger than anything we'll use in this test.
+  while (entry->field) {
+    upb_FieldPathEntry* before = entry;
+    size_t len = upb_FieldPath_ToText(&entry, buf, sizeof(buf));
+    EXPECT_LT(len, sizeof(buf));
+    assert(len <= sizeof(buf));
+    ret.push_back(buf);
+
+    // Ensure that we can have a short buffer and that it will be
+    // NULL-terminated.
+    char shortbuf[4];
+    size_t len2 = upb_FieldPath_ToText(&before, shortbuf, sizeof(shortbuf));
+    EXPECT_EQ(len, len2);
+    EXPECT_EQ(ret.back().substr(0, sizeof(shortbuf) - 1),
+              std::string(shortbuf));
+  }
+  return ret;
+}
+
+void CheckRequired(absl::string_view json,
+                   const std::vector<std::string>& missing) {
+  upb::Arena arena;
+  upb::SymbolTable symtab;
+  upb_util_test_TestRequiredFields* test_msg =
+      upb_util_test_TestRequiredFields_new(arena.ptr());
+  upb::MessageDefPtr m(
+      upb_util_test_TestRequiredFields_getmsgdef(symtab.ptr()));
+  upb::Status status;
+  EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), test_msg, m.ptr(),
+                             symtab.ptr(), 0, arena.ptr(), status.ptr()))
+      << status.error_message();
+  upb_FieldPathEntry* entries;
+  EXPECT_EQ(!missing.empty(), upb_util_HasUnsetRequired(
+                                  test_msg, m.ptr(), symtab.ptr(), &entries));
+  EXPECT_EQ(missing, PathsToText(entries));
+  free(entries);
+
+  // Verify that we can pass a NULL pointer to entries when we don't care about
+  // them.
+  EXPECT_EQ(!missing.empty(),
+            upb_util_HasUnsetRequired(test_msg, m.ptr(), symtab.ptr(), NULL));
+}
+
+// message HasRequiredField {
+//   required int32 required_int32 = 1;
+// }
+//
+// message TestRequiredFields {
+//   required EmptyMessage required_message = 1;
+//   optional TestRequiredFields optional_message = 2;
+//   repeated HasRequiredField repeated_message = 3;
+//   map<int32, HasRequiredField> map_int32_message = 4;
+// }
+TEST(RequiredFieldsTest, TestRequired) {
+  CheckRequired(R"json({})json", {"required_message"});
+  CheckRequired(R"json({"required_message": {}}")json", {});
+  CheckRequired(
+      R"json(
+      {
+        "optional_message": {}
+      }
+      )json",
+      {"required_message", "optional_message.required_message"});
+
+  // Repeated field.
+  CheckRequired(
+      R"json(
+      {
+        "optional_message": {
+          "repeated_message": [
+            {"required_int32": 1},
+            {},
+            {"required_int32": 2}
+          ]
+        }
+      }
+      )json",
+      {"required_message", "optional_message.required_message",
+       "optional_message.repeated_message[1].required_int32"});
+
+  // Int32 map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_int32_message": {
+          "1": {"required_int32": 1},
+          "5": {},
+          "9": {"required_int32": 1}
+        }
+      }
+      )json",
+      {"map_int32_message[5].required_int32"});
+
+  // Int64 map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_int64_message": {
+          "1": {"required_int32": 1},
+          "5": {},
+          "9": {"required_int32": 1}
+        }
+      }
+      )json",
+      {"map_int64_message[5].required_int32"});
+
+  // Uint32 map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_uint32_message": {
+          "1": {"required_int32": 1},
+          "5": {},
+          "9": {"required_int32": 1}
+        }
+      }
+      )json",
+      {"map_uint32_message[5].required_int32"});
+
+  // Uint64 map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_uint64_message": {
+          "1": {"required_int32": 1},
+          "5": {},
+          "9": {"required_int32": 1}
+        }
+      }
+      )json",
+      {"map_uint64_message[5].required_int32"});
+
+  // Bool map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_bool_message": {
+          "false": {"required_int32": 1},
+          "true": {}
+        }
+      }
+      )json",
+      {"map_bool_message[true].required_int32"});
+
+  // String map key.
+  CheckRequired(
+      R"json(
+      {
+        "required_message": {},
+        "map_string_message": {
+          "abc": {"required_int32": 1},
+          "d\"ef": {}
+        }
+      }
+      )json",
+      {R"(map_string_message["d\"ef"].required_int32)"});
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/util/required_fields_test.proto

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+syntax = "proto2";
+
+package upb_util_test;
+
+message EmptyMessage {}
+
+message HasRequiredField {
+  required int32 required_int32 = 1;
+}
+
+message TestRequiredFields {
+  required EmptyMessage required_message = 1;
+  optional TestRequiredFields optional_message = 2;
+  repeated HasRequiredField repeated_message = 3;
+  map<int32, HasRequiredField> map_int32_message = 4;
+  map<int64, HasRequiredField> map_int64_message = 5;
+  map<uint32, HasRequiredField> map_uint32_message = 6;
+  map<uint64, HasRequiredField> map_uint64_message = 7;
+  map<bool, HasRequiredField> map_bool_message = 8;
+  map<string, HasRequiredField> map_string_message = 9;
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/upbc/BUILD

@@ -0,0 +1,78 @@
+# Copyright (c) 2009-2021, Google LLC
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of Google LLC nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+load(
+    "//bazel:build_defs.bzl",
+    "UPB_DEFAULT_CPPOPTS",
+)
+
+licenses(["notice"])
+
+cc_library(
+    name = "common",
+    srcs = ["common.cc"],
+    hdrs = ["common.h"],
+    copts = UPB_DEFAULT_CPPOPTS,
+    deps = [
+        "@com_google_absl//absl/strings",
+        "@com_google_protobuf//:protobuf",
+    ],
+)
+
+cc_binary(
+    name = "protoc-gen-upb",
+    srcs = ["protoc-gen-upb.cc"],
+    copts = UPB_DEFAULT_CPPOPTS,
+    visibility = ["//visibility:public"],
+    deps = [
+        ":common",
+        "//:mini_table",
+        "//:port",
+        "//:upb",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/strings",
+        "@com_google_protobuf//:protobuf",
+        "@com_google_protobuf//:protoc_lib",
+    ],
+)
+
+cc_binary(
+    name = "protoc-gen-upbdefs",
+    srcs = [
+        "protoc-gen-upbdefs.cc",
+    ],
+    copts = UPB_DEFAULT_CPPOPTS,
+    visibility = ["//visibility:public"],
+    deps = [
+        ":common",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/strings",
+        "@com_google_protobuf//:protobuf",
+        "@com_google_protobuf//:protoc_lib",
+    ],
+)

data/ext/ruby_memprofiler_pprof/vendor/upb/upbc/common.cc

@@ -0,0 +1,77 @@
+// Copyright (c) 2009-2021, Google LLC
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Google LLC nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "upbc/common.h"
+
+#include "absl/strings/str_replace.h"
+
+namespace upbc {
+namespace {
+
+namespace protobuf = ::google::protobuf;
+
+}  // namespace
+
+std::string StripExtension(absl::string_view fname) {
+  size_t lastdot = fname.find_last_of('.');
+  if (lastdot == std::string::npos) {
+    return std::string(fname);
+  }
+  return std::string(fname.substr(0, lastdot));
+}
+
+std::string ToCIdent(absl::string_view str) {
+  return absl::StrReplaceAll(str, {{".", "_"}, {"/", "_"}});
+}
+
+std::string ToPreproc(absl::string_view str) {
+  return absl::AsciiStrToUpper(ToCIdent(str));
+}
+
+void EmitFileWarning(const protobuf::FileDescriptor* file, Output& output) {
+  output(
+      "/* This file was generated by upbc (the upb compiler) from the input\n"
+      " * file:\n"
+      " *\n"
+      " *     $0\n"
+      " *\n"
+      " * Do not edit -- your changes will be discarded when the file is\n"
+      " * regenerated. */\n\n",
+      file->name());
+}
+
+std::string MessageName(const protobuf::Descriptor* descriptor) {
+  return ToCIdent(descriptor->full_name());
+}
+
+std::string FileLayoutName(const google::protobuf::FileDescriptor* file) {
+  return ToCIdent(file->name()) + "_upb_file_layout";
+}
+
+std::string HeaderFilename(const google::protobuf::FileDescriptor* file) {
+  return StripExtension(file->name()) + ".upb.h";
+}
+
+}  // namespace upbc

data/ext/ruby_memprofiler_pprof/vendor/upb/upbc/common.h

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPBC_COMMON_H
+#define UPBC_COMMON_H
+
+#include <vector>
+
+#include "absl/strings/str_replace.h"
+#include "absl/strings/substitute.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/io/zero_copy_stream.h"
+
+namespace upbc {
+
+class Output {
+ public:
+  Output(google::protobuf::io::ZeroCopyOutputStream* stream)
+      : stream_(stream) {}
+  ~Output() { stream_->BackUp((int)size_); }
+
+  template <class... Arg>
+  void operator()(absl::string_view format, const Arg&... arg) {
+    Write(absl::Substitute(format, arg...));
+  }
+
+ private:
+  void Write(absl::string_view data) {
+    std::string stripped;
+    if (absl::StartsWith(data, "\n ")) {
+      size_t indent = data.substr(1).find_first_not_of(' ');
+      if (indent != absl::string_view::npos) {
+        // Remove indentation from all lines.
+        auto line_prefix = data.substr(0, indent + 1);
+        // The final line has an extra newline and is indented two less, eg.
+        //    R"cc(
+        //      UPB_INLINE $0 $1_$2(const $1 *msg) {
+        //        return $1_has_$2(msg) ? *UPB_PTR_AT(msg, $3, $0) : $4;
+        //      }
+        //    )cc",
+        std::string last_line_prefix = std::string(line_prefix);
+        last_line_prefix.resize(last_line_prefix.size() - 2);
+        data.remove_prefix(line_prefix.size());
+        stripped = absl::StrReplaceAll(
+            data, {{line_prefix, "\n"}, {last_line_prefix, "\n"}});
+        data = stripped;
+      }
+    }
+    while (!data.empty()) {
+      RefreshOutput();
+      size_t to_write = std::min(data.size(), size_);
+      memcpy(ptr_, data.data(), to_write);
+      data.remove_prefix(to_write);
+      ptr_ += to_write;
+      size_ -= to_write;
+    }
+  }
+
+  void RefreshOutput() {
+    while (size_ == 0) {
+      void* ptr;
+      int size;
+      if (!stream_->Next(&ptr, &size)) {
+        fprintf(stderr, "upbc: Failed to write to to output\n");
+        abort();
+      }
+      ptr_ = static_cast<char*>(ptr);
+      size_ = size;
+    }
+  }
+
+  google::protobuf::io::ZeroCopyOutputStream* stream_;
+  char* ptr_ = nullptr;
+  size_t size_ = 0;
+};
+
+std::string StripExtension(absl::string_view fname);
+std::string ToCIdent(absl::string_view str);
+std::string ToPreproc(absl::string_view str);
+void EmitFileWarning(const google::protobuf::FileDescriptor* file,
+                     Output& output);
+std::string MessageName(const google::protobuf::Descriptor* descriptor);
+std::string FileLayoutName(const google::protobuf::FileDescriptor* file);
+std::string HeaderFilename(const google::protobuf::FileDescriptor* file);
+
+}  // namespace upbc
+
+#endif  // UPBC_COMMON_H