google-protobuf 3.22.2 → 4.30.1

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"
 

data/ext/google/protobuf_c/extconf.rb

@@ -6,6 +6,18 @@ 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
@@ -22,6 +34,7 @@ $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",
-         "naive.c", "range2-neon.c", "range2-sse.c"]
+         "utf8_range.c", "shared_convert.c",
+         "shared_message.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;
+}

data/ext/google/protobuf_c/map.c

@@ -1,32 +1,9 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2014 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
 
 #include "convert.h"
 #include "defs.h"
@@ -61,9 +38,11 @@ static void Map_mark(void* _self) {
   rb_gc_mark(self->arena);
 }
 
+static size_t Map_memsize(const void* _self) { return sizeof(Map); }
+
 const rb_data_type_t Map_type = {
     "Google::Protobuf::Map",
-    {Map_mark, RUBY_DEFAULT_FREE, NULL},
+    {Map_mark, RUBY_DEFAULT_FREE, Map_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
@@ -84,16 +63,16 @@ static VALUE Map_alloc(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Map_type, self);
 }
 
-VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
-                         VALUE arena) {
+VALUE Map_GetRubyWrapper(const upb_Map* map, upb_CType key_type,
+                         TypeInfo value_type, VALUE arena) {
   PBRUBY_ASSERT(map);
+  PBRUBY_ASSERT(arena != Qnil);
 
   VALUE val = ObjectCache_Get(map);
 
   if (val == Qnil) {
     val = Map_alloc(cMap);
     Map* self;
-    ObjectCache_Add(map, val);
     TypedData_Get_Struct(val, Map, &Map_type, self);
     self->map = map;
     self->arena = arena;
@@ -103,8 +82,8 @@ VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
       const upb_MessageDef* val_m = self->value_type_info.def.msgdef;
       self->value_type_class = Descriptor_DefToClass(val_m);
     }
+    return ObjectCache_TryAdd(map, val);
   }
-
   return val;
 }
 
