google-protobuf 3.14.0 → 4.26.1

data/ext/google/protobuf_c/message.h

@@ -0,0 +1,86 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 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
+
+#ifndef RUBY_PROTOBUF_MESSAGE_H_
+#define RUBY_PROTOBUF_MESSAGE_H_
+
+#include "protobuf.h"
+#include "ruby-upb.h"
+
+// Gets the underlying upb_Message* and upb_MessageDef for the given Ruby
+// message wrapper. Requires that |value| is indeed a message object.
+const upb_Message* Message_Get(VALUE value, const upb_MessageDef** m);
+
+// Like Message_Get(), but checks that the object is not frozen and returns a
+// mutable pointer.
+upb_Message* Message_GetMutable(VALUE value, const upb_MessageDef** m);
+
+// Returns the Arena object for this message.
+VALUE Message_GetArena(VALUE value);
+
+// Converts |value| into a upb_Message value of the expected upb_MessageDef
+// type, raising an error if this is not possible. Used when assigning |value|
+// to a field of another message, which means the message must be of a
+// particular type.
+//
+// This will perform automatic conversions in some cases (for example, Time ->
+// Google::Protobuf::Timestamp). If any new message is created, it will be
+// created on |arena|, and any existing message will have its arena fused with
+// |arena|.
+const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
+                                         const char* name, upb_Arena* arena);
+
+// Gets or constructs a Ruby wrapper object for the given message. The wrapper
+// object will reference |arena| and ensure that it outlives this object.
+VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
+                             VALUE arena);
+
+// Gets the given field from this message.
+VALUE Message_getfield(VALUE _self, const upb_FieldDef* f);
+
+// Implements #inspect for this message, printing the text to |b|.
+void Message_PrintMessage(StringBuilder* b, const upb_Message* msg,
+                          const upb_MessageDef* m);
+
+// Returns a hash value for the given message.
+uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
+                      uint64_t seed);
+
+// Returns a deep copy of the given message.
+upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
+                               upb_Arena* arena);
+
+// Returns true if these two messages are equal.
+bool Message_Equal(const upb_Message* m1, const upb_Message* m2,
+                   const upb_MessageDef* m);
+
+// Checks that this Ruby object is a message, and raises an exception if not.
+void Message_CheckClass(VALUE klass);
+
+// Returns a new Hash object containing the contents of this message.
+VALUE Scalar_CreateHash(upb_MessageValue val, TypeInfo type_info);
+
+// Creates a message class or enum module for this descriptor, respectively.
+VALUE build_class_from_descriptor(VALUE descriptor);
+VALUE build_module_from_enumdesc(VALUE _enumdesc);
+
+// Returns the Descriptor/EnumDescriptor for the given message class or enum
+// module, respectively. Returns nil if this is not a message class or enum
+// module.
+VALUE MessageOrEnum_GetDescriptor(VALUE klass);
+
+// Decodes a Message from a byte sequence.
+VALUE Message_decode_bytes(int size, const char* bytes, int options,
+                           VALUE klass, bool freeze);
+
+// Recursively freeze message
+VALUE Message_freeze(VALUE _self);
+
+// Call at startup to register all types in this module.
+void Message_register(VALUE protobuf);
+
+#endif  // RUBY_PROTOBUF_MESSAGE_H_

data/ext/google/protobuf_c/protobuf.c

@@ -1,91 +1,331 @@
 // 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 "protobuf.h"
 
-VALUE cError;
+#include <ruby/version.h>
+
+#include "defs.h"
+#include "map.h"
+#include "message.h"
+#include "repeated_field.h"
+
 VALUE cParseError;
 VALUE cTypeError;
-VALUE c_only_cookie = Qnil;
 
-static VALUE cached_empty_string = Qnil;
-static VALUE cached_empty_bytes = Qnil;
+const upb_FieldDef *map_field_key(const upb_FieldDef *field) {
+  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+  return upb_MessageDef_FindFieldByNumber(entry, 1);
+}
+
+const upb_FieldDef *map_field_value(const upb_FieldDef *field) {
+  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+  return upb_MessageDef_FindFieldByNumber(entry, 2);
+}
+
+// -----------------------------------------------------------------------------
+// StringBuilder, for inspect
+// -----------------------------------------------------------------------------
+
+struct StringBuilder {
+  size_t size;
+  size_t cap;
+  char *data;
+};
 
