google-protobuf 4.29.3 → 4.33.1

data/ext/google/protobuf_c/extconf.rb

@@ -6,23 +6,33 @@ ext_name = "google/protobuf_c"
 
 dir_config(ext_name)
 
-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"
+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 =~ /linux/
-  # Instruct the linker to point memcpy calls at our __wrap_memcpy wrapper.
-  $LDFLAGS += " -Wl,-wrap,memcpy"
+debug_enabled = ENV["PROTOBUF_CONFIG"] == "dbg"
+
+additional_c_flags = debug_enabled ? "-O0 -fno-omit-frame-pointer -fvisibility=default -g" : "-O3 -DNDEBUG -fvisibility=hidden"
+
+if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
+  $CFLAGS += " -std=gnu99 -Wall -Wsign-compare -Wno-declaration-after-statement #{additional_c_flags}"
+else
+  $CFLAGS += " -std=gnu99 #{additional_c_flags}"
 end
 
 $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",
+$srcs = ["protobuf.c", "convert.c", "defs.c", "message.c", "repeated_field.c",
+         "map.c", "ruby-upb.c", "utf8_range.c", "shared_convert.c",
          "shared_message.c"]
 
 create_makefile(ext_name)

data/ext/google/protobuf_c/glue.c

@@ -26,6 +26,15 @@ char* EnumDescriptor_serialized_options(const upb_EnumDef* enumdef,
   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);
@@ -33,6 +42,15 @@ char* FileDescriptor_serialized_options(const upb_FileDef* filedef,
   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);
@@ -41,6 +59,15 @@ char* Descriptor_serialized_options(const upb_MessageDef* msgdef, size_t* 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);
@@ -48,6 +75,15 @@ char* OneOfDescriptor_serialized_options(const upb_OneofDef* oneofdef,
   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);