@@ -126,8 +105,9 @@ static TypeInfo Map_keyinfo(Map* self) {
 }
 
 static upb_Map* Map_GetMutable(VALUE _self) {
-  rb_check_frozen(_self);
-  return (upb_Map*)ruby_to_Map(_self)->map;
+  const upb_Map* map = ruby_to_Map(_self)->map;
+  Protobuf_CheckNotFrozen(_self, upb_Map_IsFrozen(map));
+  return (upb_Map*)map;
 }
 
 VALUE Map_CreateHash(const upb_Map* map, upb_CType key_type,
@@ -235,7 +215,7 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
     Map* self = ruby_to_Map(_self);
     Map* other = ruby_to_Map(hashmap);
     upb_Arena* arena = Arena_get(self->arena);
-    upb_Message* self_msg = Map_GetMutable(_self);
+    upb_Map* self_map = Map_GetMutable(_self);
 
     Arena_fuse(other->arena, arena);
 
@@ -248,7 +228,7 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
     size_t iter = kUpb_Map_Begin;
     upb_MessageValue key, val;
     while (upb_Map_Next(other->map, &key, &val, &iter)) {
-      upb_Map_Set(self_msg, key, val, arena);
+      upb_Map_Set(self_map, key, val, arena);
     }
   } else {
     rb_raise(rb_eArgError, "Unknown type merging into Map");
@@ -319,7 +299,9 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
 
   self->map = upb_Map_New(Arena_get(self->arena), self->key_type,
                           self->value_type_info.type);
-  ObjectCache_Add(self->map, _self);
+  VALUE stored = ObjectCache_TryAdd(self->map, _self);
+  (void)stored;
+  PBRUBY_ASSERT(stored == _self);
 
   if (init_arg != Qnil) {
     Map_merge_into_self(_self, init_arg);
@@ -458,14 +440,14 @@ static VALUE Map_has_key(VALUE _self, VALUE key) {
  * nil if none was present. Throws an exception if the key is of the wrong type.
  */
 static VALUE Map_delete(VALUE _self, VALUE key) {
+  upb_Map* map = Map_GetMutable(_self);
   Map* self = ruby_to_Map(_self);
-  rb_check_frozen(_self);
 
   upb_MessageValue key_upb =
       Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
   upb_MessageValue val_upb;
 
-  if (upb_Map_Delete(self->map, key_upb, &val_upb)) {
+  if (upb_Map_Delete(map, key_upb, &val_upb)) {
     return Convert_UpbToRuby(val_upb, self->value_type_info, self->arena);
   } else {
     return Qnil;
@@ -579,20 +561,81 @@ VALUE Map_eq(VALUE _self, VALUE _other) {
 
 /*
  * call-seq:
- *     Message.freeze => self
+ *     Map.frozen? => bool
  *
- * Freezes the message object. We have to intercept this so we can pin the
- * Ruby object into memory so we don't forget it's frozen.
+ * Returns true if the map is frozen in either Ruby or the underlying
+ * representation. Freezes the Ruby map object if it is not already frozen in
+ * Ruby but it is frozen in the underlying representation.
  */
-static VALUE Map_freeze(VALUE _self) {
+VALUE Map_frozen(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  if (!RB_OBJ_FROZEN(_self)) {
-    Arena_Pin(self->arena, _self);
-    RB_OBJ_FREEZE(_self);
+  if (!upb_Map_IsFrozen(self->map)) {
+    PBRUBY_ASSERT(!RB_OBJ_FROZEN(_self));
+    return Qfalse;
+  }
+
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
+}
+
+/*
+ * call-seq:
+ *     Map.freeze => self
+ *
+ * Freezes the map object. We have to intercept this so we can freeze the
+ * underlying representation, not just the Ruby wrapper.
+ */
+VALUE Map_freeze(VALUE _self) {
+  Map* self = ruby_to_Map(_self);
+  if (RB_OBJ_FROZEN(_self)) {
+    PBRUBY_ASSERT(upb_Map_IsFrozen(self->map));
+    return _self;
+  }
+
+  if (!upb_Map_IsFrozen(self->map)) {
+    if (self->value_type_info.type == kUpb_CType_Message) {
+      upb_Map_Freeze(
+          Map_GetMutable(_self),
+          upb_MessageDef_MiniTable(self->value_type_info.def.msgdef));
+    } else {
+      upb_Map_Freeze(Map_GetMutable(_self), NULL);
+    }
   }
+
+  RB_OBJ_FREEZE(_self);
+
   return _self;
 }
 
+VALUE Map_EmptyFrozen(const upb_FieldDef* f) {
+  PBRUBY_ASSERT(upb_FieldDef_IsMap(f));
+  VALUE val = ObjectCache_Get(f);
+
+  if (val == Qnil) {
+    const upb_FieldDef* key_f = map_field_key(f);
+    const upb_FieldDef* val_f = map_field_value(f);
+    upb_CType key_type = upb_FieldDef_CType(key_f);
+    TypeInfo value_type_info = TypeInfo_get(val_f);
+    val = Map_alloc(cMap);
+    Map* self;
+    TypedData_Get_Struct(val, Map, &Map_type, self);
+    self->arena = Arena_new();
+    self->map =
+        upb_Map_New(Arena_get(self->arena), key_type, value_type_info.type);
+    self->key_type = key_type;
+    self->value_type_info = value_type_info;
+    if (self->value_type_info.type == kUpb_CType_Message) {
+      const upb_MessageDef* val_m = value_type_info.def.msgdef;
+      self->value_type_class = Descriptor_DefToClass(val_m);
+    }
+    return ObjectCache_TryAdd(f, Map_freeze(val));
+  }
+  PBRUBY_ASSERT(RB_OBJ_FROZEN(val));
+  PBRUBY_ASSERT(upb_Map_IsFrozen(ruby_to_Map(val)->map));
+  return val;
+}
+
 /*
  * call-seq:
  *     Map.hash => hash_value
@@ -679,6 +722,7 @@ void Map_register(VALUE module) {
   rb_define_method(klass, "clone", Map_dup, 0);
   rb_define_method(klass, "==", Map_eq, 1);
   rb_define_method(klass, "freeze", Map_freeze, 0);
+  rb_define_method(klass, "frozen?", Map_frozen, 0);
   rb_define_method(klass, "hash", Map_hash, 0);
   rb_define_method(klass, "to_h", Map_to_h, 0);
   rb_define_method(klass, "inspect", Map_inspect, 0);

data/ext/google/protobuf_c/map.h

@@ -1,45 +1,24 @@
 // 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_MAP_H_
 #define RUBY_PROTOBUF_MAP_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 
+// Returns a frozen sentinel Ruby wrapper object for an empty upb_Map with the
+// key and value types specified by the field. Creates one if it doesn't exist.
+VALUE Map_EmptyFrozen(const upb_FieldDef* f);
+
 // Returns a Ruby wrapper object for the given map, which will be created if
 // one does not exist already.
-VALUE Map_GetRubyWrapper(upb_Map *map, upb_CType key_type, TypeInfo value_type,
-                         VALUE arena);
+VALUE Map_GetRubyWrapper(const upb_Map *map, upb_CType key_type,
+                         TypeInfo value_type, VALUE arena);
 
 // Gets the underlying upb_Map for this Ruby map object, which must have
 // key/value type that match |field|. If this is not a map or the type doesn't
@@ -63,4 +42,7 @@ extern VALUE cMap;
 // Call at startup to register all types in this module.
 void Map_register(VALUE module);
 
+// Recursively freeze map
+VALUE Map_freeze(VALUE _self);
+
 #endif  // RUBY_PROTOBUF_MAP_H_