google-protobuf 4.31.1-x86_64-linux-musl → 4.32.0.rc.1-x86_64-linux-musl

data/ext/google/protobuf_c/extconf.rb

@@ -28,17 +28,11 @@ else
   $CFLAGS += " -std=gnu99 #{additional_c_flags}"
 end
 
-if RUBY_PLATFORM =~ /linux/
-  # Instruct the linker to point memcpy calls at our __wrap_memcpy wrapper.
-  $LDFLAGS += " -Wl,-wrap,memcpy"
-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/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);
@@ -658,10 +691,11 @@ VALUE Map_hash(VALUE _self) {
 }
 
 /*
- * 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);

data/ext/google/protobuf_c/message.c

@@ -420,11 +420,10 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
 }
 
 /*
- * call-seq:
- *     Message.method_missing(*args)
+ * ruby-doc: AbstractMessage
  *
- * Provides accessors and setters and methods to clear and check for presence of
- * message fields according to their field names.
+ * The {AbstractMessage} class is the parent class for all Protobuf messages,
+ * and is generated from C code.
  *
  * For any field whose name does not conflict with a built-in method, an
  * accessor is provided with the same name as the field, and a setter is
@@ -653,16 +652,12 @@ void Message_InitFromValue(upb_Message* msg, const upb_MessageDef* m, VALUE val,
 }
 
 /*
- * call-seq:
- *     Message.new(kwargs) => new_message
+ * ruby-doc: AbstractMessage#initialize
  *
  * Creates a new instance of the given message class. Keyword arguments may be
  * provided with keywords corresponding to field names.
  *
- * Note that no literal Message class exists. Only concrete classes per message
- * type exist, as provided by the #msgclass method on Descriptors after they
- * have been added to a pool. The method definitions described here on the
- * Message class are provided on each concrete message class.
+ * @param kwargs the list of field keys and values.
  */
 static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -684,10 +679,11 @@ static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.dup => new_message
+ * ruby-doc: AbstractMessage#dup
  *
  * Performs a shallow copy of this message and returns the new copy.
+ *
+ * @return [AbstractMessage]
  */
 static VALUE Message_dup(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -700,13 +696,15 @@ static VALUE Message_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.==(other) => boolean
+ * ruby-doc: AbstractMessage#==
  *
  * Performs a deep comparison of this message with another. Messages are equal
  * if they have the same type and if each field is equal according to the :==
  * method's semantics (a more efficient comparison may actually be done if the
  * field is of a primitive type).