-static VALUE create_frozen_string(const char* str, size_t size, bool binary) {
-  VALUE str_rb = rb_str_new(str, size);
+typedef struct StringBuilder StringBuilder;
 
-  rb_enc_associate(str_rb,
-                   binary ? kRubyString8bitEncoding : kRubyStringUtf8Encoding);
-  rb_obj_freeze(str_rb);
-  return str_rb;
+static size_t StringBuilder_SizeOf(size_t cap) {
+  return sizeof(StringBuilder) + cap;
 }
 
-VALUE get_frozen_string(const char* str, size_t size, bool binary) {
-  if (size == 0) {
-    return binary ? cached_empty_bytes : cached_empty_string;
+StringBuilder *StringBuilder_New() {
+  const size_t cap = 128;
+  StringBuilder *builder = malloc(sizeof(*builder));
+  builder->size = 0;
+  builder->cap = cap;
+  builder->data = malloc(builder->cap);
+  return builder;
+}
+
+void StringBuilder_Free(StringBuilder *b) {
+  free(b->data);
+  free(b);
+}
+
+void StringBuilder_Printf(StringBuilder *b, const char *fmt, ...) {
+  size_t have = b->cap - b->size;
+  size_t n;
+  va_list args;
+
+  va_start(args, fmt);
+  n = vsnprintf(&b->data[b->size], have, fmt, args);
+  va_end(args);
+
+  if (have <= n) {
+    while (have <= n) {
+      b->cap *= 2;
+      have = b->cap - b->size;
+    }
+    b->data = realloc(b->data, StringBuilder_SizeOf(b->cap));
+    va_start(args, fmt);
+    n = vsnprintf(&b->data[b->size], have, fmt, args);
+    va_end(args);
+    PBRUBY_ASSERT(n < have);
+  }
+
+  b->size += n;
+}
+
+VALUE StringBuilder_ToRubyString(StringBuilder *b) {
+  VALUE ret = rb_str_new(b->data, b->size);
+  rb_enc_associate(ret, rb_utf8_encoding());
+  return ret;
+}
+
+static void StringBuilder_PrintEnum(StringBuilder *b, int32_t val,
+                                    const upb_EnumDef *e) {
+  const upb_EnumValueDef *ev = upb_EnumDef_FindValueByNumber(e, val);
+  if (ev) {
+    StringBuilder_Printf(b, ":%s", upb_EnumValueDef_Name(ev));
   } else {
-    // It is harder to memoize non-empty strings.  The obvious approach would be
-    // to use a Ruby hash keyed by string as memo table, but looking up in such a table
-    // requires constructing a string (the very thing we're trying to avoid).
-    //
-    // Since few fields have defaults, we will just optimize the empty string
-    // case for now.
-    return create_frozen_string(str, size, binary);
+    StringBuilder_Printf(b, "%" PRId32, val);
+  }
+}
+
+void StringBuilder_PrintMsgval(StringBuilder *b, upb_MessageValue val,
+                               TypeInfo info) {
+  switch (info.type) {
+    case kUpb_CType_Bool:
+      StringBuilder_Printf(b, "%s", val.bool_val ? "true" : "false");
+      break;
+    case kUpb_CType_Float: {
+      VALUE str = rb_inspect(DBL2NUM(val.float_val));
+      StringBuilder_Printf(b, "%s", RSTRING_PTR(str));
+      break;
+    }
+    case kUpb_CType_Double: {
+      VALUE str = rb_inspect(DBL2NUM(val.double_val));
+      StringBuilder_Printf(b, "%s", RSTRING_PTR(str));
+      break;
+    }
+    case kUpb_CType_Int32:
+      StringBuilder_Printf(b, "%" PRId32, val.int32_val);
+      break;
+    case kUpb_CType_UInt32:
+      StringBuilder_Printf(b, "%" PRIu32, val.uint32_val);
+      break;
+    case kUpb_CType_Int64:
+      StringBuilder_Printf(b, "%" PRId64, val.int64_val);
+      break;
+    case kUpb_CType_UInt64:
+      StringBuilder_Printf(b, "%" PRIu64, val.uint64_val);
+      break;
+    case kUpb_CType_String:
+      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size,
+                           val.str_val.data);
+      break;
+    case kUpb_CType_Bytes:
+      StringBuilder_Printf(b, "\"%.*s\"", (int)val.str_val.size,
+                           val.str_val.data);
+      break;
+    case kUpb_CType_Enum:
+      StringBuilder_PrintEnum(b, val.int32_val, info.def.enumdef);
+      break;
+    case kUpb_CType_Message:
+      Message_PrintMessage(b, val.msg_val, info.def.msgdef);
+      break;
   }
 }
 
 // -----------------------------------------------------------------------------
-// Utilities.
+// Arena
 // -----------------------------------------------------------------------------
 
-// Raises a Ruby error if |status| is not OK, using its error message.
-void check_upb_status(const upb_status* status, const char* msg) {
-  if (!upb_ok(status)) {
-    rb_raise(rb_eRuntimeError, "%s: %s\n", msg, upb_status_errmsg(status));
+typedef struct {
+  upb_Arena *arena;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  VALUE pinned_objs;
+} Arena;
+
+static void Arena_mark(void *data) {
+  Arena *arena = data;
+  rb_gc_mark(arena->pinned_objs);
+}
+
+static void Arena_free(void *data) {
+  Arena *arena = data;
+  upb_Arena_Free(arena->arena);
+  xfree(arena);
+}
+
+static size_t Arena_memsize(const void *data) {
+  const Arena *arena = data;
+  size_t fused_count;
+  size_t memsize = upb_Arena_SpaceAllocated(arena->arena, &fused_count);
+  if (fused_count > 1) {
+    // If other arena were fused we attribute an equal
+    // share of memory usage to each one.
+    memsize /= fused_count;
   }
+  return memsize + sizeof(Arena);
 }
 
-// String encodings: we look these up once, at load time, and then cache them
-// here.
-rb_encoding* kRubyStringUtf8Encoding;
-rb_encoding* kRubyStringASCIIEncoding;
-rb_encoding* kRubyString8bitEncoding;
+static VALUE cArena;
 
-// Ruby-interned string: "descriptor". We use this identifier to store an
-// instance variable on message classes we create in order to link them back to
-// their descriptors.
-//
-// We intern this once at module load time then use the interned identifier at
-// runtime in order to avoid the cost of repeatedly interning in hot paths.
-const char* kDescriptorInstanceVar = "descriptor";
-ID descriptor_instancevar_interned;
+const rb_data_type_t Arena_type = {
+    "Google::Protobuf::Internal::Arena",
+    {Arena_mark, Arena_free, Arena_memsize},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
+                                size_t size) {
+  if (size == 0) {
+    xfree(ptr);
+    return NULL;
+  } else {
+    return xrealloc(ptr, size);
+  }
+}
+
+upb_alloc ruby_upb_alloc = {&ruby_upb_allocfunc};
+
+static VALUE Arena_alloc(VALUE klass) {
+  Arena *arena = ALLOC(Arena);
+  arena->arena = upb_Arena_Init(NULL, 0, &ruby_upb_alloc);
+  arena->pinned_objs = Qnil;
+  return TypedData_Wrap_Struct(klass, &Arena_type, arena);
+}
+
+upb_Arena *Arena_get(VALUE _arena) {
+  Arena *arena;
+  TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
+  return arena->arena;
+}
+
+void Arena_fuse(VALUE _arena, upb_Arena *other) {
+  Arena *arena;
+  TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
+  if (!upb_Arena_Fuse(arena->arena, other)) {
+    rb_raise(rb_eRuntimeError,
+             "Unable to fuse arenas. This should never happen since Ruby does "
+             "not use initial blocks");
+  }
+}
+
+VALUE Arena_new() { return Arena_alloc(cArena); }
+
+void Arena_Pin(VALUE _arena, VALUE obj) {
+  Arena *arena;
+  TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
+  if (arena->pinned_objs == Qnil) {
+    RB_OBJ_WRITE(_arena, &arena->pinned_objs, rb_ary_new());
+  }
+  rb_ary_push(arena->pinned_objs, obj);
+}
+
+void Arena_register(VALUE module) {
+  VALUE internal = rb_define_module_under(module, "Internal");
+  VALUE klass = rb_define_class_under(internal, "Arena", rb_cObject);
+  rb_define_alloc_func(klass, Arena_alloc);
+  rb_gc_register_address(&cArena);
+  cArena = klass;
+}
+
+// -----------------------------------------------------------------------------
+// Object Cache
+// -----------------------------------------------------------------------------
+
+// Public ObjectCache API.
+
+VALUE weak_obj_cache = Qnil;
+ID item_get;
+ID item_try_add;
+
+static void ObjectCache_Init(VALUE protobuf) {
+  item_get = rb_intern("get");
+  item_try_add = rb_intern("try_add");
+
+  rb_gc_register_address(&weak_obj_cache);
+  VALUE internal = rb_const_get(protobuf, rb_intern("Internal"));
+#if SIZEOF_LONG >= SIZEOF_VALUE
+  VALUE cache_class = rb_const_get(internal, rb_intern("ObjectCache"));
+#else
+  VALUE cache_class = rb_const_get(internal, rb_intern("LegacyObjectCache"));
+#endif
+
+  weak_obj_cache = rb_class_new_instance(0, NULL, cache_class);
+  rb_const_set(internal, rb_intern("OBJECT_CACHE"), weak_obj_cache);
+  rb_const_set(internal, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
+  rb_const_set(internal, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
+}
+
+static VALUE ObjectCache_GetKey(const void *key) {
+  VALUE key_val = (VALUE)key;
+  PBRUBY_ASSERT((key_val & 3) == 0);
+  // Ensure the key can be stored as a Fixnum since 1 bit is needed for
+  // FIXNUM_FLAG and 1 bit is needed for the sign bit.
+  VALUE new_key = LL2NUM(key_val >> 2);
+  PBRUBY_ASSERT(FIXNUM_P(new_key));
+  return new_key;
+}
+
+VALUE ObjectCache_TryAdd(const void *key, VALUE val) {
+  VALUE key_val = ObjectCache_GetKey(key);
+  return rb_funcall(weak_obj_cache, item_try_add, 2, key_val, val);
+}
+
+// Returns the cached object for this key, if any. Otherwise returns Qnil.
+VALUE ObjectCache_Get(const void *key) {
+  VALUE key_val = ObjectCache_GetKey(key);
+  return rb_funcall(weak_obj_cache, item_get, 1, key_val);
+}
+
+/*
+ * call-seq:
+ *     Google::Protobuf.discard_unknown(msg)
+ *
+ * Discard unknown fields in the given message object and recursively discard
+ * unknown fields in submessages.
+ */
+static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
+  const upb_MessageDef *m;
+  upb_Message *msg = Message_GetMutable(msg_rb, &m);
+  if (!upb_Message_DiscardUnknown(msg, m, 128)) {
+    rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     Google::Protobuf.deep_copy(obj) => copy_of_obj
+ *
+ * Performs a deep copy of a RepeatedField instance, a Map instance, or a
+ * message object, recursively copying its members.
+ */
+VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
+  VALUE klass = CLASS_OF(obj);
+  if (klass == cRepeatedField) {
+    return RepeatedField_deep_copy(obj);
+  } else if (klass == cMap) {
+    return Map_deep_copy(obj);
+  } else {
+    VALUE new_arena_rb = Arena_new();
+    upb_Arena *new_arena = Arena_get(new_arena_rb);
+    const upb_MessageDef *m;
+    const upb_Message *msg = Message_Get(obj, &m);
+    upb_Message *new_msg = Message_deep_copy(msg, m, new_arena);
+    return Message_GetRubyWrapper(new_msg, m, new_arena_rb);
+  }
+}
 
 // -----------------------------------------------------------------------------
 // Initialization/entry point.
@@ -93,44 +333,24 @@ ID descriptor_instancevar_interned;
 
 // This must be named "Init_protobuf_c" because the Ruby module is named
 // "protobuf_c" -- the VM looks for this symbol in our .so.
-void Init_protobuf_c() {
+__attribute__((visibility("default"))) void Init_protobuf_c() {
   VALUE google = rb_define_module("Google");
   VALUE protobuf = rb_define_module_under(google, "Protobuf");
-  VALUE internal = rb_define_module_under(protobuf, "Internal");
-
-  descriptor_instancevar_interned = rb_intern(kDescriptorInstanceVar);
-  DescriptorPool_register(protobuf);
-  Descriptor_register(protobuf);
-  FileDescriptor_register(protobuf);
-  FieldDescriptor_register(protobuf);
-  OneofDescriptor_register(protobuf);
-  EnumDescriptor_register(protobuf);
-  MessageBuilderContext_register(internal);
-  OneofBuilderContext_register(internal);
-  EnumBuilderContext_register(internal);
-  FileBuilderContext_register(internal);
-  Builder_register(internal);
+
+  ObjectCache_Init(protobuf);
+  Arena_register(protobuf);
+  Defs_register(protobuf);
   RepeatedField_register(protobuf);
   Map_register(protobuf);
+  Message_register(protobuf);
 
-  cError = rb_const_get(protobuf, rb_intern("Error"));
   cParseError = rb_const_get(protobuf, rb_intern("ParseError"));
+  rb_gc_register_mark_object(cParseError);
   cTypeError = rb_const_get(protobuf, rb_intern("TypeError"));
+  rb_gc_register_mark_object(cTypeError);
 
   rb_define_singleton_method(protobuf, "discard_unknown",
                              Google_Protobuf_discard_unknown, 1);
-  rb_define_singleton_method(protobuf, "deep_copy",
-                             Google_Protobuf_deep_copy, 1);
-
-  kRubyStringUtf8Encoding = rb_utf8_encoding();
-  kRubyStringASCIIEncoding = rb_usascii_encoding();
-  kRubyString8bitEncoding = rb_ascii8bit_encoding();
-
-  rb_gc_register_address(&c_only_cookie);
-  c_only_cookie = rb_class_new_instance(0, NULL, rb_cObject);
-
-  rb_gc_register_address(&cached_empty_string);
-  rb_gc_register_address(&cached_empty_bytes);
-  cached_empty_string = create_frozen_string("", 0, false);
-  cached_empty_bytes = create_frozen_string("", 0, true);
+  rb_define_singleton_method(protobuf, "deep_copy", Google_Protobuf_deep_copy,
+                             1);
 }