@@ -55,6 +91,15 @@ char* FieldDescriptor_serialized_options(const upb_FieldDef* fielddef,
   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 =
@@ -64,9 +109,27 @@ char* ServiceDescriptor_serialized_options(const upb_ServiceDef* servicedef,
   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

@@ -236,10 +236,15 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
   return _self;
 }
 
+/**
+ * ruby-doc: Map
+ *
+ * This class represents a Protobuf Map. It is largely automatically transformed
+ * to and from a Ruby hash.
+ */
+
 /*
- * call-seq:
- *     Map.new(key_type, value_type, value_typeclass = nil, init_hashmap = {})
- *     => new map
+ * ruby-doc: Map#initialize
  *
  * Allocates a new Map container. This constructor may be called with 2, 3, or 4
  * arguments. The first two arguments are always present and are symbols (taking
@@ -265,6 +270,13 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
  * shallow-copied into the new Map: the original map is unmodified, but
  * references to underlying objects will be shared if the value type is a
  * message type.
+ *
+ * @param key_type [Symbol]
+ * @param value_type [Symbol]
+ * @param value_typeclass [Class<AbstractMessage>,Module]
+ * @paramdefault value_typeclass nil
+ * @param init_hashmap [Hash,Map]
+ * @paramdefault init_hashmap {}
  */
 static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -311,12 +323,14 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.each(&block)
+ * ruby-doc: Map#each
  *
  * Invokes &block on each |key, value| pair in the map, in unspecified order.
  * Note that Map also includes Enumerable; map thus acts like a normal Ruby
  * sequence.
+ *
+ * @yield [Object, Object]
+ * @return [nil]
  */
 static VALUE Map_each(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -333,10 +347,11 @@ static VALUE Map_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.keys => [list_of_keys]
+ * ruby-doc: Map#keys
  *
  * Returns the list of keys contained in the map, in unspecified order.
+ *
+ * @return [Array<Object>]
  */
 static VALUE Map_keys(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -353,10 +368,11 @@ static VALUE Map_keys(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.values => [list_of_values]
+ * ruby-doc: Map#values
  *
  * Returns the list of values contained in the map, in unspecified order.
+ *
+ * @return [Array<Object>]
  */
 static VALUE Map_values(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -373,11 +389,13 @@ static VALUE Map_values(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.[](key) => value
+ * ruby-doc: Map#[]
  *
  * Accesses the element at the given key. Throws an exception if the key type is
  * incorrect. Returns nil when the key is not present in the map.
+ *
+ * @param key [Object]
+ * @return [Object]
  */
 static VALUE Map_index(VALUE _self, VALUE key) {
   Map* self = ruby_to_Map(_self);
@@ -393,12 +411,15 @@ static VALUE Map_index(VALUE _self, VALUE key) {
 }
 
 /*
- * call-seq:
- *     Map.[]=(key, value) => value
+ * ruby-doc: Map#[]=
  *
  * Inserts or overwrites the value at the given key with the given new value.
  * Throws an exception if the key type is incorrect. Returns the new value that
  * was just inserted.
+ *
+ * @param key [Object]
+ * @param value [Object]
+ * @return [Object]
  */
 static VALUE Map_index_set(VALUE _self, VALUE key, VALUE val) {
   Map* self = ruby_to_Map(_self);
@@ -414,11 +435,13 @@ static VALUE Map_index_set(VALUE _self, VALUE key, VALUE val) {
 }
 
 /*
- * call-seq:
- *     Map.has_key?(key) => bool
+ * ruby-doc: Map#has_key?
  *
  * Returns true if the given key is present in the map. Throws an exception if
  * the key has the wrong type.
+ *
+ * @param key [Object]
+ * @return [Boolean]
  */
 static VALUE Map_has_key(VALUE _self, VALUE key) {
   Map* self = ruby_to_Map(_self);
@@ -433,11 +456,13 @@ static VALUE Map_has_key(VALUE _self, VALUE key) {
 }
 
 /*
- * call-seq:
- *     Map.delete(key) => old_value
+ * ruby-doc: Map#delete
  *
  * Deletes the value at the given key, if any, returning either the old value or
  * nil if none was present. Throws an exception if the key is of the wrong type.
+ *
+ * @param key [Object]
+ * @return [Object]
  */
 static VALUE Map_delete(VALUE _self, VALUE key) {
   upb_Map* map = Map_GetMutable(_self);
@@ -455,10 +480,11 @@ static VALUE Map_delete(VALUE _self, VALUE key) {
 }
 
 /*
- * call-seq:
- *     Map.clear
+ * ruby-doc: Map#clear
  *
  * Removes all entries from the map.
+ *
+ * @return [nil]
  */
 static VALUE Map_clear(VALUE _self) {
   upb_Map_Clear(Map_GetMutable(_self));
@@ -466,10 +492,11 @@ static VALUE Map_clear(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.length
+ * ruby-doc: Map#length
  *
  * Returns the number of entries (key-value pairs) in the map.
+ *
+ * @return [Integer]
  */
 static VALUE Map_length(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -477,11 +504,12 @@ static VALUE Map_length(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.dup => new_map
+ * ruby-doc: Map#dup
  *
  * Duplicates this map with a shallow copy. References to all non-primitive
  * element objects (e.g., submessages) are shared.
+ *
+ * @return [Map]
  */
 static VALUE Map_dup(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -502,8 +530,7 @@ static VALUE Map_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.==(other) => boolean
+ * ruby-doc: Map#==
  *
  * Compares this map to another. Maps are equal if they have identical key sets,
  * and for each key, the values in both maps compare equal. Elements are
@@ -513,6 +540,9 @@ static VALUE Map_dup(VALUE _self) {
  * Maps with dissimilar key types or value types/typeclasses are never equal,
  * even if value comparison (for example, between integers and floats) would
  * have otherwise indicated that every element has equal value.
+ *
+ * @param other [Map]
+ * @return [Boolean]
  */
 VALUE Map_eq(VALUE _self, VALUE _other) {
   Map* self = ruby_to_Map(_self);
@@ -560,12 +590,13 @@ VALUE Map_eq(VALUE _self, VALUE _other) {
 }
 
 /*
- * call-seq:
- *     Map.frozen? => bool
+ * ruby-doc: Map#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.
+ *
+ * @return [Boolean]
  */
 VALUE Map_frozen(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -580,11 +611,12 @@ VALUE Map_frozen(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.freeze => self
+ * ruby-doc: Map#freeze
  *
  * Freezes the map object. We have to intercept this so we can freeze the
  * underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
 VALUE Map_freeze(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -637,10 +669,11 @@ VALUE Map_EmptyFrozen(const upb_FieldDef* f) {
 }
 
 /*
- * call-seq:
- *     Map.hash => hash_value
+ * ruby-doc: Map#hash
  *
  * Returns a hash value based on this map's contents.
+ *
+ * @return [Integer]
  */
 VALUE Map_hash(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -650,18 +683,19 @@ VALUE Map_hash(VALUE _self) {
   TypeInfo key_info = {self->key_type};
   upb_MessageValue key, val;
   while (upb_Map_Next(self->map, &key, &val, &iter)) {
-    hash = Msgval_GetHash(key, key_info, hash);
-    hash = Msgval_GetHash(val, self->value_type_info, hash);
+    hash += Msgval_GetHash(key, key_info, 0);
+    hash += Msgval_GetHash(val, self->value_type_info, 0);
   }
 
   return LL2NUM(hash);
 }
 
 /*
- * call-seq:
- *     Map.to_h => {}
+ * ruby-doc: Map#to_h
  *
  * Returns a Ruby Hash object containing all the values within the map
+ *
+ * @return [Hash]
  */
 VALUE Map_to_h(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -669,12 +703,13 @@ VALUE Map_to_h(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.inspect => string
+ * ruby-doc: Map#inspect
  *
  * Returns a string representing this map's elements. It will be formatted as
  * "{key => value, key => value, ...}", with each key and value string
  * representation computed by its own #inspect method.
+ *
+ * @return [String]
  */
 VALUE Map_inspect(VALUE _self) {
   Map* self = ruby_to_Map(_self);
@@ -687,13 +722,15 @@ VALUE Map_inspect(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Map.merge(other_map) => map
+ * ruby-doc: Map#merge
  *
  * Copies key/value pairs from other_map into a copy of this map. If a key is
  * set in other_map and this map, the value from other_map overwrites the value
  * in the new copy of this map. Returns the new copy of this map with merged
  * contents.
+ *
+ * @param other_map [Map]
+ * @return [Map]
  */
 static VALUE Map_merge(VALUE _self, VALUE hashmap) {
   VALUE dupped = Map_dup(_self);