+ *
+ * @param other [AbstractMessage]
+ * @return [Boolean]
  */
 static VALUE Message_eq(VALUE _self, VALUE _other) {
   if (CLASS_OF(_self) != CLASS_OF(_other)) return Qfalse;
@@ -735,10 +733,11 @@ uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
 }
 
 /*
- * call-seq:
- *     Message.hash => hash_value
+ * ruby-doc: AbstractMessage#hash
  *
  * Returns a hash value that represents this message's field values.
+ *
+ * @return [Integer]
  */
 static VALUE Message_hash(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -749,12 +748,13 @@ static VALUE Message_hash(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.inspect => string
+ * ruby-doc: AbstractMessage#inspect
  *
  * Returns a human-readable string representing this message. It will be
  * formatted as "<MessageType: field1: value1, field2: value2, ...>". Each
  * field's value is represented according to its own #inspect method.
+ *
+ * @return [String]
  */
 static VALUE Message_inspect(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -830,10 +830,11 @@ VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
 }
 
 /*
- * call-seq:
- *     Message.to_h => {}
+ * ruby-doc: AbstractMessage#to_h
  *
  * Returns the message as a Ruby Hash object, with keys as symbols.
+ *
+ * @return [Hash]
  */
 static VALUE Message_to_h(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -841,12 +842,13 @@ static VALUE Message_to_h(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.frozen? => bool
+ * ruby-doc: AbstractMessage#frozen?
  *
  * Returns true if the message is frozen in either Ruby or the underlying
  * representation. Freezes the Ruby message object if it is not already frozen
  * in Ruby but it is frozen in the underlying representation.
+ *
+ * @return [Boolean]
  */
 VALUE Message_frozen(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -861,11 +863,12 @@ VALUE Message_frozen(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.freeze => self
+ * ruby-doc: AbstractMessage#freeze
  *
  * Freezes the message object. We have to intercept this so we can freeze the
  * underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
 VALUE Message_freeze(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -882,11 +885,13 @@ VALUE Message_freeze(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.[](index) => value
+ * ruby-doc: AbstractMessage#[]
  *
  * Accesses a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @return [Object]
  */
 static VALUE Message_index(VALUE _self, VALUE field_name) {
   Message* self = ruby_to_Message(_self);
@@ -903,11 +908,14 @@ static VALUE Message_index(VALUE _self, VALUE field_name) {
 }
 
 /*
- * call-seq:
- *     Message.[]=(index, value)
+ * ruby-doc: AbstractMessage#[]=
  *
  * Sets a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @param value [Object]
+ * @return [nil]
  */
 static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
   Message* self = ruby_to_Message(_self);
@@ -929,14 +937,16 @@ static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
 }
 
 /*
- * call-seq:
- *     MessageClass.decode(data, options) => message
+ * ruby-doc: AbstractMessage.decode
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretation given by this message class's definition
  * and returns a message object with the corresponding field values.
- * @param options [Hash] options for the decoder
- *  recursion_limit: set to maximum decoding depth for message (default is 64)
+ * @param data [String]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum decoding depth for message
+ * (default is 64)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -989,16 +999,17 @@ VALUE Message_decode_bytes(int size, const char* bytes, int options,
 }
 
 /*
- * call-seq:
- *     MessageClass.decode_json(data, options = {}) => message
+ * ruby-doc: AbstractMessage.decode_json
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretration given by this message class's definition
  * and returns a message object with the corresponding field values.
  *
- *  @param options [Hash] options for the decoder
- *   ignore_unknown_fields: set true to ignore unknown fields (default is to
- *   raise an error)
+ * @param data [String]
+ * @param options [Hash]
+ * @option ignore_unknown_fields [Boolean] set true to ignore unknown fields
+ * (default is to raise an error)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -1057,13 +1068,16 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode(msg, options) => bytes
+ * ruby-doc: AbstractMessage.encode
  *
  * Encodes the given message object to its serialized form in protocol buffers
  * wire format.
- * @param options [Hash] options for the encoder
- *  recursion_limit: set to maximum encoding depth for message (default is 64)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum encoding depth for message
+ * (default is 64)
+ * @return [String]
  */
 static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1110,14 +1124,17 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode_json(msg, options = {}) => json_string
+ * ruby-doc: AbstractMessage.encode_json
  *
  * Encodes the given message object into its serialized JSON representation.
- * @param options [Hash] options for the decoder
- *  preserve_proto_fieldnames: set true to use original fieldnames (default is
- * to camelCase) emit_defaults: set true to emit 0/false values (default is to
- * omit them)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option preserve_proto_fieldnames [Boolean] set true to use original
+ * fieldnames (default is to camelCase)
+ * @option emit_defaults [Boolean] set true to emit 0/false values (default is
+ * to omit them)
+ * @return [String]
  */
 static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1185,11 +1202,12 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     Message.descriptor => descriptor
+ * ruby-doc: AbstractMessage.descriptor
  *
  * Class method that returns the Descriptor instance corresponding to this
  * message class's type.
+ *
+ * @return [Descriptor]
  */
 static VALUE Message_descriptor(VALUE klass) {
   return rb_ivar_get(klass, descriptor_instancevar_interned);
@@ -1212,12 +1230,26 @@ VALUE build_class_from_descriptor(VALUE descriptor) {
   return klass;
 }
 
+/* ruby-doc: Enum
+ *
+ * There isn't really a concrete `Enum` module generated by Protobuf. Instead,
+ * you can use this documentation as an indicator of methods that are defined on
+ * each `Enum` module that is generated. E.g. if you have:
+ *
+ *   enum my_enum_type
+ *
+ * in your Proto file and generate Ruby code, a module
+ * called `MyEnumType` will be generated with the following methods available.
+ */
+
 /*
- * call-seq:
- *     Enum.lookup(number) => name
+ * ruby-doc: Enum.lookup
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by number and returns its name as a Ruby symbol, or nil if not found.
+ *
+ * @param number [Integer]
+ * @return [String]
  */
 static VALUE enum_lookup(VALUE self, VALUE number) {
   int32_t num = NUM2INT(number);
@@ -1232,11 +1264,13 @@ static VALUE enum_lookup(VALUE self, VALUE number) {
 }
 
 /*
- * call-seq:
- *     Enum.resolve(name) => number
+ * ruby-doc: Enum.resolve
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by name (as a Ruby symbol) and returns its name, or nil if not found.
+ *
+ * @param name [String]
+ * @return [Integer]
  */
 static VALUE enum_resolve(VALUE self, VALUE sym) {
   const char* name = rb_id2name(SYM2ID(sym));
@@ -1251,11 +1285,13 @@ static VALUE enum_resolve(VALUE self, VALUE sym) {
 }
 
 /*
- * call-seq:
- *     Enum.descriptor
+ * ruby-doc: Enum.descriptor
  *
  * This module method, provided on each generated enum module, returns the
- * EnumDescriptor corresponding to this enum type.
+ * {EnumDescriptor} corresponding to this enum type.
+ *
+ * @return [EnumDescriptor]
+ *
  */
 static VALUE enum_descriptor(VALUE self) {
   return rb_ivar_get(self, descriptor_instancevar_interned);

data/ext/google/protobuf_c/protobuf.c

@@ -183,7 +183,7 @@ const rb_data_type_t Arena_type = {
 };
 
 static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
-                                size_t size) {
+                                size_t size, size_t *actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;

data/ext/google/protobuf_c/protobuf.h

@@ -97,6 +97,4 @@ void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen);
 
 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
-#define UPB_UNUSED(var) (void)var
-
 #endif  // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__