google-protobuf 3.19.1 → 4.30.2

data/ext/google/protobuf_c/defs.h

@@ -1,38 +1,13 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
 //
-// 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 Inc. 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 THE COPYRIGHT
-// OWNER OR CONTRIBUTORS 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.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
 
 #ifndef RUBY_PROTOBUF_DEFS_H_
 #define RUBY_PROTOBUF_DEFS_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 
@@ -40,9 +15,9 @@
 // TypeInfo
 // -----------------------------------------------------------------------------
 
-// This bundles a upb_fieldtype_t and msgdef/enumdef when appropriate. This is
+// This bundles a upb_CType and msgdef/enumdef when appropriate. This is
 // convenient for functions that need type information but cannot necessarily
-// assume a upb_fielddef will be available.
+// assume a upb_FieldDef will be available.
 //
 // For example, Google::Protobuf::Map and Google::Protobuf::RepeatedField can
 // be constructed with type information alone:
@@ -51,21 +26,21 @@
 //   Google::Protobuf::RepeatedField.new(:message, FooMessage)
 
 typedef struct {
-  upb_fieldtype_t type;
+  upb_CType type;
   union {
-    const upb_msgdef* msgdef;      // When type == UPB_TYPE_MESSAGE
-    const upb_enumdef* enumdef;    // When type == UPB_TYPE_ENUM
+    const upb_MessageDef* msgdef;  // When type == kUpb_CType_Message
+    const upb_EnumDef* enumdef;    // When type == kUpb_CType_Enum
   } def;
 } TypeInfo;
 
