Roll forward Ruby upb changes now that protobuf Ruby build is fixed (#5866)
* Rolled forward again with "Updated upb from defcleanup branch..."
Revert "Revert "Updated upb from defcleanup branch and modified Ruby to use it (#5539)" (#5848)"
This reverts commit 1568deab40db055a79fa415d21547eaffbd56d57.
* A few more merge fixes.
* Updated for defcleanup2 branch.
* Fixed upb to define upb_decode().
* Fixed names of nested messages.
* Revert submodule.
* Set -std=gnu90 and fixed warnings/errors.
Some of our Kokoro tests seem to run with this level of warnings,
and the source strives to be gnu90 compatible. Enforcing it for
every build removes the possibility of some errors showing up in
Kokoro/Travis tests only.
* Fixed remaining warnings with gnu90 mode.
I tried to match warning flags with what Ruby appears to do
in our Kokoro tests.
* Initialize values registered by rb_gc_register_address().
* Fixed subtle GC bug.
We need to initialize this marked value before creating the instance.
* Truly fix the GC bug.
* Updated upb for mktime() fix.
* Removed XOPEN_SOURCE as we are not using strptime().
* Removed fixed tests from the conformance failure list for Ruby.
* Fixed memory error related to oneof def names.
* Picked up new upb changes re: JSON printing.
* Uncomment concurrent decoding test.
diff --git a/ruby/ext/google/protobuf_c/defs.c b/ruby/ext/google/protobuf_c/defs.c
index 49c2ba6..77ef5e5 100644
--- a/ruby/ext/google/protobuf_c/defs.c
+++ b/ruby/ext/google/protobuf_c/defs.c
@@ -28,6 +28,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <ctype.h>
+#include <errno.h>
#include "protobuf.h"
// -----------------------------------------------------------------------------
@@ -46,29 +48,290 @@
return rb_str_new2(s);
}
-static upb_def* check_notfrozen(const upb_def* def) {
- if (upb_def_isfrozen(def)) {
- rb_raise(rb_eRuntimeError,
- "Attempt to modify a frozen descriptor. Once descriptors are "
- "added to the descriptor pool, they may not be modified.");
+static void rewrite_enum_default(const upb_symtab* symtab,
+ google_protobuf_FileDescriptorProto* file,
+ google_protobuf_FieldDescriptorProto* field) {
+ upb_strview defaultval;
+ const char *type_name_str;
+ char *end;
+ long val;
+ const upb_enumdef *e;
+ upb_strview type_name;
+
+ /* Look for TYPE_ENUM fields that have a default. */
+ if (google_protobuf_FieldDescriptorProto_type(field) !=
+ google_protobuf_FieldDescriptorProto_TYPE_ENUM ||
+ !google_protobuf_FieldDescriptorProto_has_default_value(field) ||
+ !google_protobuf_FieldDescriptorProto_has_type_name(field)) {
+ return;
}
- return (upb_def*)def;
+
+ defaultval = google_protobuf_FieldDescriptorProto_default_value(field);
+ type_name = google_protobuf_FieldDescriptorProto_type_name(field);
+
+ if (defaultval.size == 0 || !isdigit(defaultval.data[0])) {
+ return;
+ }
+
+ if (type_name.size == 0 || type_name.data[0] != '.') {
+ return;
+ }
+
+ type_name_str = type_name.data + 1;
+
+ errno = 0;
+ val = strtol(defaultval.data, &end, 10);
+
+ if (errno != 0 || *end != 0 || val < INT32_MIN || val > INT32_MAX) {
+ return;
+ }
+
+ /* Now find the corresponding enum definition. */
+ e = upb_symtab_lookupenum(symtab, type_name_str);
+ if (e) {
+ /* Look in previously loaded files. */
+ const char *label = upb_enumdef_iton(e, val);
+ if (!label) {
+ return;
+ }
+ google_protobuf_FieldDescriptorProto_set_default_value(
+ field, upb_strview_makez(label));
+ } else {
+ /* Look in enums defined in this file. */
+ const google_protobuf_EnumDescriptorProto* matching_enum = NULL;
+ size_t i, n;
+ const google_protobuf_EnumDescriptorProto* const* enums =
+ google_protobuf_FileDescriptorProto_enum_type(file, &n);
+ const google_protobuf_EnumValueDescriptorProto* const* values;
+
+ for (i = 0; i < n; i++) {
+ if (upb_strview_eql(google_protobuf_EnumDescriptorProto_name(enums[i]),
+ upb_strview_makez(type_name_str))) {
+ matching_enum = enums[i];
+ break;
+ }
+ }
+
+ if (!matching_enum) {
+ return;
+ }
+
+ values = google_protobuf_EnumDescriptorProto_value(matching_enum, &n);
+ for (i = 0; i < n; i++) {
+ if (google_protobuf_EnumValueDescriptorProto_number(values[i]) == val) {
+ google_protobuf_FieldDescriptorProto_set_default_value(
+ field, google_protobuf_EnumValueDescriptorProto_name(values[i]));
+ return;
+ }
+ }
+
+ /* We failed to find an enum default. But we'll just leave the enum
+ * untouched and let the normal def-building code catch it. */
+ }
}
-static upb_msgdef* check_msg_notfrozen(const upb_msgdef* def) {
- return upb_downcast_msgdef_mutable(check_notfrozen((const upb_def*)def));
+/* Historically we allowed enum defaults to be specified as a number. In
+ * retrospect this was a mistake as descriptors require defaults to be
+ * specified as a label. This can make a difference if multiple labels have the
+ * same number.
+ *
+ * Here we do a pass over all enum defaults and rewrite numeric defaults by
+ * looking up their labels. This is compilcated by the fact that the enum
+ * definition can live in either the symtab or the file_proto.
+ * */
+static void rewrite_enum_defaults(
+ const upb_symtab* symtab, google_protobuf_FileDescriptorProto* file_proto) {
+ size_t i, n;
+ google_protobuf_DescriptorProto** msgs =
+ google_protobuf_FileDescriptorProto_mutable_message_type(file_proto, &n);
+
+ for (i = 0; i < n; i++) {
+ size_t j, m;
+ google_protobuf_FieldDescriptorProto** fields =
+ google_protobuf_DescriptorProto_mutable_field(msgs[i], &m);
+ for (j = 0; j < m; j++) {
+ rewrite_enum_default(symtab, file_proto, fields[j]);
+ }
+ }
}
-static upb_fielddef* check_field_notfrozen(const upb_fielddef* def) {
- return upb_downcast_fielddef_mutable(check_notfrozen((const upb_def*)def));
+static void remove_path(upb_strview *name) {
+ const char* last = strrchr(name->data, '.');
+ if (last) {
+ size_t remove = last - name->data + 1;
+ name->data += remove;
+ name->size -= remove;
+ }
}
-static upb_oneofdef* check_oneof_notfrozen(const upb_oneofdef* def) {
- return (upb_oneofdef*)check_notfrozen((const upb_def*)def);
+static void rewrite_nesting(VALUE msg_ent, google_protobuf_DescriptorProto* msg,
+ google_protobuf_DescriptorProto* const* msgs,
+ google_protobuf_EnumDescriptorProto* const* enums,
+ upb_arena *arena) {
+ VALUE submsgs = rb_hash_aref(msg_ent, ID2SYM(rb_intern("msgs")));
+ VALUE enum_pos = rb_hash_aref(msg_ent, ID2SYM(rb_intern("enums")));
+ int submsg_count;
+ int enum_count;
+ int i;
+ google_protobuf_DescriptorProto** msg_msgs;
+ google_protobuf_EnumDescriptorProto** msg_enums;
+
+ Check_Type(submsgs, T_ARRAY);
+ Check_Type(enum_pos, T_ARRAY);
+
+ submsg_count = RARRAY_LEN(submsgs);
+ enum_count = RARRAY_LEN(enum_pos);
+
+ msg_msgs = google_protobuf_DescriptorProto_resize_nested_type(
+ msg, submsg_count, arena);
+ msg_enums =
+ google_protobuf_DescriptorProto_resize_enum_type(msg, enum_count, arena);
+
+ for (i = 0; i < submsg_count; i++) {
+ VALUE submsg_ent = RARRAY_PTR(submsgs)[i];
+ VALUE pos = rb_hash_aref(submsg_ent, ID2SYM(rb_intern("pos")));
+ upb_strview name;
+
+ msg_msgs[i] = msgs[NUM2INT(pos)];
+ name = google_protobuf_DescriptorProto_name(msg_msgs[i]);
+ remove_path(&name);
+ google_protobuf_DescriptorProto_set_name(msg_msgs[i], name);
+ rewrite_nesting(submsg_ent, msg_msgs[i], msgs, enums, arena);
+ }
+
+ for (i = 0; i < enum_count; i++) {
+ VALUE pos = RARRAY_PTR(enum_pos)[i];
+ msg_enums[i] = enums[NUM2INT(pos)];
+ }
}
-static upb_enumdef* check_enum_notfrozen(const upb_enumdef* def) {
- return (upb_enumdef*)check_notfrozen((const upb_def*)def);
+/* We have to do some relatively complicated logic here for backward
+ * compatibility.
+ *
+ * In descriptor.proto, messages are nested inside other messages if that is
+ * what the original .proto file looks like. For example, suppose we have this
+ * foo.proto:
+ *
+ * package foo;
+ * message Bar {
+ * message Baz {}
+ * }
+ *
+ * The descriptor for this must look like this:
+ *
+ * file {
+ * name: "test.proto"
+ * package: "foo"
+ * message_type {
+ * name: "Bar"
+ * nested_type {
+ * name: "Baz"
+ * }
+ * }
+ * }
+ *
+ * However, the Ruby generated code has always generated messages in a flat,
+ * non-nested way:
+ *
+ * Google::Protobuf::DescriptorPool.generated_pool.build do
+ * add_message "foo.Bar" do
+ * end
+ * add_message "foo.Bar.Baz" do
+ * end
+ * end
+ *
+ * Here we need to do a translation where we turn this generated code into the
+ * above descriptor. We need to infer that "foo" is the package name, and not
+ * a message itself.
+ *
+ * We delegate to Ruby to compute the transformation, for more concice and
+ * readable code than we can do in C */
+static void rewrite_names(VALUE _file_builder,
+ google_protobuf_FileDescriptorProto* file_proto) {
+ FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+ upb_arena *arena = file_builder->arena;
+ // Build params (package, msg_names, enum_names).
+ VALUE package = Qnil;
+ VALUE msg_names = rb_ary_new();
+ VALUE enum_names = rb_ary_new();
+ size_t msg_count, enum_count, i;
+ VALUE new_package, nesting, msg_ents, enum_ents;
+ google_protobuf_DescriptorProto** msgs;
+ google_protobuf_EnumDescriptorProto** enums;
+
+ if (google_protobuf_FileDescriptorProto_has_package(file_proto)) {
+ upb_strview package_str =
+ google_protobuf_FileDescriptorProto_package(file_proto);
+ package = rb_str_new(package_str.data, package_str.size);
+ }
+
+ msgs = google_protobuf_FileDescriptorProto_mutable_message_type(file_proto,
+ &msg_count);
+ for (i = 0; i < msg_count; i++) {
+ upb_strview name = google_protobuf_DescriptorProto_name(msgs[i]);
+ rb_ary_push(msg_names, rb_str_new(name.data, name.size));
+ }
+
+ enums = google_protobuf_FileDescriptorProto_mutable_enum_type(file_proto,
+ &enum_count);
+ for (i = 0; i < enum_count; i++) {
+ upb_strview name = google_protobuf_EnumDescriptorProto_name(enums[i]);
+ rb_ary_push(enum_names, rb_str_new(name.data, name.size));
+ }
+
+ {
+ // Call Ruby code to calculate package name and nesting.
+ VALUE args[3] = { package, msg_names, enum_names };
+ VALUE internal = rb_eval_string("Google::Protobuf::Internal");
+ VALUE ret = rb_funcallv(internal, rb_intern("fixup_descriptor"), 3, args);
+
+ new_package = rb_ary_entry(ret, 0);
+ nesting = rb_ary_entry(ret, 1);
+ }
+
+ // Rewrite package and names.
+ if (new_package != Qnil) {
+ upb_strview new_package_str =
+ FileBuilderContext_strdup(_file_builder, new_package);
+ google_protobuf_FileDescriptorProto_set_package(file_proto,
+ new_package_str);
+ }
+
+ for (i = 0; i < msg_count; i++) {
+ upb_strview name = google_protobuf_DescriptorProto_name(msgs[i]);
+ remove_path(&name);
+ google_protobuf_DescriptorProto_set_name(msgs[i], name);
+ }
+
+ for (i = 0; i < enum_count; i++) {
+ upb_strview name = google_protobuf_EnumDescriptorProto_name(enums[i]);
+ remove_path(&name);
+ google_protobuf_EnumDescriptorProto_set_name(enums[i], name);
+ }
+
+ // Rewrite nesting.
+ msg_ents = rb_hash_aref(nesting, ID2SYM(rb_intern("msgs")));
+ enum_ents = rb_hash_aref(nesting, ID2SYM(rb_intern("enums")));
+
+ Check_Type(msg_ents, T_ARRAY);
+ Check_Type(enum_ents, T_ARRAY);
+
+ for (i = 0; i < (size_t)RARRAY_LEN(msg_ents); i++) {
+ VALUE msg_ent = rb_ary_entry(msg_ents, i);
+ VALUE pos = rb_hash_aref(msg_ent, ID2SYM(rb_intern("pos")));
+ msgs[i] = msgs[NUM2INT(pos)];
+ rewrite_nesting(msg_ent, msgs[i], msgs, enums, arena);
+ }
+
+ for (i = 0; i < (size_t)RARRAY_LEN(enum_ents); i++) {
+ VALUE enum_pos = rb_ary_entry(enum_ents, i);
+ enums[i] = enums[NUM2INT(enum_pos)];
+ }
+
+ google_protobuf_FileDescriptorProto_resize_message_type(
+ file_proto, RARRAY_LEN(msg_ents), arena);
+ google_protobuf_FileDescriptorProto_resize_enum_type(
+ file_proto, RARRAY_LEN(enum_ents), arena);
}
// -----------------------------------------------------------------------------
@@ -92,16 +355,26 @@
// Global singleton DescriptorPool. The user is free to create others, but this
// is used by generated code.
-VALUE generated_pool;
+VALUE generated_pool = Qnil;
DEFINE_CLASS(DescriptorPool, "Google::Protobuf::DescriptorPool");
void DescriptorPool_mark(void* _self) {
+ DescriptorPool* self = _self;
+ rb_gc_mark(self->def_to_descriptor);
}
void DescriptorPool_free(void* _self) {
DescriptorPool* self = _self;
+
upb_symtab_free(self->symtab);
+ upb_handlercache_free(self->fill_handler_cache);
+ upb_handlercache_free(self->pb_serialize_handler_cache);
+ upb_handlercache_free(self->json_serialize_handler_cache);
+ upb_handlercache_free(self->json_serialize_handler_preserve_cache);
+ upb_pbcodecache_free(self->fill_method_cache);
+ upb_json_codecache_free(self->json_fill_method_cache);
+
xfree(self);
}
@@ -113,15 +386,29 @@
*/
VALUE DescriptorPool_alloc(VALUE klass) {
DescriptorPool* self = ALLOC(DescriptorPool);
+ VALUE ret;
+
+ self->def_to_descriptor = Qnil;
+ ret = TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
+
+ self->def_to_descriptor = rb_hash_new();
self->symtab = upb_symtab_new();
- return TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
+ self->fill_handler_cache =
+ upb_handlercache_new(add_handlers_for_message, (void*)ret);
+ self->pb_serialize_handler_cache = upb_pb_encoder_newcache();
+ self->json_serialize_handler_cache = upb_json_printer_newcache(false);
+ self->json_serialize_handler_preserve_cache =
+ upb_json_printer_newcache(true);
+ self->fill_method_cache = upb_pbcodecache_new(self->fill_handler_cache);
+ self->json_fill_method_cache = upb_json_codecache_new();
+
+ return ret;
}
void DescriptorPool_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "DescriptorPool", rb_cObject);
rb_define_alloc_func(klass, DescriptorPool_alloc);
- rb_define_method(klass, "add", DescriptorPool_add, 1);
rb_define_method(klass, "build", DescriptorPool_build, -1);
rb_define_method(klass, "lookup", DescriptorPool_lookup, 1);
rb_define_singleton_method(klass, "generated_pool",
@@ -133,44 +420,6 @@
generated_pool = rb_class_new_instance(0, NULL, klass);
}
-static void add_descriptor_to_pool(DescriptorPool* self,
- Descriptor* descriptor) {
- CHECK_UPB(
- upb_symtab_add(self->symtab, (upb_def**)&descriptor->msgdef, 1,
- NULL, &status),
- "Adding Descriptor to DescriptorPool failed");
-}
-
-static void add_enumdesc_to_pool(DescriptorPool* self,
- EnumDescriptor* enumdesc) {
- CHECK_UPB(
- upb_symtab_add(self->symtab, (upb_def**)&enumdesc->enumdef, 1,
- NULL, &status),
- "Adding EnumDescriptor to DescriptorPool failed");
-}
-
-/*
- * call-seq:
- * DescriptorPool.add(descriptor)
- *
- * Adds the given Descriptor or EnumDescriptor to this pool. All references to
- * other types in a Descriptor's fields must be resolvable within this pool or
- * an exception will be raised.
- */
-VALUE DescriptorPool_add(VALUE _self, VALUE def) {
- DEFINE_SELF(DescriptorPool, self, _self);
- VALUE def_klass = rb_obj_class(def);
- if (def_klass == cDescriptor) {
- add_descriptor_to_pool(self, ruby_to_Descriptor(def));
- } else if (def_klass == cEnumDescriptor) {
- add_enumdesc_to_pool(self, ruby_to_EnumDescriptor(def));
- } else {
- rb_raise(rb_eArgError,
- "Second argument must be a Descriptor or EnumDescriptor.");
- }
- return Qnil;
-}
-
/*
* call-seq:
* DescriptorPool.build(&block)
@@ -182,10 +431,10 @@
* idiomatic way to define new message and enum types.
*/
VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
- VALUE ctx = rb_class_new_instance(0, NULL, cBuilder);
+ VALUE ctx = rb_class_new_instance(1, &_self, cBuilder);
VALUE block = rb_block_proc();
rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- rb_funcall(ctx, rb_intern("finalize_to_pool"), 1, _self);
+ Builder_build(ctx);
return Qnil;
}
@@ -199,11 +448,20 @@
VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
DEFINE_SELF(DescriptorPool, self, _self);
const char* name_str = get_str(name);
- const upb_def* def = upb_symtab_lookup(self->symtab, name_str);
- if (!def) {
- return Qnil;
+ const upb_msgdef* msgdef;
+ const upb_enumdef* enumdef;
+
+ msgdef = upb_symtab_lookupmsg(self->symtab, name_str);
+ if (msgdef) {
+ return get_msgdef_obj(_self, msgdef);
}
- return get_def_obj(def);
+
+ enumdef = upb_symtab_lookupenum(self->symtab, name_str);
+ if (enumdef) {
+ return get_enumdef_obj(_self, enumdef);
+ }
+
+ return Qnil;
}
/*
@@ -228,36 +486,14 @@
void Descriptor_mark(void* _self) {
Descriptor* self = _self;
rb_gc_mark(self->klass);
+ rb_gc_mark(self->descriptor_pool);
}
void Descriptor_free(void* _self) {
Descriptor* self = _self;
- upb_msgdef_unref(self->msgdef, &self->msgdef);
if (self->layout) {
free_layout(self->layout);
}
- if (self->fill_handlers) {
- upb_handlers_unref(self->fill_handlers, &self->fill_handlers);
- }
- if (self->fill_method) {
- upb_pbdecodermethod_unref(self->fill_method, &self->fill_method);
- }
- if (self->json_fill_method) {
- upb_json_parsermethod_unref(self->json_fill_method,
- &self->json_fill_method);
- }
- if (self->pb_serialize_handlers) {
- upb_handlers_unref(self->pb_serialize_handlers,
- &self->pb_serialize_handlers);
- }
- if (self->json_serialize_handlers) {
- upb_handlers_unref(self->json_serialize_handlers,
- &self->json_serialize_handlers);
- }
- if (self->json_serialize_handlers_preserve) {
- upb_handlers_unref(self->json_serialize_handlers_preserve,
- &self->json_serialize_handlers_preserve);
- }
xfree(self);
}
@@ -273,15 +509,10 @@
VALUE Descriptor_alloc(VALUE klass) {
Descriptor* self = ALLOC(Descriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_Descriptor_type, self);
- self->msgdef = upb_msgdef_new(&self->msgdef);
+ self->msgdef = NULL;
self->klass = Qnil;
+ self->descriptor_pool = Qnil;
self->layout = NULL;
- self->fill_handlers = NULL;
- self->fill_method = NULL;
- self->json_fill_method = NULL;
- self->pb_serialize_handlers = NULL;
- self->json_serialize_handlers = NULL;
- self->json_serialize_handlers_preserve = NULL;
return ret;
}
@@ -289,16 +520,13 @@
VALUE klass = rb_define_class_under(
module, "Descriptor", rb_cObject);
rb_define_alloc_func(klass, Descriptor_alloc);
- rb_define_method(klass, "initialize", Descriptor_initialize, 1);
+ rb_define_method(klass, "initialize", Descriptor_initialize, 3);
rb_define_method(klass, "each", Descriptor_each, 0);
rb_define_method(klass, "lookup", Descriptor_lookup, 1);
- rb_define_method(klass, "add_field", Descriptor_add_field, 1);
- rb_define_method(klass, "add_oneof", Descriptor_add_oneof, 1);
rb_define_method(klass, "each_oneof", Descriptor_each_oneof, 0);
rb_define_method(klass, "lookup_oneof", Descriptor_lookup_oneof, 1);
rb_define_method(klass, "msgclass", Descriptor_msgclass, 0);
rb_define_method(klass, "name", Descriptor_name, 0);
- rb_define_method(klass, "name=", Descriptor_name_set, 1);
rb_define_method(klass, "file_descriptor", Descriptor_file_descriptor, 0);
rb_include_module(klass, rb_mEnumerable);
rb_gc_register_address(&cDescriptor);
@@ -307,19 +535,21 @@
/*
* call-seq:
- * Descriptor.new(file_descriptor)
+ * Descriptor.new(c_only_cookie, ptr) => Descriptor
*
- * Initializes a new descriptor and assigns a file descriptor to it.
+ * Creates a descriptor wrapper object. May only be called from C.
*/
-VALUE Descriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
+VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
+ VALUE descriptor_pool, VALUE ptr) {
DEFINE_SELF(Descriptor, self, _self);
- FileDescriptor* file_descriptor = ruby_to_FileDescriptor(file_descriptor_rb);
+ if (cookie != c_only_cookie) {
+ rb_raise(rb_eRuntimeError,
+ "Descriptor objects may not be created from Ruby.");
+ }
- CHECK_UPB(
- upb_filedef_addmsg(file_descriptor->filedef, self->msgdef, NULL, &status),
- "Failed to associate message to file descriptor.");
- add_def_obj(file_descriptor->filedef, file_descriptor_rb);
+ self->descriptor_pool = descriptor_pool;
+ self->msgdef = (const upb_msgdef*)NUM2ULL(ptr);
return Qnil;
}
@@ -332,7 +562,7 @@
*/
VALUE Descriptor_file_descriptor(VALUE _self) {
DEFINE_SELF(Descriptor, self, _self);
- return get_def_obj(upb_def_file(self->msgdef));
+ return get_filedef_obj(self->descriptor_pool, upb_msgdef_file(self->msgdef));
}
/*
@@ -349,23 +579,6 @@
/*
* call-seq:
- * Descriptor.name = name
- *
- * Assigns a name to this message type. The descriptor must not have been added
- * to a pool yet.
- */
-VALUE Descriptor_name_set(VALUE _self, VALUE str) {
- DEFINE_SELF(Descriptor, self, _self);
- upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
- const char* name = get_str(str);
- CHECK_UPB(
- upb_msgdef_setfullname(mut_def, name, &status),
- "Error setting Descriptor name");
- return Qnil;
-}
-
-/*
- * call-seq:
* Descriptor.each(&block)
*
* Iterates over fields in this message type, yielding to the block on each one.
@@ -378,7 +591,7 @@
!upb_msg_field_done(&it);
upb_msg_field_next(&it)) {
const upb_fielddef* field = upb_msg_iter_field(&it);
- VALUE obj = get_def_obj(field);
+ VALUE obj = get_fielddef_obj(self->descriptor_pool, field);
rb_yield(obj);
}
return Qnil;
@@ -398,51 +611,7 @@
if (field == NULL) {
return Qnil;
}
- return get_def_obj(field);
-}
-
-/*
- * call-seq:
- * Descriptor.add_field(field) => nil
- *
- * Adds the given FieldDescriptor to this message type. This descriptor must not
- * have been added to a pool yet. Raises an exception if a field with the same
- * name or number already exists. Sub-type references (e.g. for fields of type
- * message) are not resolved at this point.
- */
-VALUE Descriptor_add_field(VALUE _self, VALUE obj) {
- DEFINE_SELF(Descriptor, self, _self);
- upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
- FieldDescriptor* def = ruby_to_FieldDescriptor(obj);
- upb_fielddef* mut_field_def = check_field_notfrozen(def->fielddef);
- CHECK_UPB(
- upb_msgdef_addfield(mut_def, mut_field_def, NULL, &status),
- "Adding field to Descriptor failed");
- add_def_obj(def->fielddef, obj);
- return Qnil;
-}
-
-/*
- * call-seq:
- * Descriptor.add_oneof(oneof) => nil
- *
- * Adds the given OneofDescriptor to this message type. This descriptor must not
- * have been added to a pool yet. Raises an exception if a oneof with the same
- * name already exists, or if any of the oneof's fields' names or numbers
- * conflict with an existing field in this message type. All fields in the oneof
- * are added to the message descriptor. Sub-type references (e.g. for fields of
- * type message) are not resolved at this point.
- */
-VALUE Descriptor_add_oneof(VALUE _self, VALUE obj) {
- DEFINE_SELF(Descriptor, self, _self);
- upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
- OneofDescriptor* def = ruby_to_OneofDescriptor(obj);
- upb_oneofdef* mut_oneof_def = check_oneof_notfrozen(def->oneofdef);
- CHECK_UPB(
- upb_msgdef_addoneof(mut_def, mut_oneof_def, NULL, &status),
- "Adding oneof to Descriptor failed");
- add_def_obj(def->oneofdef, obj);
- return Qnil;
+ return get_fielddef_obj(self->descriptor_pool, field);
}
/*
@@ -460,7 +629,7 @@
!upb_msg_oneof_done(&it);
upb_msg_oneof_next(&it)) {
const upb_oneofdef* oneof = upb_msg_iter_oneof(&it);
- VALUE obj = get_def_obj(oneof);
+ VALUE obj = get_oneofdef_obj(self->descriptor_pool, oneof);
rb_yield(obj);
}
return Qnil;
@@ -480,24 +649,19 @@
if (oneof == NULL) {
return Qnil;
}
- return get_def_obj(oneof);
+ return get_oneofdef_obj(self->descriptor_pool, oneof);
}
/*
* call-seq:
* Descriptor.msgclass => message_klass
*
- * Returns the Ruby class created for this message type. Valid only once the
- * message type has been added to a pool.
+ * Returns the Ruby class created for this message type.
*/
VALUE Descriptor_msgclass(VALUE _self) {
DEFINE_SELF(Descriptor, self, _self);
- if (!upb_def_isfrozen((const upb_def*)self->msgdef)) {
- rb_raise(rb_eRuntimeError,
- "Cannot fetch message class from a Descriptor not yet in a pool.");
- }
if (self->klass == Qnil) {
- self->klass = build_class_from_descriptor(self);
+ self->klass = build_class_from_descriptor(_self);
}
return self->klass;
}
@@ -509,12 +673,20 @@
DEFINE_CLASS(FileDescriptor, "Google::Protobuf::FileDescriptor");
void FileDescriptor_mark(void* _self) {
+ FileDescriptor* self = _self;
+ rb_gc_mark(self->descriptor_pool);
}
void FileDescriptor_free(void* _self) {
- FileDescriptor* self = _self;
- upb_filedef_unref(self->filedef, &self->filedef);
- xfree(self);
+ xfree(_self);
+}
+
+VALUE FileDescriptor_alloc(VALUE klass) {
+ FileDescriptor* self = ALLOC(FileDescriptor);
+ VALUE ret = TypedData_Wrap_Struct(klass, &_FileDescriptor_type, self);
+ self->descriptor_pool = Qnil;
+ self->filedef = NULL;
+ return ret;
}
/*
@@ -524,66 +696,34 @@
* Returns a new file descriptor. The syntax must be set before it's passed
* to a builder.
*/
-VALUE FileDescriptor_alloc(VALUE klass) {
- FileDescriptor* self = ALLOC(FileDescriptor);
- VALUE ret = TypedData_Wrap_Struct(klass, &_FileDescriptor_type, self);
- upb_filedef* filedef = upb_filedef_new(&self->filedef);
- self->filedef = filedef;
- return ret;
+VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
+ VALUE descriptor_pool, VALUE ptr) {
+ DEFINE_SELF(FileDescriptor, self, _self);
+
+ if (cookie != c_only_cookie) {
+ rb_raise(rb_eRuntimeError,
+ "Descriptor objects may not be created from Ruby.");
+ }
+
+ self->descriptor_pool = descriptor_pool;
+ self->filedef = (const upb_filedef*)NUM2ULL(ptr);
+
+ return Qnil;
}
void FileDescriptor_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "FileDescriptor", rb_cObject);
rb_define_alloc_func(klass, FileDescriptor_alloc);
- rb_define_method(klass, "initialize", FileDescriptor_initialize, -1);
+ rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
rb_define_method(klass, "name", FileDescriptor_name, 0);
rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
- rb_define_method(klass, "syntax=", FileDescriptor_syntax_set, 1);
rb_gc_register_address(&cFileDescriptor);
cFileDescriptor = klass;
}
/*
* call-seq:
- * FileDescriptor.new(name, options = nil) => file
- *
- * Initializes a new file descriptor with the given file name.
- * Also accepts an optional "options" hash, specifying other optional
- * metadata about the file. The options hash currently accepts the following
- * * "syntax": :proto2 or :proto3 (default: :proto3)
- */
-VALUE FileDescriptor_initialize(int argc, VALUE* argv, VALUE _self) {
- DEFINE_SELF(FileDescriptor, self, _self);
-
- VALUE name_rb;
- VALUE options = Qnil;
- rb_scan_args(argc, argv, "11", &name_rb, &options);
-
- if (name_rb != Qnil) {
- Check_Type(name_rb, T_STRING);
- const char* name = get_str(name_rb);
- CHECK_UPB(upb_filedef_setname(self->filedef, name, &status),
- "Error setting file name");
- }
-
- // Default syntax is proto3.
- VALUE syntax = ID2SYM(rb_intern("proto3"));
- if (options != Qnil) {
- Check_Type(options, T_HASH);
-
- if (rb_funcall(options, rb_intern("key?"), 1,
- ID2SYM(rb_intern("syntax"))) == Qtrue) {
- syntax = rb_hash_lookup(options, ID2SYM(rb_intern("syntax")));
- }
- }
- FileDescriptor_syntax_set(_self, syntax);
-
- return Qnil;
-}
-
-/*
- * call-seq:
* FileDescriptor.name => name
*
* Returns the name of the file.
@@ -613,31 +753,6 @@
}
}
-/*
- * call-seq:
- * FileDescriptor.syntax = version
- *
- * Sets this file descriptor's syntax, can be :proto3 or :proto2.
- */
-VALUE FileDescriptor_syntax_set(VALUE _self, VALUE syntax_rb) {
- DEFINE_SELF(FileDescriptor, self, _self);
- Check_Type(syntax_rb, T_SYMBOL);
-
- upb_syntax_t syntax;
- if (SYM2ID(syntax_rb) == rb_intern("proto3")) {
- syntax = UPB_SYNTAX_PROTO3;
- } else if (SYM2ID(syntax_rb) == rb_intern("proto2")) {
- syntax = UPB_SYNTAX_PROTO2;
- } else {
- rb_raise(rb_eArgError, "Expected :proto3 or :proto3, received '%s'",
- rb_id2name(SYM2ID(syntax_rb)));
- }
-
- CHECK_UPB(upb_filedef_setsyntax(self->filedef, syntax, &status),
- "Error setting file syntax for proto");
- return Qnil;
-}
-
// -----------------------------------------------------------------------------
// FieldDescriptor.
// -----------------------------------------------------------------------------
@@ -645,12 +760,12 @@
DEFINE_CLASS(FieldDescriptor, "Google::Protobuf::FieldDescriptor");
void FieldDescriptor_mark(void* _self) {
+ FieldDescriptor* self = _self;
+ rb_gc_mark(self->descriptor_pool);
}
void FieldDescriptor_free(void* _self) {
- FieldDescriptor* self = _self;
- upb_fielddef_unref(self->fielddef, &self->fielddef);
- xfree(self);
+ xfree(_self);
}
/*
@@ -663,9 +778,7 @@
VALUE FieldDescriptor_alloc(VALUE klass) {
FieldDescriptor* self = ALLOC(FieldDescriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_FieldDescriptor_type, self);
- upb_fielddef* fielddef = upb_fielddef_new(&self->fielddef);
- upb_fielddef_setpacked(fielddef, false);
- self->fielddef = fielddef;
+ self->fielddef = NULL;
return ret;
}
@@ -673,18 +786,13 @@
VALUE klass = rb_define_class_under(
module, "FieldDescriptor", rb_cObject);
rb_define_alloc_func(klass, FieldDescriptor_alloc);
+ rb_define_method(klass, "initialize", FieldDescriptor_initialize, 3);
rb_define_method(klass, "name", FieldDescriptor_name, 0);
- rb_define_method(klass, "name=", FieldDescriptor_name_set, 1);
rb_define_method(klass, "type", FieldDescriptor_type, 0);
- rb_define_method(klass, "type=", FieldDescriptor_type_set, 1);
rb_define_method(klass, "default", FieldDescriptor_default, 0);
- rb_define_method(klass, "default=", FieldDescriptor_default_set, 1);
rb_define_method(klass, "label", FieldDescriptor_label, 0);
- rb_define_method(klass, "label=", FieldDescriptor_label_set, 1);
rb_define_method(klass, "number", FieldDescriptor_number, 0);
- rb_define_method(klass, "number=", FieldDescriptor_number_set, 1);
rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
- rb_define_method(klass, "submsg_name=", FieldDescriptor_submsg_name_set, 1);
rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
rb_define_method(klass, "has?", FieldDescriptor_has, 1);
rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
@@ -696,6 +804,27 @@
/*
* call-seq:
+ * EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
+ *
+ * Creates a descriptor wrapper object. May only be called from C.
+ */
+VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
+ VALUE descriptor_pool, VALUE ptr) {
+ DEFINE_SELF(FieldDescriptor, self, _self);
+
+ if (cookie != c_only_cookie) {
+ rb_raise(rb_eRuntimeError,
+ "Descriptor objects may not be created from Ruby.");
+ }
+
+ self->descriptor_pool = descriptor_pool;
+ self->fielddef = (const upb_fielddef*)NUM2ULL(ptr);
+
+ return Qnil;
+}
+
+/*
+ * call-seq:
* FieldDescriptor.name => name
*
* Returns the name of this field.
@@ -705,22 +834,6 @@
return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
}
-/*
- * call-seq:
- * FieldDescriptor.name = name
- *
- * Sets the name of this field. Cannot be called once the containing message
- * type, if any, is added to a pool.
- */
-VALUE FieldDescriptor_name_set(VALUE _self, VALUE str) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
- const char* name = get_str(str);
- CHECK_UPB(upb_fielddef_setname(mut_def, name, &status),
- "Error setting FieldDescriptor name");
- return Qnil;
-}
-
upb_fieldtype_t ruby_to_fieldtype(VALUE type) {
if (TYPE(type) != T_SYMBOL) {
rb_raise(rb_eArgError, "Expected symbol for field type.");
@@ -831,6 +944,29 @@
return Qnil;
}
+VALUE ruby_to_label(VALUE label) {
+ upb_label_t upb_label;
+ bool converted = false;
+
+#define CONVERT(upb, ruby) \
+ if (SYM2ID(label) == rb_intern( # ruby )) { \
+ upb_label = UPB_LABEL_ ## upb; \
+ converted = true; \
+ }
+
+ CONVERT(OPTIONAL, optional);
+ CONVERT(REQUIRED, required);
+ CONVERT(REPEATED, repeated);
+
+#undef CONVERT
+
+ if (!converted) {
+ rb_raise(rb_eArgError, "Unknown field label.");
+ }
+
+ return upb_label;
+}
+
/*
* call-seq:
* FieldDescriptor.type => type
@@ -843,28 +979,11 @@
*/
VALUE FieldDescriptor_type(VALUE _self) {
DEFINE_SELF(FieldDescriptor, self, _self);
- if (!upb_fielddef_typeisset(self->fielddef)) {
- return Qnil;
- }
return descriptortype_to_ruby(upb_fielddef_descriptortype(self->fielddef));
}
/*
* call-seq:
- * FieldDescriptor.type = type
- *
- * Sets this field's type. Cannot be called if field is part of a message type
- * already in a pool.
- */
-VALUE FieldDescriptor_type_set(VALUE _self, VALUE type) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
- upb_fielddef_setdescriptortype(mut_def, ruby_to_descriptortype(type));
- return Qnil;
-}
-
-/*
- * call-seq:
* FieldDescriptor.default => default
*
* Returns this field's default, as a Ruby object, or nil if not yet set.
@@ -876,60 +995,6 @@
/*
* call-seq:
- * FieldDescriptor.default = default
- *
- * Sets this field's default value. Raises an exception when calling with
- * proto syntax 3.
- */
-VALUE FieldDescriptor_default_set(VALUE _self, VALUE default_value) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-
- switch (upb_fielddef_type(mut_def)) {
- case UPB_TYPE_FLOAT:
- upb_fielddef_setdefaultfloat(mut_def, NUM2DBL(default_value));
- break;
- case UPB_TYPE_DOUBLE:
- upb_fielddef_setdefaultdouble(mut_def, NUM2DBL(default_value));
- break;
- case UPB_TYPE_BOOL:
- if (!RB_TYPE_P(default_value, T_TRUE) &&
- !RB_TYPE_P(default_value, T_FALSE) &&
- !RB_TYPE_P(default_value, T_NIL)) {
- rb_raise(cTypeError, "Expected boolean for default value.");
- }
-
- upb_fielddef_setdefaultbool(mut_def, RTEST(default_value));
- break;
- case UPB_TYPE_ENUM:
- case UPB_TYPE_INT32:
- upb_fielddef_setdefaultint32(mut_def, NUM2INT(default_value));
- break;
- case UPB_TYPE_INT64:
- upb_fielddef_setdefaultint64(mut_def, NUM2INT(default_value));
- break;
- case UPB_TYPE_UINT32:
- upb_fielddef_setdefaultuint32(mut_def, NUM2UINT(default_value));
- break;
- case UPB_TYPE_UINT64:
- upb_fielddef_setdefaultuint64(mut_def, NUM2UINT(default_value));
- break;
- case UPB_TYPE_STRING:
- case UPB_TYPE_BYTES:
- CHECK_UPB(upb_fielddef_setdefaultcstr(mut_def, StringValuePtr(default_value),
- &status),
- "Error setting default string");
- break;
- default:
- rb_raise(rb_eArgError, "Defaults not supported on field %s.%s",
- upb_fielddef_fullname(mut_def), upb_fielddef_name(mut_def));
- }
-
- return Qnil;
-}
-
-/*
- * call-seq:
* FieldDescriptor.label => label
*
* Returns this field's label (i.e., plurality), as a Ruby symbol.
@@ -955,44 +1020,6 @@
/*
* call-seq:
- * FieldDescriptor.label = label
- *
- * Sets the label on this field. Cannot be called if field is part of a message
- * type already in a pool.
- */
-VALUE FieldDescriptor_label_set(VALUE _self, VALUE label) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
- upb_label_t upb_label = -1;
- bool converted = false;
-
- if (TYPE(label) != T_SYMBOL) {
- rb_raise(rb_eArgError, "Expected symbol for field label.");
- }
-
-#define CONVERT(upb, ruby) \
- if (SYM2ID(label) == rb_intern( # ruby )) { \
- upb_label = UPB_LABEL_ ## upb; \
- converted = true; \
- }
-
- CONVERT(OPTIONAL, optional);
- CONVERT(REQUIRED, required);
- CONVERT(REPEATED, repeated);
-
-#undef CONVERT
-
- if (!converted) {
- rb_raise(rb_eArgError, "Unknown field label.");
- }
-
- upb_fielddef_setlabel(mut_def, upb_label);
-
- return Qnil;
-}
-
-/*
- * call-seq:
* FieldDescriptor.number => number
*
* Returns the tag number for this field.
@@ -1004,21 +1031,6 @@
/*
* call-seq:
- * FieldDescriptor.number = number
- *
- * Sets the tag number for this field. Cannot be called if field is part of a
- * message type already in a pool.
- */
-VALUE FieldDescriptor_number_set(VALUE _self, VALUE number) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
- CHECK_UPB(upb_fielddef_setnumber(mut_def, NUM2INT(number), &status),
- "Error setting field number");
- return Qnil;
-}
-
-/*
- * call-seq:
* FieldDescriptor.submsg_name => submsg_name
*
* Returns the name of the message or enum type corresponding to this field, if
@@ -1028,32 +1040,16 @@
*/
VALUE FieldDescriptor_submsg_name(VALUE _self) {
DEFINE_SELF(FieldDescriptor, self, _self);
- if (!upb_fielddef_hassubdef(self->fielddef)) {
- return Qnil;
+ switch (upb_fielddef_type(self->fielddef)) {
+ case UPB_TYPE_ENUM:
+ return rb_str_new2(
+ upb_enumdef_fullname(upb_fielddef_enumsubdef(self->fielddef)));
+ case UPB_TYPE_MESSAGE:
+ return rb_str_new2(
+ upb_msgdef_fullname(upb_fielddef_msgsubdef(self->fielddef)));
+ default:
+ return Qnil;
}
- return rb_str_maybe_null(upb_fielddef_subdefname(self->fielddef));
-}
-
-/*
- * call-seq:
- * FieldDescriptor.submsg_name = submsg_name
- *
- * Sets the name of the message or enum type corresponding to this field, if it
- * is a message or enum field (respectively). This type name will be resolved
- * within the context of the pool to which the containing message type is added.
- * Cannot be called on field that are not of message or enum type, or on fields
- * that are part of a message type already added to a pool.
- */
-VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value) {
- DEFINE_SELF(FieldDescriptor, self, _self);
- upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
- const char* str = get_str(value);
- if (!upb_fielddef_hassubdef(self->fielddef)) {
- rb_raise(cTypeError, "FieldDescriptor does not have subdef.");
- }
- CHECK_UPB(upb_fielddef_setsubdefname(mut_def, str, &status),
- "Error setting submessage name");
- return Qnil;
}
/*
@@ -1067,16 +1063,16 @@
*/
VALUE FieldDescriptor_subtype(VALUE _self) {
DEFINE_SELF(FieldDescriptor, self, _self);
- const upb_def* def;
-
- if (!upb_fielddef_hassubdef(self->fielddef)) {
- return Qnil;
+ switch (upb_fielddef_type(self->fielddef)) {
+ case UPB_TYPE_ENUM:
+ return get_enumdef_obj(self->descriptor_pool,
+ upb_fielddef_enumsubdef(self->fielddef));
+ case UPB_TYPE_MESSAGE:
+ return get_msgdef_obj(self->descriptor_pool,
+ upb_fielddef_msgsubdef(self->fielddef));
+ default:
+ return Qnil;
}
- def = upb_fielddef_subdef(self->fielddef);
- if (def == NULL) {
- return Qnil;
- }
- return get_def_obj(def);
}
/*
@@ -1160,12 +1156,12 @@
DEFINE_CLASS(OneofDescriptor, "Google::Protobuf::OneofDescriptor");
void OneofDescriptor_mark(void* _self) {
+ OneofDescriptor* self = _self;
+ rb_gc_mark(self->descriptor_pool);
}
void OneofDescriptor_free(void* _self) {
- OneofDescriptor* self = _self;
- upb_oneofdef_unref(self->oneofdef, &self->oneofdef);
- xfree(self);
+ xfree(_self);
}
/*
@@ -1178,7 +1174,8 @@
VALUE OneofDescriptor_alloc(VALUE klass) {
OneofDescriptor* self = ALLOC(OneofDescriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_OneofDescriptor_type, self);
- self->oneofdef = upb_oneofdef_new(&self->oneofdef);
+ self->oneofdef = NULL;
+ self->descriptor_pool = Qnil;
return ret;
}
@@ -1186,9 +1183,8 @@
VALUE klass = rb_define_class_under(
module, "OneofDescriptor", rb_cObject);
rb_define_alloc_func(klass, OneofDescriptor_alloc);
+ rb_define_method(klass, "initialize", OneofDescriptor_initialize, 3);
rb_define_method(klass, "name", OneofDescriptor_name, 0);
- rb_define_method(klass, "name=", OneofDescriptor_name_set, 1);
- rb_define_method(klass, "add_field", OneofDescriptor_add_field, 1);
rb_define_method(klass, "each", OneofDescriptor_each, 0);
rb_include_module(klass, rb_mEnumerable);
rb_gc_register_address(&cOneofDescriptor);
@@ -1197,6 +1193,27 @@
/*
* call-seq:
+ * OneofDescriptor.new(c_only_cookie, pool, ptr) => OneofDescriptor
+ *
+ * Creates a descriptor wrapper object. May only be called from C.
+ */
+VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
+ VALUE descriptor_pool, VALUE ptr) {
+ DEFINE_SELF(OneofDescriptor, self, _self);
+
+ if (cookie != c_only_cookie) {
+ rb_raise(rb_eRuntimeError,
+ "Descriptor objects may not be created from Ruby.");
+ }
+
+ self->descriptor_pool = descriptor_pool;
+ self->oneofdef = (const upb_oneofdef*)NUM2ULL(ptr);
+
+ return Qnil;
+}
+
+/*
+ * call-seq:
* OneofDescriptor.name => name
*
* Returns the name of this oneof.
@@ -1208,48 +1225,6 @@
/*
* call-seq:
- * OneofDescriptor.name = name
- *
- * Sets a new name for this oneof. The oneof must not have been added to a
- * message descriptor yet.
- */
-VALUE OneofDescriptor_name_set(VALUE _self, VALUE value) {
- DEFINE_SELF(OneofDescriptor, self, _self);
- upb_oneofdef* mut_def = check_oneof_notfrozen(self->oneofdef);
- const char* str = get_str(value);
- CHECK_UPB(upb_oneofdef_setname(mut_def, str, &status),
- "Error setting oneof name");
- return Qnil;
-}
-
-/*
- * call-seq:
- * OneofDescriptor.add_field(field) => nil
- *
- * Adds a field to this oneof. The field may have been added to this oneof in
- * the past, or the message to which this oneof belongs (if any), but may not
- * have already been added to any other oneof or message. Otherwise, an
- * exception is raised.
- *
- * All fields added to the oneof via this method will be automatically added to
- * the message to which this oneof belongs, if it belongs to one currently, or
- * else will be added to any message to which the oneof is later added at the
- * time that it is added.
- */
-VALUE OneofDescriptor_add_field(VALUE _self, VALUE obj) {
- DEFINE_SELF(OneofDescriptor, self, _self);
- upb_oneofdef* mut_def = check_oneof_notfrozen(self->oneofdef);
- FieldDescriptor* def = ruby_to_FieldDescriptor(obj);
- upb_fielddef* mut_field_def = check_field_notfrozen(def->fielddef);
- CHECK_UPB(
- upb_oneofdef_addfield(mut_def, mut_field_def, NULL, &status),
- "Adding field to OneofDescriptor failed");
- add_def_obj(def->fielddef, obj);
- return Qnil;
-}
-
-/*
- * call-seq:
* OneofDescriptor.each(&block) => nil
*
* Iterates through fields in this oneof, yielding to the block on each one.
@@ -1261,7 +1236,7 @@
!upb_oneof_done(&it);
upb_oneof_next(&it)) {
const upb_fielddef* f = upb_oneof_iter_field(&it);
- VALUE obj = get_def_obj(f);
+ VALUE obj = get_fielddef_obj(self->descriptor_pool, f);
rb_yield(obj);
}
return Qnil;
@@ -1276,38 +1251,49 @@
void EnumDescriptor_mark(void* _self) {
EnumDescriptor* self = _self;
rb_gc_mark(self->module);
+ rb_gc_mark(self->descriptor_pool);
}
void EnumDescriptor_free(void* _self) {
- EnumDescriptor* self = _self;
- upb_enumdef_unref(self->enumdef, &self->enumdef);
- xfree(self);
+ xfree(_self);
+}
+
+VALUE EnumDescriptor_alloc(VALUE klass) {
+ EnumDescriptor* self = ALLOC(EnumDescriptor);
+ VALUE ret = TypedData_Wrap_Struct(klass, &_EnumDescriptor_type, self);
+ self->enumdef = NULL;
+ self->module = Qnil;
+ self->descriptor_pool = Qnil;
+ return ret;
}
/*
* call-seq:
- * EnumDescriptor.new => enum_descriptor
+ * EnumDescriptor.new(c_only_cookie, ptr) => EnumDescriptor
*
- * Creates a new, empty, enum descriptor. Must be added to a pool before the
- * enum type can be used. The enum type may only be modified prior to adding to
- * a pool.
+ * Creates a descriptor wrapper object. May only be called from C.
*/
-VALUE EnumDescriptor_alloc(VALUE klass) {
- EnumDescriptor* self = ALLOC(EnumDescriptor);
- VALUE ret = TypedData_Wrap_Struct(klass, &_EnumDescriptor_type, self);
- self->enumdef = upb_enumdef_new(&self->enumdef);
- self->module = Qnil;
- return ret;
+VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
+ VALUE descriptor_pool, VALUE ptr) {
+ DEFINE_SELF(EnumDescriptor, self, _self);
+
+ if (cookie != c_only_cookie) {
+ rb_raise(rb_eRuntimeError,
+ "Descriptor objects may not be created from Ruby.");
+ }
+
+ self->descriptor_pool = descriptor_pool;
+ self->enumdef = (const upb_enumdef*)NUM2ULL(ptr);
+
+ return Qnil;
}
void EnumDescriptor_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "EnumDescriptor", rb_cObject);
rb_define_alloc_func(klass, EnumDescriptor_alloc);
- rb_define_method(klass, "initialize", EnumDescriptor_initialize, 1);
+ rb_define_method(klass, "initialize", EnumDescriptor_initialize, 3);
rb_define_method(klass, "name", EnumDescriptor_name, 0);
- rb_define_method(klass, "name=", EnumDescriptor_name_set, 1);
- rb_define_method(klass, "add_value", EnumDescriptor_add_value, 2);
rb_define_method(klass, "lookup_name", EnumDescriptor_lookup_name, 1);
rb_define_method(klass, "lookup_value", EnumDescriptor_lookup_value, 1);
rb_define_method(klass, "each", EnumDescriptor_each, 0);
@@ -1320,31 +1306,14 @@
/*
* call-seq:
- * Descriptor.new(file_descriptor)
- *
- * Initializes a new descriptor and assigns a file descriptor to it.
- */
-VALUE EnumDescriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
- DEFINE_SELF(EnumDescriptor, self, _self);
- FileDescriptor* file_descriptor = ruby_to_FileDescriptor(file_descriptor_rb);
- CHECK_UPB(
- upb_filedef_addenum(file_descriptor->filedef, self->enumdef,
- NULL, &status),
- "Failed to associate enum to file descriptor.");
- add_def_obj(file_descriptor->filedef, file_descriptor_rb);
-
- return Qnil;
-}
-
-/*
- * call-seq:
- * Descriptor.file_descriptor
+ * EnumDescriptor.file_descriptor
*
* Returns the FileDescriptor object this enum belongs to.
*/
VALUE EnumDescriptor_file_descriptor(VALUE _self) {
DEFINE_SELF(EnumDescriptor, self, _self);
- return get_def_obj(upb_def_file(self->enumdef));
+ return get_filedef_obj(self->descriptor_pool,
+ upb_enumdef_file(self->enumdef));
}
/*
@@ -1360,40 +1329,6 @@
/*
* call-seq:
- * EnumDescriptor.name = name
- *
- * Sets the name of this enum type. Cannot be called if the enum type has
- * already been added to a pool.
- */
-VALUE EnumDescriptor_name_set(VALUE _self, VALUE str) {
- DEFINE_SELF(EnumDescriptor, self, _self);
- upb_enumdef* mut_def = check_enum_notfrozen(self->enumdef);
- const char* name = get_str(str);
- CHECK_UPB(upb_enumdef_setfullname(mut_def, name, &status),
- "Error setting EnumDescriptor name");
- return Qnil;
-}
-
-/*
- * call-seq:
- * EnumDescriptor.add_value(key, value)
- *
- * Adds a new key => value mapping to this enum type. Key must be given as a
- * Ruby symbol. Cannot be called if the enum type has already been added to a
- * pool. Will raise an exception if the key or value is already in use.
- */
-VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number) {
- DEFINE_SELF(EnumDescriptor, self, _self);
- upb_enumdef* mut_def = check_enum_notfrozen(self->enumdef);
- const char* name_str = rb_id2name(SYM2ID(name));
- int32_t val = NUM2INT(number);
- CHECK_UPB(upb_enumdef_addval(mut_def, name_str, val, &status),
- "Error adding value to enum");
- return Qnil;
-}
-
-/*
- * call-seq:
* EnumDescriptor.lookup_name(name) => value
*
* Returns the numeric value corresponding to the given key name (as a Ruby
@@ -1454,18 +1389,12 @@
* call-seq:
* EnumDescriptor.enummodule => module
*
- * Returns the Ruby module corresponding to this enum type. Cannot be called
- * until the enum descriptor has been added to a pool.
+ * Returns the Ruby module corresponding to this enum type.
*/
VALUE EnumDescriptor_enummodule(VALUE _self) {
DEFINE_SELF(EnumDescriptor, self, _self);
- if (!upb_def_isfrozen((const upb_def*)self->enumdef)) {
- rb_raise(rb_eRuntimeError,
- "Cannot fetch enum module from an EnumDescriptor not yet "
- "in a pool.");
- }
if (self->module == Qnil) {
- self->module = build_module_from_enumdesc(self);
+ self->module = build_module_from_enumdesc(_self);
}
return self->module;
}
@@ -1479,8 +1408,7 @@
void MessageBuilderContext_mark(void* _self) {
MessageBuilderContext* self = _self;
- rb_gc_mark(self->descriptor);
- rb_gc_mark(self->builder);
+ rb_gc_mark(self->file_builder);
}
void MessageBuilderContext_free(void* _self) {
@@ -1492,8 +1420,7 @@
MessageBuilderContext* self = ALLOC(MessageBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_MessageBuilderContext_type, self);
- self->descriptor = Qnil;
- self->builder = Qnil;
+ self->file_builder = Qnil;
return ret;
}
@@ -1514,65 +1441,110 @@
/*
* call-seq:
- * MessageBuilderContext.new(desc, builder) => context
+ * MessageBuilderContext.new(file_builder, name) => context
*
* Create a new message builder context around the given message descriptor and
* builder context. This class is intended to serve as a DSL context to be used
* with #instance_eval.
*/
VALUE MessageBuilderContext_initialize(VALUE _self,
- VALUE msgdef,
- VALUE builder) {
+ VALUE _file_builder,
+ VALUE name) {
DEFINE_SELF(MessageBuilderContext, self, _self);
- self->descriptor = msgdef;
- self->builder = builder;
+ FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+ google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
+
+ self->file_builder = _file_builder;
+ self->msg_proto = google_protobuf_FileDescriptorProto_add_message_type(
+ file_proto, file_builder->arena);
+
+ google_protobuf_DescriptorProto_set_name(
+ self->msg_proto, FileBuilderContext_strdup(_file_builder, name));
+
return Qnil;
}
-static VALUE msgdef_add_field(VALUE msgdef_rb,
- const char* label, VALUE name,
- VALUE type, VALUE number,
- VALUE type_class,
- VALUE options) {
- VALUE fielddef_rb = rb_class_new_instance(0, NULL, cFieldDescriptor);
- VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
+static void msgdef_add_field(VALUE msgbuilder_rb, upb_label_t label, VALUE name,
+ VALUE type, VALUE number, VALUE type_class,
+ VALUE options, int oneof_index) {
+ DEFINE_SELF(MessageBuilderContext, self, msgbuilder_rb);
+ FileBuilderContext* file_context =
+ ruby_to_FileBuilderContext(self->file_builder);
+ google_protobuf_FieldDescriptorProto* field_proto;
+ VALUE name_str;
- rb_funcall(fielddef_rb, rb_intern("label="), 1, ID2SYM(rb_intern(label)));
- rb_funcall(fielddef_rb, rb_intern("name="), 1, name_str);
- rb_funcall(fielddef_rb, rb_intern("type="), 1, type);
- rb_funcall(fielddef_rb, rb_intern("number="), 1, number);
+ field_proto = google_protobuf_DescriptorProto_add_field(self->msg_proto,
+ file_context->arena);
+
+ Check_Type(name, T_SYMBOL);
+ name_str = rb_id2str(SYM2ID(name));
+
+ google_protobuf_FieldDescriptorProto_set_name(
+ field_proto, FileBuilderContext_strdup(self->file_builder, name_str));
+ google_protobuf_FieldDescriptorProto_set_number(field_proto, NUM2INT(number));
+ google_protobuf_FieldDescriptorProto_set_label(field_proto, (int)label);
+ google_protobuf_FieldDescriptorProto_set_type(
+ field_proto, (int)ruby_to_descriptortype(type));
if (type_class != Qnil) {
Check_Type(type_class, T_STRING);
// Make it an absolute type name by prepending a dot.
type_class = rb_str_append(rb_str_new2("."), type_class);
- rb_funcall(fielddef_rb, rb_intern("submsg_name="), 1, type_class);
+ google_protobuf_FieldDescriptorProto_set_type_name(
+ field_proto, FileBuilderContext_strdup(self->file_builder, type_class));
}
if (options != Qnil) {
Check_Type(options, T_HASH);
if (rb_funcall(options, rb_intern("key?"), 1,
- ID2SYM(rb_intern("default"))) == Qtrue) {
- Descriptor* msgdef = ruby_to_Descriptor(msgdef_rb);
- if (upb_msgdef_syntax((upb_msgdef*)msgdef->msgdef) == UPB_SYNTAX_PROTO3) {
- rb_raise(rb_eArgError, "Cannot set :default when using proto3 syntax.");
- }
+ ID2SYM(rb_intern("default"))) == Qtrue) {
+ VALUE default_value =
+ rb_hash_lookup(options, ID2SYM(rb_intern("default")));
- FieldDescriptor* fielddef = ruby_to_FieldDescriptor(fielddef_rb);
- if (!upb_fielddef_haspresence((upb_fielddef*)fielddef->fielddef) ||
- upb_fielddef_issubmsg((upb_fielddef*)fielddef->fielddef)) {
- rb_raise(rb_eArgError, "Cannot set :default on this kind of field.");
- }
+ /* Call #to_s since all defaults are strings in the descriptor. */
+ default_value = rb_funcall(default_value, rb_intern("to_s"), 0);
- rb_funcall(fielddef_rb, rb_intern("default="), 1,
- rb_hash_lookup(options, ID2SYM(rb_intern("default"))));
+ google_protobuf_FieldDescriptorProto_set_default_value(
+ field_proto,
+ FileBuilderContext_strdup(self->file_builder, default_value));
}
}
- rb_funcall(msgdef_rb, rb_intern("add_field"), 1, fielddef_rb);
- return fielddef_rb;
+ if (oneof_index >= 0) {
+ google_protobuf_FieldDescriptorProto_set_oneof_index(field_proto,
+ oneof_index);
+ }
+}
+
+static VALUE make_mapentry(VALUE _message_builder, VALUE types, int argc,
+ VALUE* argv) {
+ DEFINE_SELF(MessageBuilderContext, message_builder, _message_builder);
+ VALUE type_class = rb_ary_entry(types, 2);
+ FileBuilderContext* file_context =
+ ruby_to_FileBuilderContext(message_builder->file_builder);
+ google_protobuf_MessageOptions* options =
+ google_protobuf_DescriptorProto_mutable_options(
+ message_builder->msg_proto, file_context->arena);
+
+ google_protobuf_MessageOptions_set_map_entry(options, true);
+
+ // optional <type> key = 1;
+ rb_funcall(_message_builder, rb_intern("optional"), 3,
+ ID2SYM(rb_intern("key")), rb_ary_entry(types, 0), INT2NUM(1));
+
+ // optional <type> value = 2;
+ if (type_class == Qnil) {
+ rb_funcall(_message_builder, rb_intern("optional"), 3,
+ ID2SYM(rb_intern("value")), rb_ary_entry(types, 1), INT2NUM(2));
+ } else {
+ rb_funcall(_message_builder, rb_intern("optional"), 4,
+ ID2SYM(rb_intern("value")), rb_ary_entry(types, 1), INT2NUM(2),
+ type_class);
+ }
+
+ return Qnil;
}
/*
@@ -1586,7 +1558,6 @@
* string, if present (as accepted by FieldDescriptor#submsg_name=).
*/
VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
- DEFINE_SELF(MessageBuilderContext, self, _self);
VALUE name, type, number;
VALUE type_class, options = Qnil;
@@ -1599,8 +1570,10 @@
type_class = Qnil;
}
- return msgdef_add_field(self->descriptor, "optional",
- name, type, number, type_class, options);
+ msgdef_add_field(_self, UPB_LABEL_OPTIONAL, name, type, number, type_class,
+ options, -1);
+
+ return Qnil;
}
/*
@@ -1618,7 +1591,6 @@
* pool will currently result in an error.
*/
VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
- DEFINE_SELF(MessageBuilderContext, self, _self);
VALUE name, type, number;
VALUE type_class, options = Qnil;
@@ -1631,8 +1603,10 @@
type_class = Qnil;
}
- return msgdef_add_field(self->descriptor, "required",
- name, type, number, type_class, options);
+ msgdef_add_field(_self, UPB_LABEL_REQUIRED, name, type, number, type_class,
+ options, -1);
+
+ return Qnil;
}
/*
@@ -1645,7 +1619,6 @@
* string, if present (as accepted by FieldDescriptor#submsg_name=).
*/
VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
- DEFINE_SELF(MessageBuilderContext, self, _self);
VALUE name, type, number, type_class;
if (argc < 3) {
@@ -1656,8 +1629,10 @@
number = argv[2];
type_class = (argc > 3) ? argv[3] : Qnil;
- return msgdef_add_field(self->descriptor, "repeated",
- name, type, number, type_class, Qnil);
+ msgdef_add_field(_self, UPB_LABEL_REPEATED, name, type, number, type_class,
+ Qnil, -1);
+
+ return Qnil;
}
/*
@@ -1675,7 +1650,9 @@
VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
DEFINE_SELF(MessageBuilderContext, self, _self);
VALUE name, key_type, value_type, number, type_class;
- VALUE mapentry_desc, mapentry_desc_name;
+ VALUE mapentry_desc_name;
+ FileBuilderContext* file_builder;
+ upb_strview msg_name;
if (argc < 4) {
rb_raise(rb_eArgError, "Expected at least 4 arguments.");
@@ -1698,77 +1675,44 @@
"type.");
}
- Descriptor* descriptor = ruby_to_Descriptor(self->descriptor);
- if (upb_msgdef_syntax(descriptor->msgdef) == UPB_SYNTAX_PROTO2) {
+ file_builder = ruby_to_FileBuilderContext(self->file_builder);
+
+ // TODO(haberman): remove this restriction, maps are supported in proto2.
+ if (upb_strview_eql(
+ google_protobuf_FileDescriptorProto_syntax(file_builder->file_proto),
+ upb_strview_makez("proto2"))) {
rb_raise(rb_eArgError,
- "Cannot add a native map field using proto2 syntax.");
+ "Cannot add a native map field using proto2 syntax.");
}
// Create a new message descriptor for the map entry message, and create a
// repeated submessage field here with that type.
- VALUE file_descriptor_rb =
- rb_funcall(self->descriptor, rb_intern("file_descriptor"), 0);
- mapentry_desc = rb_class_new_instance(1, &file_descriptor_rb, cDescriptor);
- mapentry_desc_name = rb_funcall(self->descriptor, rb_intern("name"), 0);
+ msg_name = google_protobuf_DescriptorProto_name(self->msg_proto);
+ mapentry_desc_name = rb_str_new(msg_name.data, msg_name.size);
mapentry_desc_name = rb_str_cat2(mapentry_desc_name, "_MapEntry_");
- mapentry_desc_name = rb_str_cat2(mapentry_desc_name,
- rb_id2name(SYM2ID(name)));
- Descriptor_name_set(mapentry_desc, mapentry_desc_name);
+ mapentry_desc_name =
+ rb_str_cat2(mapentry_desc_name, rb_id2name(SYM2ID(name)));
{
- // The 'mapentry' attribute has no Ruby setter because we do not want the
- // user attempting to DIY the setup below; we want to ensure that the fields
- // are correct. So we reach into the msgdef here to set the bit manually.
- Descriptor* mapentry_desc_self = ruby_to_Descriptor(mapentry_desc);
- upb_msgdef_setmapentry((upb_msgdef*)mapentry_desc_self->msgdef, true);
+ // message <msgname>_MapEntry_ { /* ... */ }
+ VALUE args[1] = {mapentry_desc_name};
+ VALUE types = rb_ary_new3(3, key_type, value_type, type_class);
+ rb_block_call(self->file_builder, rb_intern("add_message"), 1, args,
+ make_mapentry, types);
}
- {
- // optional <type> key = 1;
- VALUE key_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
- FieldDescriptor_name_set(key_field, rb_str_new2("key"));
- FieldDescriptor_label_set(key_field, ID2SYM(rb_intern("optional")));
- FieldDescriptor_number_set(key_field, INT2NUM(1));
- FieldDescriptor_type_set(key_field, key_type);
- Descriptor_add_field(mapentry_desc, key_field);
+ // If this file is in a package, we need to qualify the map entry type.
+ if (google_protobuf_FileDescriptorProto_has_package(file_builder->file_proto)) {
+ upb_strview package_view =
+ google_protobuf_FileDescriptorProto_package(file_builder->file_proto);
+ VALUE package = rb_str_new(package_view.data, package_view.size);
+ package = rb_str_cat2(package, ".");
+ mapentry_desc_name = rb_str_concat(package, mapentry_desc_name);
}
- {
- // optional <type> value = 2;
- VALUE value_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
- FieldDescriptor_name_set(value_field, rb_str_new2("value"));
- FieldDescriptor_label_set(value_field, ID2SYM(rb_intern("optional")));
- FieldDescriptor_number_set(value_field, INT2NUM(2));
- FieldDescriptor_type_set(value_field, value_type);
- if (type_class != Qnil) {
- VALUE submsg_name = rb_str_new2("."); // prepend '.' to make absolute.
- submsg_name = rb_str_append(submsg_name, type_class);
- FieldDescriptor_submsg_name_set(value_field, submsg_name);
- }
- Descriptor_add_field(mapentry_desc, value_field);
- }
-
- {
- // Add the map-entry message type to the current builder, and use the type
- // to create the map field itself.
- Builder* builder = ruby_to_Builder(self->builder);
- rb_ary_push(builder->pending_list, mapentry_desc);
- }
-
- {
- VALUE map_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
- VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
- VALUE submsg_name;
-
- FieldDescriptor_name_set(map_field, name_str);
- FieldDescriptor_number_set(map_field, number);
- FieldDescriptor_label_set(map_field, ID2SYM(rb_intern("repeated")));
- FieldDescriptor_type_set(map_field, ID2SYM(rb_intern("message")));
- submsg_name = rb_str_new2("."); // prepend '.' to make name absolute.
- submsg_name = rb_str_append(submsg_name, mapentry_desc_name);
- FieldDescriptor_submsg_name_set(map_field, submsg_name);
- Descriptor_add_field(self->descriptor, map_field);
- }
+ // repeated MapEntry <name> = <number>;
+ rb_funcall(_self, rb_intern("repeated"), 4, name,
+ ID2SYM(rb_intern("message")), number, mapentry_desc_name);
return Qnil;
}
@@ -1786,14 +1730,27 @@
*/
VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
DEFINE_SELF(MessageBuilderContext, self, _self);
- VALUE oneofdef = rb_class_new_instance(0, NULL, cOneofDescriptor);
- VALUE args[2] = { oneofdef, self->builder };
- VALUE ctx = rb_class_new_instance(2, args, cOneofBuilderContext);
- VALUE block = rb_block_proc();
- VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
- rb_funcall(oneofdef, rb_intern("name="), 1, name_str);
- rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- Descriptor_add_oneof(self->descriptor, oneofdef);
+ size_t oneof_count;
+ FileBuilderContext* file_context =
+ ruby_to_FileBuilderContext(self->file_builder);
+ google_protobuf_OneofDescriptorProto* oneof_proto;
+
+ // Existing oneof_count becomes oneof_index.
+ google_protobuf_DescriptorProto_oneof_decl(self->msg_proto, &oneof_count);
+
+ // Create oneof_proto and set its name.
+ oneof_proto = google_protobuf_DescriptorProto_add_oneof_decl(
+ self->msg_proto, file_context->arena);
+ google_protobuf_OneofDescriptorProto_set_name(
+ oneof_proto, FileBuilderContext_strdup_sym(self->file_builder, name));
+
+ // Evaluate the block with the builder as argument.
+ {
+ VALUE args[2] = { INT2NUM(oneof_count), _self };
+ VALUE ctx = rb_class_new_instance(2, args, cOneofBuilderContext);
+ VALUE block = rb_block_proc();
+ rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+ }
return Qnil;
}
@@ -1807,21 +1764,19 @@
void OneofBuilderContext_mark(void* _self) {
OneofBuilderContext* self = _self;
- rb_gc_mark(self->descriptor);
- rb_gc_mark(self->builder);
+ rb_gc_mark(self->message_builder);
}
void OneofBuilderContext_free(void* _self) {
- OneofBuilderContext* self = _self;
- xfree(self);
+ xfree(_self);
}
VALUE OneofBuilderContext_alloc(VALUE klass) {
OneofBuilderContext* self = ALLOC(OneofBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_OneofBuilderContext_type, self);
- self->descriptor = Qnil;
- self->builder = Qnil;
+ self->oneof_index = 0;
+ self->message_builder = Qnil;
return ret;
}
@@ -1838,18 +1793,18 @@
/*
* call-seq:
- * OneofBuilderContext.new(desc, builder) => context
+ * OneofBuilderContext.new(oneof_index, message_builder) => context
*
* Create a new oneof builder context around the given oneof descriptor and
* builder context. This class is intended to serve as a DSL context to be used
* with #instance_eval.
*/
VALUE OneofBuilderContext_initialize(VALUE _self,
- VALUE oneofdef,
- VALUE builder) {
+ VALUE oneof_index,
+ VALUE message_builder) {
DEFINE_SELF(OneofBuilderContext, self, _self);
- self->descriptor = oneofdef;
- self->builder = builder;
+ self->oneof_index = NUM2INT(oneof_index);
+ self->message_builder = message_builder;
return Qnil;
}
@@ -1870,8 +1825,10 @@
rb_scan_args(argc, argv, "32", &name, &type, &number, &type_class, &options);
- return msgdef_add_field(self->descriptor, "optional",
- name, type, number, type_class, options);
+ msgdef_add_field(self->message_builder, UPB_LABEL_OPTIONAL, name, type,
+ number, type_class, options, self->oneof_index);
+
+ return Qnil;
}
// -----------------------------------------------------------------------------
@@ -1883,19 +1840,19 @@
void EnumBuilderContext_mark(void* _self) {
EnumBuilderContext* self = _self;
- rb_gc_mark(self->enumdesc);
+ rb_gc_mark(self->file_builder);
}
void EnumBuilderContext_free(void* _self) {
- EnumBuilderContext* self = _self;
- xfree(self);
+ xfree(_self);
}
VALUE EnumBuilderContext_alloc(VALUE klass) {
EnumBuilderContext* self = ALLOC(EnumBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_EnumBuilderContext_type, self);
- self->enumdesc = Qnil;
+ self->enum_proto = NULL;
+ self->file_builder = Qnil;
return ret;
}
@@ -1903,8 +1860,7 @@
VALUE klass = rb_define_class_under(
module, "EnumBuilderContext", rb_cObject);
rb_define_alloc_func(klass, EnumBuilderContext_alloc);
- rb_define_method(klass, "initialize",
- EnumBuilderContext_initialize, 1);
+ rb_define_method(klass, "initialize", EnumBuilderContext_initialize, 2);
rb_define_method(klass, "value", EnumBuilderContext_value, 2);
rb_gc_register_address(&cEnumBuilderContext);
cEnumBuilderContext = klass;
@@ -1912,20 +1868,24 @@
/*
* call-seq:
- * EnumBuilderContext.new(enumdesc) => context
+ * EnumBuilderContext.new(file_builder) => context
*
* Create a new builder context around the given enum descriptor. This class is
* intended to serve as a DSL context to be used with #instance_eval.
*/
-VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdef) {
+VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
+ VALUE name) {
DEFINE_SELF(EnumBuilderContext, self, _self);
- self->enumdesc = enumdef;
- return Qnil;
-}
+ FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+ google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
-static VALUE enumdef_add_value(VALUE enumdef,
- VALUE name, VALUE number) {
- rb_funcall(enumdef, rb_intern("add_value"), 2, name, number);
+ self->file_builder = _file_builder;
+ self->enum_proto = google_protobuf_FileDescriptorProto_add_enum_type(
+ file_proto, file_builder->arena);
+
+ google_protobuf_EnumDescriptorProto_set_name(
+ self->enum_proto, FileBuilderContext_strdup(_file_builder, name));
+
return Qnil;
}
@@ -1938,7 +1898,19 @@
*/
VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
DEFINE_SELF(EnumBuilderContext, self, _self);
- return enumdef_add_value(self->enumdesc, name, number);
+ FileBuilderContext* file_builder =
+ ruby_to_FileBuilderContext(self->file_builder);
+ google_protobuf_EnumValueDescriptorProto* enum_value;
+
+ enum_value = google_protobuf_EnumDescriptorProto_add_value(
+ self->enum_proto, file_builder->arena);
+
+ google_protobuf_EnumValueDescriptorProto_set_name(
+ enum_value, FileBuilderContext_strdup_sym(self->file_builder, name));
+ google_protobuf_EnumValueDescriptorProto_set_number(enum_value,
+ NUM2INT(number));
+
+ return Qnil;
}
@@ -1947,33 +1919,55 @@
// -----------------------------------------------------------------------------
DEFINE_CLASS(FileBuilderContext,
- "Google::Protobuf::Internal::FileBuilderContext");
+ "Google::Protobuf::Internal::FileBuilderContext");
void FileBuilderContext_mark(void* _self) {
FileBuilderContext* self = _self;
- rb_gc_mark(self->pending_list);
- rb_gc_mark(self->file_descriptor);
- rb_gc_mark(self->builder);
+ rb_gc_mark(self->descriptor_pool);
}
void FileBuilderContext_free(void* _self) {
FileBuilderContext* self = _self;
+ upb_arena_free(self->arena);
xfree(self);
}
+upb_strview FileBuilderContext_strdup2(VALUE _self, const char *str) {
+ DEFINE_SELF(FileBuilderContext, self, _self);
+ upb_strview ret;
+ char *data;
+
+ ret.size = strlen(str);
+ data = upb_malloc(upb_arena_alloc(self->arena), ret.size + 1);
+ ret.data = data;
+ memcpy(data, str, ret.size);
+ /* Null-terminate required by rewrite_enum_defaults() above. */
+ data[ret.size] = '\0';
+ return ret;
+}
+
+upb_strview FileBuilderContext_strdup(VALUE _self, VALUE rb_str) {
+ return FileBuilderContext_strdup2(_self, get_str(rb_str));
+}
+
+upb_strview FileBuilderContext_strdup_sym(VALUE _self, VALUE rb_sym) {
+ Check_Type(rb_sym, T_SYMBOL);
+ return FileBuilderContext_strdup(_self, rb_id2str(SYM2ID(rb_sym)));
+}
+
VALUE FileBuilderContext_alloc(VALUE klass) {
FileBuilderContext* self = ALLOC(FileBuilderContext);
VALUE ret = TypedData_Wrap_Struct(klass, &_FileBuilderContext_type, self);
- self->pending_list = Qnil;
- self->file_descriptor = Qnil;
- self->builder = Qnil;
+ self->arena = upb_arena_new();
+ self->file_proto = google_protobuf_FileDescriptorProto_new(self->arena);
+ self->descriptor_pool = Qnil;
return ret;
}
void FileBuilderContext_register(VALUE module) {
VALUE klass = rb_define_class_under(module, "FileBuilderContext", rb_cObject);
rb_define_alloc_func(klass, FileBuilderContext_alloc);
- rb_define_method(klass, "initialize", FileBuilderContext_initialize, 2);
+ rb_define_method(klass, "initialize", FileBuilderContext_initialize, 3);
rb_define_method(klass, "add_message", FileBuilderContext_add_message, 1);
rb_define_method(klass, "add_enum", FileBuilderContext_add_enum, 1);
rb_gc_register_address(&cFileBuilderContext);
@@ -1982,18 +1976,41 @@
/*
* call-seq:
- * FileBuilderContext.new(file_descriptor, builder) => context
+ * FileBuilderContext.new(descriptor_pool) => context
*
* Create a new file builder context for the given file descriptor and
* builder context. This class is intended to serve as a DSL context to be used
* with #instance_eval.
*/
-VALUE FileBuilderContext_initialize(VALUE _self, VALUE file_descriptor,
- VALUE builder) {
+VALUE FileBuilderContext_initialize(VALUE _self, VALUE descriptor_pool,
+ VALUE name, VALUE options) {
DEFINE_SELF(FileBuilderContext, self, _self);
- self->pending_list = rb_ary_new();
- self->file_descriptor = file_descriptor;
- self->builder = builder;
+ self->descriptor_pool = descriptor_pool;
+
+ google_protobuf_FileDescriptorProto_set_name(
+ self->file_proto, FileBuilderContext_strdup(_self, name));
+
+ // Default syntax for Ruby is proto3.
+ google_protobuf_FileDescriptorProto_set_syntax(
+ self->file_proto,
+ FileBuilderContext_strdup(_self, rb_str_new2("proto3")));
+
+ if (options != Qnil) {
+ VALUE syntax;
+
+ Check_Type(options, T_HASH);
+ syntax = rb_hash_lookup2(options, ID2SYM(rb_intern("syntax")), Qnil);
+
+ if (syntax != Qnil) {
+ VALUE syntax_str;
+
+ Check_Type(syntax, T_SYMBOL);
+ syntax_str = rb_id2str(SYM2ID(syntax));
+ google_protobuf_FileDescriptorProto_set_syntax(
+ self->file_proto, FileBuilderContext_strdup(_self, syntax_str));
+ }
+ }
+
return Qnil;
}
@@ -2009,14 +2026,10 @@
* This is the recommended, idiomatic way to build message definitions.
*/
VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
- DEFINE_SELF(FileBuilderContext, self, _self);
- VALUE msgdef = rb_class_new_instance(1, &self->file_descriptor, cDescriptor);
- VALUE args[2] = { msgdef, self->builder };
+ VALUE args[2] = { _self, name };
VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
VALUE block = rb_block_proc();
- rb_funcall(msgdef, rb_intern("name="), 1, name);
rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- rb_ary_push(self->pending_list, msgdef);
return Qnil;
}
@@ -2031,20 +2044,26 @@
* This is the recommended, idiomatic way to build enum definitions.
*/
VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name) {
- DEFINE_SELF(FileBuilderContext, self, _self);
- VALUE enumdef =
- rb_class_new_instance(1, &self->file_descriptor, cEnumDescriptor);
- VALUE ctx = rb_class_new_instance(1, &enumdef, cEnumBuilderContext);
+ VALUE args[2] = { _self, name };
+ VALUE ctx = rb_class_new_instance(2, args, cEnumBuilderContext);
VALUE block = rb_block_proc();
- rb_funcall(enumdef, rb_intern("name="), 1, name);
rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- rb_ary_push(self->pending_list, enumdef);
return Qnil;
}
-VALUE FileBuilderContext_pending_descriptors(VALUE _self) {
+void FileBuilderContext_build(VALUE _self) {
DEFINE_SELF(FileBuilderContext, self, _self);
- return self->pending_list;
+ DescriptorPool* pool = ruby_to_DescriptorPool(self->descriptor_pool);
+ upb_status status;
+
+ rewrite_enum_defaults(pool->symtab, self->file_proto);
+ rewrite_names(_self, self->file_proto);
+
+ upb_status_clear(&status);
+ if (!upb_symtab_addfile(pool->symtab, self->file_proto, &status)) {
+ rb_raise(cTypeError, "Unable to add defs to DescriptorPool: %s",
+ upb_status_errmsg(&status));
+ }
}
// -----------------------------------------------------------------------------
@@ -2055,58 +2074,46 @@
void Builder_mark(void* _self) {
Builder* self = _self;
- rb_gc_mark(self->pending_list);
- rb_gc_mark(self->default_file_descriptor);
+ rb_gc_mark(self->descriptor_pool);
+ rb_gc_mark(self->default_file_builder);
}
void Builder_free(void* _self) {
- Builder* self = _self;
- xfree(self->defs);
- xfree(self);
+ xfree(_self);
}
-/*
- * call-seq:
- * Builder.new => builder
- *
- * Creates a new Builder. A Builder can accumulate a set of new message and enum
- * descriptors and atomically register them into a pool in a way that allows for
- * (co)recursive type references.
- */
VALUE Builder_alloc(VALUE klass) {
Builder* self = ALLOC(Builder);
VALUE ret = TypedData_Wrap_Struct(
klass, &_Builder_type, self);
- self->pending_list = Qnil;
- self->defs = NULL;
- self->default_file_descriptor = Qnil;
+ self->descriptor_pool = Qnil;
+ self->default_file_builder = Qnil;
return ret;
}
void Builder_register(VALUE module) {
VALUE klass = rb_define_class_under(module, "Builder", rb_cObject);
- rb_define_alloc_func(klass, Builder_alloc);
- rb_define_method(klass, "initialize", Builder_initialize, 0);
+ rb_define_alloc_func(klass, Builder_alloc);
+ rb_define_method(klass, "initialize", Builder_initialize, 1);
rb_define_method(klass, "add_file", Builder_add_file, -1);
rb_define_method(klass, "add_message", Builder_add_message, 1);
rb_define_method(klass, "add_enum", Builder_add_enum, 1);
- rb_define_method(klass, "finalize_to_pool", Builder_finalize_to_pool, 1);
rb_gc_register_address(&cBuilder);
cBuilder = klass;
}
/*
* call-seq:
- * Builder.new
+ * Builder.new(descriptor_pool) => builder
*
- * Initializes a new builder.
+ * Creates a new Builder. A Builder can accumulate a set of new message and enum
+ * descriptors and atomically register them into a pool in a way that allows for
+ * (co)recursive type references.
*/
-VALUE Builder_initialize(VALUE _self) {
+VALUE Builder_initialize(VALUE _self, VALUE pool) {
DEFINE_SELF(Builder, self, _self);
- self->pending_list = rb_ary_new();
- VALUE file_name = Qnil;
- self->default_file_descriptor =
- rb_class_new_instance(1, &file_name, cFileDescriptor);
+ self->descriptor_pool = pool;
+ self->default_file_builder = Qnil; // Created lazily if needed.
return Qnil;
}
@@ -2123,17 +2130,38 @@
*/
VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
DEFINE_SELF(Builder, self, _self);
- VALUE file_descriptor = rb_class_new_instance(argc, argv, cFileDescriptor);
- VALUE args[2] = { file_descriptor, _self };
- VALUE ctx = rb_class_new_instance(2, args, cFileBuilderContext);
- VALUE block = rb_block_proc();
- rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+ VALUE name, options;
+ VALUE ctx;
+ VALUE block;
- rb_ary_concat(self->pending_list,
- FileBuilderContext_pending_descriptors(ctx));
+ rb_scan_args(argc, argv, "11", &name, &options);
+
+ {
+ VALUE args[3] = { self->descriptor_pool, name, options };
+ ctx = rb_class_new_instance(3, args, cFileBuilderContext);
+ }
+
+ block = rb_block_proc();
+ rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+ FileBuilderContext_build(ctx);
+
return Qnil;
}
+static VALUE Builder_get_default_file(VALUE _self) {
+ DEFINE_SELF(Builder, self, _self);
+
+ /* Lazily create only if legacy builder-level methods are called. */
+ if (self->default_file_builder == Qnil) {
+ VALUE name = rb_str_new2("ruby_default_file.proto");
+ VALUE args [3] = { self->descriptor_pool, name, rb_hash_new() };
+ self->default_file_builder =
+ rb_class_new_instance(3, args, cFileBuilderContext);
+ }
+
+ return self->default_file_builder;
+}
+
/*
* call-seq:
* Builder.add_message(name, &block)
@@ -2146,15 +2174,9 @@
* Descriptors created this way get assigned to a default empty FileDescriptor.
*/
VALUE Builder_add_message(VALUE _self, VALUE name) {
- DEFINE_SELF(Builder, self, _self);
- VALUE msgdef =
- rb_class_new_instance(1, &self->default_file_descriptor, cDescriptor);
- VALUE args[2] = { msgdef, _self };
- VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
- VALUE block = rb_block_proc();
- rb_funcall(msgdef, rb_intern("name="), 1, name);
- rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- rb_ary_push(self->pending_list, msgdef);
+ VALUE file_builder = Builder_get_default_file(_self);
+ rb_funcall_with_block(file_builder, rb_intern("add_message"), 1, &name,
+ rb_block_proc());
return Qnil;
}
@@ -2171,87 +2193,62 @@
* FileDescriptor.
*/
VALUE Builder_add_enum(VALUE _self, VALUE name) {
- DEFINE_SELF(Builder, self, _self);
- VALUE enumdef =
- rb_class_new_instance(1, &self->default_file_descriptor, cEnumDescriptor);
- VALUE ctx = rb_class_new_instance(1, &enumdef, cEnumBuilderContext);
- VALUE block = rb_block_proc();
- rb_funcall(enumdef, rb_intern("name="), 1, name);
- rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
- rb_ary_push(self->pending_list, enumdef);
+ VALUE file_builder = Builder_get_default_file(_self);
+ rb_funcall_with_block(file_builder, rb_intern("add_enum"), 1, &name,
+ rb_block_proc());
return Qnil;
}
-static void proto3_validate_msgdef(const upb_msgdef* msgdef) {
- // Verify that no required fields exist. proto3 does not support these.
- upb_msg_field_iter it;
- for (upb_msg_field_begin(&it, msgdef);
- !upb_msg_field_done(&it);
- upb_msg_field_next(&it)) {
- const upb_fielddef* field = upb_msg_iter_field(&it);
- if (upb_fielddef_label(field) == UPB_LABEL_REQUIRED) {
- rb_raise(cTypeError, "Required fields are unsupported in proto3.");
- }
- }
-}
-
-static void proto3_validate_enumdef(const upb_enumdef* enumdef) {
- // Verify that an entry exists with integer value 0. (This is the default
- // value.)
- const char* lookup = upb_enumdef_iton(enumdef, 0);
- if (lookup == NULL) {
- rb_raise(cTypeError,
- "Enum definition does not contain a value for '0'.");
- }
-}
-
-/*
- * call-seq:
- * Builder.finalize_to_pool(pool)
- *
- * Adds all accumulated message and enum descriptors created in this builder
- * context to the given pool. The operation occurs atomically, and all
- * descriptors can refer to each other (including in cycles). This is the only
- * way to build (co)recursive message definitions.
- *
- * This method is usually called automatically by DescriptorPool#build after it
- * invokes the given user block in the context of the builder. The user should
- * not normally need to call this manually because a Builder is not normally
- * created manually.
- */
-VALUE Builder_finalize_to_pool(VALUE _self, VALUE pool_rb) {
+/* This method is hidden from Ruby, and only called directly from
+ * DescriptorPool_build(). */
+VALUE Builder_build(VALUE _self) {
DEFINE_SELF(Builder, self, _self);
- DescriptorPool* pool = ruby_to_DescriptorPool(pool_rb);
-
- REALLOC_N(self->defs, upb_def*, RARRAY_LEN(self->pending_list));
-
- for (int i = 0; i < RARRAY_LEN(self->pending_list); i++) {
- VALUE def_rb = rb_ary_entry(self->pending_list, i);
- if (CLASS_OF(def_rb) == cDescriptor) {
- self->defs[i] = (upb_def*)ruby_to_Descriptor(def_rb)->msgdef;
-
- if (upb_filedef_syntax(upb_def_file(self->defs[i])) == UPB_SYNTAX_PROTO3) {
- proto3_validate_msgdef((const upb_msgdef*)self->defs[i]);
- }
- } else if (CLASS_OF(def_rb) == cEnumDescriptor) {
- self->defs[i] = (upb_def*)ruby_to_EnumDescriptor(def_rb)->enumdef;
-
- if (upb_filedef_syntax(upb_def_file(self->defs[i])) == UPB_SYNTAX_PROTO3) {
- proto3_validate_enumdef((const upb_enumdef*)self->defs[i]);
- }
- }
+ if (self->default_file_builder != Qnil) {
+ FileBuilderContext_build(self->default_file_builder);
+ self->default_file_builder = Qnil;
}
- CHECK_UPB(upb_symtab_add(pool->symtab, (upb_def**)self->defs,
- RARRAY_LEN(self->pending_list), NULL, &status),
- "Unable to add defs to DescriptorPool");
-
- for (int i = 0; i < RARRAY_LEN(self->pending_list); i++) {
- VALUE def_rb = rb_ary_entry(self->pending_list, i);
- add_def_obj(self->defs[i], def_rb);
- }
-
- self->pending_list = rb_ary_new();
return Qnil;
}
+
+static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
+ DEFINE_SELF(DescriptorPool, descriptor_pool, _descriptor_pool);
+ VALUE key = ULL2NUM((intptr_t)ptr);
+ VALUE def;
+
+ def = rb_hash_aref(descriptor_pool->def_to_descriptor, key);
+
+ if (ptr == NULL) {
+ return Qnil;
+ }
+
+ if (def == Qnil) {
+ // Lazily create wrapper object.
+ VALUE args[3] = { c_only_cookie, _descriptor_pool, key };
+ def = rb_class_new_instance(3, args, klass);
+ rb_hash_aset(descriptor_pool->def_to_descriptor, key, def);
+ }
+
+ return def;
+}
+
+VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def) {
+ return get_def_obj(descriptor_pool, def, cDescriptor);
+}
+
+VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def) {
+ return get_def_obj(descriptor_pool, def, cEnumDescriptor);
+}
+
+VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_fielddef* def) {
+ return get_def_obj(descriptor_pool, def, cFieldDescriptor);
+}
+
+VALUE get_filedef_obj(VALUE descriptor_pool, const upb_filedef* def) {
+ return get_def_obj(descriptor_pool, def, cFileDescriptor);
+}
+
+VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def) {
+ return get_def_obj(descriptor_pool, def, cOneofDescriptor);
+}