-static inline TypeInfo TypeInfo_get(const upb_fielddef *f) {
-  TypeInfo ret = {upb_fielddef_type(f), {NULL}};
+static inline TypeInfo TypeInfo_get(const upb_FieldDef* f) {
+  TypeInfo ret = {upb_FieldDef_CType(f), {NULL}};
   switch (ret.type) {
-    case UPB_TYPE_MESSAGE:
-      ret.def.msgdef = upb_fielddef_msgsubdef(f);
+    case kUpb_CType_Message:
+      ret.def.msgdef = upb_FieldDef_MessageSubDef(f);
       break;
-    case UPB_TYPE_ENUM:
-      ret.def.enumdef = upb_fielddef_enumsubdef(f);
+    case kUpb_CType_Enum:
+      ret.def.enumdef = upb_FieldDef_EnumSubDef(f);
       break;
     default:
       break;
@@ -76,9 +51,9 @@ static inline TypeInfo TypeInfo_get(const upb_fielddef *f) {
 TypeInfo TypeInfo_FromClass(int argc, VALUE* argv, int skip_arg,
                             VALUE* type_class, VALUE* init_arg);
 
-static inline TypeInfo TypeInfo_from_type(upb_fieldtype_t type) {
+static inline TypeInfo TypeInfo_from_type(upb_CType type) {
   TypeInfo ret = {type};
-  assert(type != UPB_TYPE_MESSAGE && type != UPB_TYPE_ENUM);
+  assert(type != kUpb_CType_Message && type != kUpb_CType_Enum);
   return ret;
 }
 
@@ -86,17 +61,17 @@ static inline TypeInfo TypeInfo_from_type(upb_fieldtype_t type) {
 // Other utilities
 // -----------------------------------------------------------------------------
 
-VALUE Descriptor_DefToClass(const upb_msgdef *m);
+VALUE Descriptor_DefToClass(const upb_MessageDef* m);
 
 // Returns the underlying msgdef, enumdef, or symtab (respectively) for the
 // given Descriptor, EnumDescriptor, or DescriptorPool Ruby object.
-const upb_enumdef *EnumDescriptor_GetEnumDef(VALUE enum_desc_rb);
-const upb_symtab *DescriptorPool_GetSymtab(VALUE desc_pool_rb);
-const upb_msgdef *Descriptor_GetMsgDef(VALUE desc_rb);
+const upb_EnumDef* EnumDescriptor_GetEnumDef(VALUE enum_desc_rb);
+const upb_DefPool* DescriptorPool_GetSymtab(VALUE desc_pool_rb);
+const upb_MessageDef* Descriptor_GetMsgDef(VALUE desc_rb);
 
 // Returns a upb field type for the given Ruby symbol
-// (eg. :float => UPB_TYPE_FLOAT).
-upb_fieldtype_t ruby_to_fieldtype(VALUE type);
+// (eg. :float => kUpb_CType_Float).
+upb_CType ruby_to_fieldtype(VALUE type);
 
 // The singleton generated pool (a DescriptorPool object).
 extern VALUE generated_pool;

data/ext/google/protobuf_c/extconf.rb

@@ -2,19 +2,39 @@
 
 require 'mkmf'
 
-if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/
+ext_name = "google/protobuf_c"
+
+dir_config(ext_name)
+
+if ENV["CC"]
+  RbConfig::CONFIG["CC"] = RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+if ENV["CXX"]
+  RbConfig::CONFIG["CXX"] = RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"]
+end
+
+if ENV["LD"]
+  RbConfig::CONFIG["LD"] = RbConfig::MAKEFILE_CONFIG["LD"] = ENV["LD"]
+end
+
+if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
   $CFLAGS += " -std=gnu99 -O3 -DNDEBUG -fvisibility=hidden -Wall -Wsign-compare -Wno-declaration-after-statement"
 else
   $CFLAGS += " -std=gnu99 -O3 -DNDEBUG"
 end
 
-
 if RUBY_PLATFORM =~ /linux/
   # Instruct the linker to point memcpy calls at our __wrap_memcpy wrapper.
   $LDFLAGS += " -Wl,-wrap,memcpy"
 end
 
-$objs = ["protobuf.o", "convert.o", "defs.o", "message.o",
-         "repeated_field.o", "map.o", "ruby-upb.o", "wrap_memcpy.o"]
+$VPATH << "$(srcdir)/third_party/utf8_range"
+$INCFLAGS += " -I$(srcdir)/third_party/utf8_range"
+
+$srcs = ["protobuf.c", "convert.c", "defs.c", "message.c",
+         "repeated_field.c", "map.c", "ruby-upb.c", "wrap_memcpy.c",
+         "utf8_range.c", "shared_convert.c",
+         "shared_message.c"]
 
-create_makefile("google/protobuf_c")
+create_makefile(ext_name)

data/ext/google/protobuf_c/glue.c

@@ -0,0 +1,135 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2023 Google Inc.  All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
+
+// -----------------------------------------------------------------------------
+// Exposing inlined UPB functions. Strictly free of dependencies on
+// Ruby interpreter internals.
+
+#include "ruby-upb.h"
+
+upb_Arena* Arena_create() { return upb_Arena_Init(NULL, 0, &upb_alloc_global); }
+
+google_protobuf_FileDescriptorProto* FileDescriptorProto_parse(
+    const char* serialized_file_proto, size_t length, upb_Arena* arena) {
+  return google_protobuf_FileDescriptorProto_parse(serialized_file_proto,
+                                                   length, arena);
+}
+
+char* EnumDescriptor_serialized_options(const upb_EnumDef* enumdef,
+                                        size_t* size, upb_Arena* arena) {
+  const google_protobuf_EnumOptions* opts = upb_EnumDef_Options(enumdef);
+  char* serialized = google_protobuf_EnumOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* EnumDescriptor_serialized_to_proto(const upb_EnumDef* enumdef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_EnumDescriptorProto* file_proto =
+      upb_EnumDef_ToProto(enumdef, arena);
+  char* serialized =
+      google_protobuf_EnumDescriptorProto_serialize(file_proto, arena, size);
+  return serialized;
+}
+
+char* FileDescriptor_serialized_options(const upb_FileDef* filedef,
+                                        size_t* size, upb_Arena* arena) {
+  const google_protobuf_FileOptions* opts = upb_FileDef_Options(filedef);
+  char* serialized = google_protobuf_FileOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* FileDescriptor_serialized_to_proto(const upb_FileDef* filedef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_FileDescriptorProto* file_proto =
+      upb_FileDef_ToProto(filedef, arena);
+  char* serialized =
+      google_protobuf_FileDescriptorProto_serialize(file_proto, arena, size);
+  return serialized;
+}
+
+char* Descriptor_serialized_options(const upb_MessageDef* msgdef, size_t* size,
+                                    upb_Arena* arena) {
+  const google_protobuf_MessageOptions* opts = upb_MessageDef_Options(msgdef);
+  char* serialized =
+      google_protobuf_MessageOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* Descriptor_serialized_to_proto(const upb_MessageDef* msgdef, size_t* size,
+                                     upb_Arena* arena) {
+  const google_protobuf_DescriptorProto* proto =
+      upb_MessageDef_ToProto(msgdef, arena);
+  char* serialized =
+      google_protobuf_DescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
+char* OneOfDescriptor_serialized_options(const upb_OneofDef* oneofdef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_OneofOptions* opts = upb_OneofDef_Options(oneofdef);
+  char* serialized = google_protobuf_OneofOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* OneOfDescriptor_serialized_to_proto(const upb_OneofDef* oneofdef,
+                                          size_t* size, upb_Arena* arena) {
+  const google_protobuf_OneofDescriptorProto* proto =
+      upb_OneofDef_ToProto(oneofdef, arena);
+  char* serialized =
+      google_protobuf_OneofDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
+char* FieldDescriptor_serialized_options(const upb_FieldDef* fielddef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_FieldOptions* opts = upb_FieldDef_Options(fielddef);
+  char* serialized = google_protobuf_FieldOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* FieldDescriptor_serialized_to_proto(const upb_FieldDef* fieldef,
+                                          size_t* size, upb_Arena* arena) {
+  const google_protobuf_FieldDescriptorProto* proto =
+      upb_FieldDef_ToProto(fieldef, arena);
+  char* serialized =
+      google_protobuf_FieldDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
+char* ServiceDescriptor_serialized_options(const upb_ServiceDef* servicedef,
+                                           size_t* size, upb_Arena* arena) {
+  const google_protobuf_ServiceOptions* opts =
+      upb_ServiceDef_Options(servicedef);
+  char* serialized =
+      google_protobuf_ServiceOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* ServiceDescriptor_serialized_to_proto(const upb_ServiceDef* servicedef,
+                                            size_t* size, upb_Arena* arena) {
+  const google_protobuf_ServiceDescriptorProto* proto =
+      upb_ServiceDef_ToProto(servicedef, arena);
+  char* serialized =
+      google_protobuf_ServiceDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
+char* MethodDescriptor_serialized_options(const upb_MethodDef* methoddef,
+                                          size_t* size, upb_Arena* arena) {
+  const google_protobuf_MethodOptions* opts = upb_MethodDef_Options(methoddef);
+  char* serialized = google_protobuf_MethodOptions_serialize(opts, arena, size);
+  return serialized;
+}
+
+char* MethodDescriptor_serialized_to_proto(const upb_MethodDef* methodef,
+                                           size_t* size, upb_Arena* arena) {
+  const google_protobuf_MethodDescriptorProto* proto =
+      upb_MethodDef_ToProto(methodef, arena);
+  char* serialized =
+      google_protobuf_MethodDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}