Skip to content

P
protobuf
Unverified Commit 1568deab authored by Joshua Haberman's avatar Joshua Haberman Committed by GitHub
Browse files
Options

Revert "Updated upb from defcleanup branch and modified Ruby to use it (#5539)" (#5848) 

This reverts commit 37581380.
parent d0f91c86
Show whitespace changes
Inline Side-by-side
Showing with 1181 additions and 1119 deletions
ruby/ext/google/protobuf_c/defs.c
View file @ 1568deab
......@@ -28,8 +28,6 @@
// (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"
// -----------------------------------------------------------------------------
......@@ -48,292 +46,29 @@ static VALUE rb_str_maybe_null(const char* s) {
return rb_str_new2(s);
}
static void rewrite_enum_default(const upb_symtab* symtab,
google_protobuf_FileDescriptorProto* file,
google_protobuf_FieldDescriptorProto* field) {
/* 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;
}
upb_strview defaultval =
google_protobuf_FieldDescriptorProto_default_value(field);
upb_strview 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;
}
const char *type_name_str = type_name.data + 1;
char *end;
errno = 0;
long val = strtol(defaultval.data, &end, 10);
if (errno != 0 || *end != 0 || val < INT32_MIN || val > INT32_MAX) {
return;
}
/* Now find the corresponding enum definition. */
const upb_enumdef *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);
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;
}
const google_protobuf_EnumValueDescriptorProto* const* 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_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.");
}
return (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_msgdef* check_msg_notfrozen(const upb_msgdef* def) {
return upb_downcast_msgdef_mutable(check_notfrozen((const upb_def*)def));
}
static bool has_prefix(upb_strview str, upb_strview prefix) {
return str.size >= prefix.size &&
memcmp(str.data, prefix.data, prefix.size) == 0;
static upb_fielddef* check_field_notfrozen(const upb_fielddef* def) {
return upb_downcast_fielddef_mutable(check_notfrozen((const upb_def*)def));
}
static void remove_package(upb_strview *name, upb_strview package) {
size_t prefix_len = package.size + 1;
if (!has_prefix(*name, package) || prefix_len >= name->size ||
name->data[package.size] != '.') {
rb_raise(cTypeError,
"Bad package name, wasn't prefix: " UPB_STRVIEW_FORMAT
", " UPB_STRVIEW_FORMAT,
UPB_STRVIEW_ARGS(*name), UPB_STRVIEW_ARGS(package));
}
name->data += prefix_len;
name->size -= prefix_len;
}
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 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")));
Check_Type(submsgs, T_ARRAY);
Check_Type(enum_pos, T_ARRAY);
int submsg_count = RARRAY_LEN(submsgs);
int enum_count = RARRAY_LEN(enum_pos);
google_protobuf_DescriptorProto** msg_msgs =
google_protobuf_DescriptorProto_resize_nested_type(msg, submsg_count,
arena);
google_protobuf_EnumDescriptorProto** msg_enums =
google_protobuf_DescriptorProto_resize_enum_type(msg, enum_count, arena);
for (int i = 0; i < submsg_count; i++) {
VALUE submsg_ent = RARRAY_PTR(submsgs)[i];
VALUE pos = rb_hash_aref(submsg_ent, ID2SYM(rb_intern("pos")));
msg_msgs[i] = msgs[NUM2INT(pos)];
upb_strview 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 (int i = 0; i < enum_count; i++) {
VALUE pos = RARRAY_PTR(enum_pos)[i];
msg_enums[i] = enums[NUM2INT(pos)];
}
}
/* 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;
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);
}
google_protobuf_DescriptorProto** 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));
}
google_protobuf_EnumDescriptorProto** 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);
VALUE new_package = rb_ary_entry(ret, 0);
VALUE nesting = rb_ary_entry(ret, 1);
if (package == Qnil && new_package != Qnil) {
// We inferred a package name; set this package name on the file and remove
// the prefix from all msg/enum names.
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_package(&name, new_package_str);
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_package(&name, new_package_str);
google_protobuf_EnumDescriptorProto_set_name(enums[i], name);
}
}
VALUE msg_ents = rb_hash_aref(nesting, ID2SYM(rb_intern("msgs")));
VALUE 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 < 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 < RARRAY_LEN(enum_ents); i++) {
VALUE enum_pos = rb_ary_entry(enum_ents, i);
enums[i] = enums[NUM2INT(enum_pos)];
}
static upb_oneofdef* check_oneof_notfrozen(const upb_oneofdef* def) {
return (upb_oneofdef*)check_notfrozen((const upb_def*)def);
}
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);
static upb_enumdef* check_enum_notfrozen(const upb_enumdef* def) {
return (upb_enumdef*)check_notfrozen((const upb_def*)def);
}
// -----------------------------------------------------------------------------
......@@ -362,21 +97,11 @@ VALUE generated_pool;
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);
}
......@@ -388,26 +113,15 @@ void DescriptorPool_free(void* _self) {
*/
VALUE DescriptorPool_alloc(VALUE klass) {
DescriptorPool* self = ALLOC(DescriptorPool);
self->def_to_descriptor = rb_hash_new();
VALUE ret = TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
self->symtab = upb_symtab_new();
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;
return TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
}
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",
......@@ -419,6 +133,44 @@ void DescriptorPool_register(VALUE module) {
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)
......@@ -430,10 +182,10 @@ void DescriptorPool_register(VALUE module) {
* idiomatic way to define new message and enum types.
*/
VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
VALUE ctx = rb_class_new_instance(1, &_self, cBuilder);
VALUE ctx = rb_class_new_instance(0, NULL, cBuilder);
VALUE block = rb_block_proc();
rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
Builder_build(ctx);
rb_funcall(ctx, rb_intern("finalize_to_pool"), 1, _self);
return Qnil;
}
......@@ -447,18 +199,11 @@ VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
DEFINE_SELF(DescriptorPool, self, _self);
const char* name_str = get_str(name);
const upb_msgdef* msgdef = upb_symtab_lookupmsg(self->symtab, name_str);
if (msgdef) {
return get_msgdef_obj(_self, msgdef);
}
const upb_enumdef* enumdef = upb_symtab_lookupenum(self->symtab, name_str);
if (enumdef) {
return get_enumdef_obj(_self, enumdef);
}
const upb_def* def = upb_symtab_lookup(self->symtab, name_str);
if (!def) {
return Qnil;
}
return get_def_obj(def);
}
/*
......@@ -483,14 +228,36 @@ DEFINE_CLASS(Descriptor, "Google::Protobuf::Descriptor");
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);
}
......@@ -506,10 +273,15 @@ void Descriptor_free(void* _self) {
VALUE Descriptor_alloc(VALUE klass) {
Descriptor* self = ALLOC(Descriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_Descriptor_type, self);
self->msgdef = NULL;
self->msgdef = upb_msgdef_new(&self->msgdef);
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;
}
......@@ -517,13 +289,16 @@ void Descriptor_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "Descriptor", rb_cObject);
rb_define_alloc_func(klass, Descriptor_alloc);
rb_define_method(klass, "initialize", Descriptor_initialize, 3);
rb_define_method(klass, "initialize", Descriptor_initialize, 1);
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);
......@@ -532,21 +307,19 @@ void Descriptor_register(VALUE module) {
/*
* call-seq:
* Descriptor.new(c_only_cookie, ptr) => Descriptor
* Descriptor.new(file_descriptor)
*
* Creates a descriptor wrapper object. May only be called from C.
* Initializes a new descriptor and assigns a file descriptor to it.
*/
VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr) {
VALUE Descriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
DEFINE_SELF(Descriptor, self, _self);
if (cookie != c_only_cookie) {
rb_raise(rb_eRuntimeError,
"Descriptor objects may not be created from Ruby.");
}
FileDescriptor* file_descriptor = ruby_to_FileDescriptor(file_descriptor_rb);
self->descriptor_pool = descriptor_pool;
self->msgdef = (const upb_msgdef*)NUM2ULL(ptr);
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);
return Qnil;
}
......@@ -559,7 +332,7 @@ VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
*/
VALUE Descriptor_file_descriptor(VALUE _self) {
DEFINE_SELF(Descriptor, self, _self);
return get_filedef_obj(self->descriptor_pool, upb_msgdef_file(self->msgdef));
return get_def_obj(upb_def_file(self->msgdef));
}
/*
......@@ -574,6 +347,23 @@ VALUE Descriptor_name(VALUE _self) {
return rb_str_maybe_null(upb_msgdef_fullname(self->msgdef));
}
/*
* 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)
......@@ -588,7 +378,7 @@ VALUE Descriptor_each(VALUE _self) {
!upb_msg_field_done(&it);
upb_msg_field_next(&it)) {
const upb_fielddef* field = upb_msg_iter_field(&it);
VALUE obj = get_fielddef_obj(self->descriptor_pool, field);
VALUE obj = get_def_obj(field);
rb_yield(obj);
}
return Qnil;
......@@ -608,7 +398,51 @@ VALUE Descriptor_lookup(VALUE _self, VALUE name) {
if (field == NULL) {
return Qnil;
}
return get_fielddef_obj(self->descriptor_pool, field);
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;
}
/*
......@@ -626,7 +460,7 @@ VALUE Descriptor_each_oneof(VALUE _self) {
!upb_msg_oneof_done(&it);
upb_msg_oneof_next(&it)) {
const upb_oneofdef* oneof = upb_msg_iter_oneof(&it);
VALUE obj = get_oneofdef_obj(self->descriptor_pool, oneof);
VALUE obj = get_def_obj(oneof);
rb_yield(obj);
}
return Qnil;
......@@ -646,19 +480,24 @@ VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
if (oneof == NULL) {
return Qnil;
}
return get_oneofdef_obj(self->descriptor_pool, oneof);
return get_def_obj(oneof);
}
/*
* call-seq:
* Descriptor.msgclass => message_klass
*
* Returns the Ruby class created for this message type.
* Returns the Ruby class created for this message type. Valid only once the
* message type has been added to a pool.
*/
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;
}
......@@ -670,20 +509,12 @@ VALUE Descriptor_msgclass(VALUE _self) {
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) {
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;
FileDescriptor* self = _self;
upb_filedef_unref(self->filedef, &self->filedef);
xfree(self);
}
/*
......@@ -693,32 +524,64 @@ VALUE FileDescriptor_alloc(VALUE klass) {
* Returns a new file descriptor. The syntax must be set before it's passed
* to a builder.
*/
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;
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;
}
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, 3);
rb_define_method(klass, "initialize", FileDescriptor_initialize, -1);
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
......@@ -750,6 +613,31 @@ VALUE FileDescriptor_syntax(VALUE _self) {
}
}
/*
* 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.
// -----------------------------------------------------------------------------
......@@ -757,12 +645,12 @@ VALUE FileDescriptor_syntax(VALUE _self) {
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) {
xfree(_self);
FieldDescriptor* self = _self;
upb_fielddef_unref(self->fielddef, &self->fielddef);
xfree(self);
}
/*
......@@ -775,7 +663,9 @@ void FieldDescriptor_free(void* _self) {
VALUE FieldDescriptor_alloc(VALUE klass) {
FieldDescriptor* self = ALLOC(FieldDescriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_FieldDescriptor_type, self);
self->fielddef = NULL;
upb_fielddef* fielddef = upb_fielddef_new(&self->fielddef);
upb_fielddef_setpacked(fielddef, false);
self->fielddef = fielddef;
return ret;
}
......@@ -783,13 +673,18 @@ void FieldDescriptor_register(VALUE module) {
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);
......@@ -801,34 +696,29 @@ void FieldDescriptor_register(VALUE module) {
/*
* call-seq:
* EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
* FieldDescriptor.name => name
*
* Creates a descriptor wrapper object. May only be called from C.
* Returns the name of this field.
*/
VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr) {
VALUE FieldDescriptor_name(VALUE _self) {
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;
return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
}
/*
* call-seq:
* FieldDescriptor.name => name
* FieldDescriptor.name = name
*
* Returns the name of this field.
* Sets the name of this field. Cannot be called once the containing message
* type, if any, is added to a pool.
*/
VALUE FieldDescriptor_name(VALUE _self) {
VALUE FieldDescriptor_name_set(VALUE _self, VALUE str) {
DEFINE_SELF(FieldDescriptor, self, _self);
return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
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) {
......@@ -941,29 +831,6 @@ VALUE descriptortype_to_ruby(upb_descriptortype_t type) {
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
......@@ -976,9 +843,26 @@ VALUE ruby_to_label(VALUE label) {
*/
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
......@@ -990,6 +874,60 @@ VALUE FieldDescriptor_default(VALUE _self) {
return layout_get_default(self->fielddef);
}
/*
* 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
......@@ -1015,6 +953,44 @@ VALUE FieldDescriptor_label(VALUE _self) {
return Qnil;
}
/*
* 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
......@@ -1026,6 +1002,21 @@ VALUE FieldDescriptor_number(VALUE _self) {
return INT2NUM(upb_fielddef_number(self->fielddef));
}
/*
* 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
......@@ -1037,16 +1028,32 @@ VALUE FieldDescriptor_number(VALUE _self) {
*/
VALUE FieldDescriptor_submsg_name(VALUE _self) {
DEFINE_SELF(FieldDescriptor, self, _self);
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:
if (!upb_fielddef_hassubdef(self->fielddef)) {
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;
}
/*
......@@ -1060,16 +1067,16 @@ VALUE FieldDescriptor_submsg_name(VALUE _self) {
*/
VALUE FieldDescriptor_subtype(VALUE _self) {
DEFINE_SELF(FieldDescriptor, self, _self);
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:
const upb_def* def;
if (!upb_fielddef_hassubdef(self->fielddef)) {
return Qnil;
}
def = upb_fielddef_subdef(self->fielddef);
if (def == NULL) {
return Qnil;
}
return get_def_obj(def);
}
/*
......@@ -1153,12 +1160,12 @@ VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
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) {
xfree(_self);
OneofDescriptor* self = _self;
upb_oneofdef_unref(self->oneofdef, &self->oneofdef);
xfree(self);
}
/*
......@@ -1171,8 +1178,7 @@ void OneofDescriptor_free(void* _self) {
VALUE OneofDescriptor_alloc(VALUE klass) {
OneofDescriptor* self = ALLOC(OneofDescriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_OneofDescriptor_type, self);
self->oneofdef = NULL;
self->descriptor_pool = Qnil;
self->oneofdef = upb_oneofdef_new(&self->oneofdef);
return ret;
}
......@@ -1180,8 +1186,9 @@ void OneofDescriptor_register(VALUE module) {
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);
......@@ -1190,34 +1197,55 @@ void OneofDescriptor_register(VALUE module) {
/*
* call-seq:
* OneofDescriptor.new(c_only_cookie, pool, ptr) => OneofDescriptor
* OneofDescriptor.name => name
*
* Creates a descriptor wrapper object. May only be called from C.
* Returns the name of this oneof.
*/
VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr) {
VALUE OneofDescriptor_name(VALUE _self) {
DEFINE_SELF(OneofDescriptor, self, _self);
return rb_str_maybe_null(upb_oneofdef_name(self->oneofdef));
}
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);
/*
* 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.name => name
* OneofDescriptor.add_field(field) => nil
*
* Returns the name of this oneof.
* 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_name(VALUE _self) {
VALUE OneofDescriptor_add_field(VALUE _self, VALUE obj) {
DEFINE_SELF(OneofDescriptor, self, _self);
return rb_str_maybe_null(upb_oneofdef_name(self->oneofdef));
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;
}
/*
......@@ -1233,7 +1261,7 @@ VALUE OneofDescriptor_each(VALUE _self, VALUE field) {
!upb_oneof_done(&it);
upb_oneof_next(&it)) {
const upb_fielddef* f = upb_oneof_iter_field(&it);
VALUE obj = get_fielddef_obj(self->descriptor_pool, f);
VALUE obj = get_def_obj(f);
rb_yield(obj);
}
return Qnil;
......@@ -1248,49 +1276,38 @@ DEFINE_CLASS(EnumDescriptor, "Google::Protobuf::EnumDescriptor");
void EnumDescriptor_mark(void* _self) {
EnumDescriptor* self = _self;
rb_gc_mark(self->module);
rb_gc_mark(self->descriptor_pool);
}
void EnumDescriptor_free(void* _self) {
xfree(_self);
EnumDescriptor* self = _self;
upb_enumdef_unref(self->enumdef, &self->enumdef);
xfree(self);
}
/*
* call-seq:
* EnumDescriptor.new => enum_descriptor
*
* 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.
*/
VALUE EnumDescriptor_alloc(VALUE klass) {
EnumDescriptor* self = ALLOC(EnumDescriptor);
VALUE ret = TypedData_Wrap_Struct(klass, &_EnumDescriptor_type, self);
self->enumdef = NULL;
self->enumdef = upb_enumdef_new(&self->enumdef);
self->module = Qnil;
self->descriptor_pool = Qnil;
return ret;
}
/*
* call-seq:
* EnumDescriptor.new(c_only_cookie, ptr) => EnumDescriptor
*
* Creates a descriptor wrapper object. May only be called from C.
*/
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, 3);
rb_define_method(klass, "initialize", EnumDescriptor_initialize, 1);
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);
......@@ -1303,14 +1320,31 @@ void EnumDescriptor_register(VALUE module) {
/*
* call-seq:
* EnumDescriptor.file_descriptor
* 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
*
* Returns the FileDescriptor object this enum belongs to.
*/
VALUE EnumDescriptor_file_descriptor(VALUE _self) {
DEFINE_SELF(EnumDescriptor, self, _self);
return get_filedef_obj(self->descriptor_pool,
upb_enumdef_file(self->enumdef));
return get_def_obj(upb_def_file(self->enumdef));
}
/*
......@@ -1324,6 +1358,40 @@ VALUE EnumDescriptor_name(VALUE _self) {
return rb_str_maybe_null(upb_enumdef_fullname(self->enumdef));
}
/*
* 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
......@@ -1386,12 +1454,18 @@ VALUE EnumDescriptor_each(VALUE _self) {
* call-seq:
* EnumDescriptor.enummodule => module
*
* Returns the Ruby module corresponding to this enum type.
* Returns the Ruby module corresponding to this enum type. Cannot be called
* until the enum descriptor has been added to a pool.
*/
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;
}
......@@ -1405,7 +1479,8 @@ DEFINE_CLASS(MessageBuilderContext,
void MessageBuilderContext_mark(void* _self) {
MessageBuilderContext* self = _self;
rb_gc_mark(self->file_builder);
rb_gc_mark(self->descriptor);
rb_gc_mark(self->builder);
}
void MessageBuilderContext_free(void* _self) {
......@@ -1417,7 +1492,8 @@ VALUE MessageBuilderContext_alloc(VALUE klass) {
MessageBuilderContext* self = ALLOC(MessageBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_MessageBuilderContext_type, self);
self->file_builder = Qnil;
self->descriptor = Qnil;
self->builder = Qnil;
return ret;
}
......@@ -1438,57 +1514,40 @@ void MessageBuilderContext_register(VALUE module) {
/*
* call-seq:
* MessageBuilderContext.new(file_builder, name) => context
* MessageBuilderContext.new(desc, builder) => 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 _file_builder,
VALUE name) {
VALUE msgdef,
VALUE builder) {
DEFINE_SELF(MessageBuilderContext, self, _self);
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));
self->descriptor = msgdef;
self->builder = builder;
return Qnil;
}
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 =
google_protobuf_DescriptorProto_add_field(self->msg_proto,
file_context->arena);
Check_Type(name, T_SYMBOL);
VALUE name_str = rb_id2str(SYM2ID(name));
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)));
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));
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);
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);
google_protobuf_FieldDescriptorProto_set_type_name(
field_proto, FileBuilderContext_strdup(self->file_builder, type_class));
rb_funcall(fielddef_rb, rb_intern("submsg_name="), 1, type_class);
}
if (options != Qnil) {
......@@ -1496,51 +1555,24 @@ static void msgdef_add_field(VALUE msgbuilder_rb, upb_label_t label, VALUE name,
if (rb_funcall(options, rb_intern("key?"), 1,
ID2SYM(rb_intern("default"))) == Qtrue) {
VALUE default_value =
rb_hash_lookup(options, ID2SYM(rb_intern("default")));
/* Call #to_s since all defaults are strings in the descriptor. */
default_value = rb_funcall(default_value, rb_intern("to_s"), 0);
google_protobuf_FieldDescriptorProto_set_default_value(
field_proto,
FileBuilderContext_strdup(self->file_builder, default_value));
}
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.");
}
if (oneof_index >= 0) {
google_protobuf_FieldDescriptorProto_set_oneof_index(field_proto,
oneof_index);
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.");
}
}
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);
rb_funcall(fielddef_rb, rb_intern("default="), 1,
rb_hash_lookup(options, ID2SYM(rb_intern("default"))));
}
}
return Qnil;
rb_funcall(msgdef_rb, rb_intern("add_field"), 1, fielddef_rb);
return fielddef_rb;
}
/*
......@@ -1567,10 +1599,8 @@ VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
type_class = Qnil;
}
msgdef_add_field(_self, UPB_LABEL_OPTIONAL, name, type, number, type_class,
options, -1);
return Qnil;
return msgdef_add_field(self->descriptor, "optional",
name, type, number, type_class, options);
}
/*
......@@ -1601,10 +1631,8 @@ VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
type_class = Qnil;
}
msgdef_add_field(_self, UPB_LABEL_REQUIRED, name, type, number, type_class,
options, -1);
return Qnil;
return msgdef_add_field(self->descriptor, "required",
name, type, number, type_class, options);
}
/*
......@@ -1628,10 +1656,8 @@ VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
number = argv[2];
type_class = (argc > 3) ? argv[3] : Qnil;
msgdef_add_field(_self, UPB_LABEL_REPEATED, name, type, number, type_class,
Qnil, -1);
return Qnil;
return msgdef_add_field(self->descriptor, "repeated",
name, type, number, type_class, Qnil);
}
/*
......@@ -1672,43 +1698,77 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
"type.");
}
FileBuilderContext* 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"))) {
Descriptor* descriptor = ruby_to_Descriptor(self->descriptor);
if (upb_msgdef_syntax(descriptor->msgdef) == UPB_SYNTAX_PROTO2) {
rb_raise(rb_eArgError,
"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.
upb_strview msg_name = google_protobuf_DescriptorProto_name(self->msg_proto);
mapentry_desc_name = rb_str_new(msg_name.data, msg_name.size);
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);
mapentry_desc_name = rb_str_cat2(mapentry_desc_name, "_MapEntry_");
mapentry_desc_name =
rb_str_cat2(mapentry_desc_name, rb_id2name(SYM2ID(name)));
mapentry_desc_name = rb_str_cat2(mapentry_desc_name,
rb_id2name(SYM2ID(name)));
Descriptor_name_set(mapentry_desc, mapentry_desc_name);
// 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);
{
// 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);
}
// 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> 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);
}
// repeated MapEntry <name> = <number>;
rb_funcall(_self, rb_intern("repeated"), 4, name,
ID2SYM(rb_intern("message")), number, 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);
}
return Qnil;
}
......@@ -1726,26 +1786,14 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
*/
VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
DEFINE_SELF(MessageBuilderContext, self, _self);
size_t oneof_count;
FileBuilderContext* file_context =
ruby_to_FileBuilderContext(self->file_builder);
// Existing oneof_count becomes oneof_index.
google_protobuf_DescriptorProto_oneof_decl(self->msg_proto, &oneof_count);
// Create oneof_proto and set its name.
google_protobuf_OneofDescriptorProto* oneof_proto =
google_protobuf_DescriptorProto_add_oneof_decl(self->msg_proto,
file_context->arena);
VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
upb_strview name_strview = upb_strview_makez(StringValueCStr(name_str));
google_protobuf_OneofDescriptorProto_set_name(oneof_proto, name_strview);
// Evaluate the block with the builder as argument.
VALUE args[2] = { INT2NUM(oneof_count), _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);
return Qnil;
}
......@@ -1759,19 +1807,21 @@ DEFINE_CLASS(OneofBuilderContext,
void OneofBuilderContext_mark(void* _self) {
OneofBuilderContext* self = _self;
rb_gc_mark(self->message_builder);
rb_gc_mark(self->descriptor);
rb_gc_mark(self->builder);
}
void OneofBuilderContext_free(void* _self) {
xfree(_self);
OneofBuilderContext* self = _self;
xfree(self);
}
VALUE OneofBuilderContext_alloc(VALUE klass) {
OneofBuilderContext* self = ALLOC(OneofBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_OneofBuilderContext_type, self);
self->oneof_index = 0;
self->message_builder = Qnil;
self->descriptor = Qnil;
self->builder = Qnil;
return ret;
}
......@@ -1788,18 +1838,18 @@ void OneofBuilderContext_register(VALUE module) {
/*
* call-seq:
* OneofBuilderContext.new(oneof_index, message_builder) => context
* OneofBuilderContext.new(desc, 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 oneof_index,
VALUE message_builder) {
VALUE oneofdef,
VALUE builder) {
DEFINE_SELF(OneofBuilderContext, self, _self);
self->oneof_index = NUM2INT(oneof_index);
self->message_builder = message_builder;
self->descriptor = oneofdef;
self->builder = builder;
return Qnil;
}
......@@ -1820,10 +1870,8 @@ VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
rb_scan_args(argc, argv, "32", &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;
return msgdef_add_field(self->descriptor, "optional",
name, type, number, type_class, options);
}
// -----------------------------------------------------------------------------
......@@ -1835,19 +1883,19 @@ DEFINE_CLASS(EnumBuilderContext,
void EnumBuilderContext_mark(void* _self) {
EnumBuilderContext* self = _self;
rb_gc_mark(self->file_builder);
rb_gc_mark(self->enumdesc);
}
void EnumBuilderContext_free(void* _self) {
xfree(_self);
EnumBuilderContext* self = _self;
xfree(self);
}
VALUE EnumBuilderContext_alloc(VALUE klass) {
EnumBuilderContext* self = ALLOC(EnumBuilderContext);
VALUE ret = TypedData_Wrap_Struct(
klass, &_EnumBuilderContext_type, self);
self->enum_proto = NULL;
self->file_builder = Qnil;
self->enumdesc = Qnil;
return ret;
}
......@@ -1855,7 +1903,8 @@ void EnumBuilderContext_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "EnumBuilderContext", rb_cObject);
rb_define_alloc_func(klass, EnumBuilderContext_alloc);
rb_define_method(klass, "initialize", EnumBuilderContext_initialize, 2);
rb_define_method(klass, "initialize",
EnumBuilderContext_initialize, 1);
rb_define_method(klass, "value", EnumBuilderContext_value, 2);
rb_gc_register_address(&cEnumBuilderContext);
cEnumBuilderContext = klass;
......@@ -1863,24 +1912,20 @@ void EnumBuilderContext_register(VALUE module) {
/*
* call-seq:
* EnumBuilderContext.new(file_builder) => context
* EnumBuilderContext.new(enumdesc) => 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 _file_builder,
VALUE name) {
VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdef) {
DEFINE_SELF(EnumBuilderContext, self, _self);
FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
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));
self->enumdesc = enumdef;
return Qnil;
}
static VALUE enumdef_add_value(VALUE enumdef,
VALUE name, VALUE number) {
rb_funcall(enumdef, rb_intern("add_value"), 2, name, number);
return Qnil;
}
......@@ -1893,21 +1938,7 @@ VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
*/
VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
DEFINE_SELF(EnumBuilderContext, self, _self);
FileBuilderContext* file_builder =
ruby_to_FileBuilderContext(self->file_builder);
Check_Type(name, T_SYMBOL);
VALUE name_str = rb_id2str(SYM2ID(name));
google_protobuf_EnumValueDescriptorProto* enum_value =
google_protobuf_EnumDescriptorProto_add_value(self->enum_proto,
file_builder->arena);
google_protobuf_EnumValueDescriptorProto_set_name(
enum_value, FileBuilderContext_strdup(self->file_builder, name_str));
google_protobuf_EnumValueDescriptorProto_set_number(enum_value,
NUM2INT(number));
return Qnil;
return enumdef_add_value(self->enumdesc, name, number);
}
......@@ -1920,45 +1951,29 @@ DEFINE_CLASS(FileBuilderContext,
void FileBuilderContext_mark(void* _self) {
FileBuilderContext* self = _self;
rb_gc_mark(self->descriptor_pool);
rb_gc_mark(self->pending_list);
rb_gc_mark(self->file_descriptor);
rb_gc_mark(self->builder);
}
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;
ret.size = strlen(str);
char *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) {
const char *str = get_str(rb_str);
return FileBuilderContext_strdup2(_self, str);
}
VALUE FileBuilderContext_alloc(VALUE klass) {
FileBuilderContext* self = ALLOC(FileBuilderContext);
VALUE ret = TypedData_Wrap_Struct(klass, &_FileBuilderContext_type, self);
self->arena = upb_arena_new();
self->file_proto = google_protobuf_FileDescriptorProto_new(self->arena);
self->descriptor_pool = Qnil;
self->pending_list = Qnil;
self->file_descriptor = Qnil;
self->builder = 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, 3);
rb_define_method(klass, "initialize", FileBuilderContext_initialize, 2);
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);
......@@ -1967,38 +1982,18 @@ void FileBuilderContext_register(VALUE module) {
/*
* call-seq:
* FileBuilderContext.new(descriptor_pool) => context
* FileBuilderContext.new(file_descriptor, builder) => 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 descriptor_pool,
VALUE name, VALUE options) {
VALUE FileBuilderContext_initialize(VALUE _self, VALUE file_descriptor,
VALUE builder) {
DEFINE_SELF(FileBuilderContext, self, _self);
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) {
Check_Type(options, T_HASH);
VALUE syntax = rb_hash_lookup2(options, ID2SYM(rb_intern("syntax")), Qnil);
if (syntax != Qnil) {
Check_Type(syntax, T_SYMBOL);
VALUE syntax_str = rb_id2str(SYM2ID(syntax));
google_protobuf_FileDescriptorProto_set_syntax(
self->file_proto, FileBuilderContext_strdup(_self, syntax_str));
}
}
self->pending_list = rb_ary_new();
self->file_descriptor = file_descriptor;
self->builder = builder;
return Qnil;
}
......@@ -2015,10 +2010,13 @@ VALUE FileBuilderContext_initialize(VALUE _self, VALUE descriptor_pool,
*/
VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
DEFINE_SELF(FileBuilderContext, self, _self);
VALUE args[2] = { _self, name };
VALUE msgdef = rb_class_new_instance(1, &self->file_descriptor, cDescriptor);
VALUE args[2] = { msgdef, self->builder };
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;
}
......@@ -2034,26 +2032,19 @@ VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
*/
VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name) {
DEFINE_SELF(FileBuilderContext, self, _self);
VALUE args[2] = { _self, name };
VALUE ctx = rb_class_new_instance(2, args, cEnumBuilderContext);
VALUE enumdef =
rb_class_new_instance(1, &self->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);
return Qnil;
}
void FileBuilderContext_build(VALUE _self) {
VALUE FileBuilderContext_pending_descriptors(VALUE _self) {
DEFINE_SELF(FileBuilderContext, self, _self);
DescriptorPool* pool = ruby_to_DescriptorPool(self->descriptor_pool);
rewrite_enum_defaults(pool->symtab, self->file_proto);
rewrite_names(_self, self->file_proto);
upb_status status;
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));
}
return self->pending_list;
}
// -----------------------------------------------------------------------------
......@@ -2064,46 +2055,58 @@ DEFINE_CLASS(Builder, "Google::Protobuf::Internal::Builder");
void Builder_mark(void* _self) {
Builder* self = _self;
rb_gc_mark(self->descriptor_pool);
rb_gc_mark(self->default_file_builder);
rb_gc_mark(self->pending_list);
rb_gc_mark(self->default_file_descriptor);
}
void Builder_free(void* _self) {
xfree(_self);
Builder* self = _self;
xfree(self->defs);
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->descriptor_pool = Qnil;
self->default_file_builder = Qnil;
self->pending_list = Qnil;
self->defs = NULL;
self->default_file_descriptor = 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, 1);
rb_define_method(klass, "initialize", Builder_initialize, 0);
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(descriptor_pool) => builder
* Builder.new
*
* 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.
* Initializes a new builder.
*/
VALUE Builder_initialize(VALUE _self, VALUE pool) {
VALUE Builder_initialize(VALUE _self) {
DEFINE_SELF(Builder, self, _self);
self->descriptor_pool = pool;
self->default_file_builder = Qnil; // Created lazily if needed.
self->pending_list = rb_ary_new();
VALUE file_name = Qnil;
self->default_file_descriptor =
rb_class_new_instance(1, &file_name, cFileDescriptor);
return Qnil;
}
......@@ -2120,34 +2123,17 @@ VALUE Builder_initialize(VALUE _self, VALUE pool) {
*/
VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
DEFINE_SELF(Builder, self, _self);
VALUE name, options;
rb_scan_args(argc, argv, "11", &name, &options);
VALUE args[3] = { self->descriptor_pool, name, options };
VALUE ctx = rb_class_new_instance(3, args, cFileBuilderContext);
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);
FileBuilderContext_build(ctx);
rb_ary_concat(self->pending_list,
FileBuilderContext_pending_descriptors(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)
......@@ -2161,9 +2147,14 @@ static VALUE Builder_get_default_file(VALUE _self) {
*/
VALUE Builder_add_message(VALUE _self, VALUE name) {
DEFINE_SELF(Builder, self, _self);
VALUE file_builder = Builder_get_default_file(_self);
rb_funcall_with_block(file_builder, rb_intern("add_message"), 1, &name,
rb_block_proc());
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);
return Qnil;
}
......@@ -2181,60 +2172,86 @@ VALUE Builder_add_message(VALUE _self, VALUE name) {
*/
VALUE Builder_add_enum(VALUE _self, VALUE name) {
DEFINE_SELF(Builder, self, _self);
VALUE file_builder = Builder_get_default_file(_self);
rb_funcall_with_block(file_builder, rb_intern("add_enum"), 1, &name,
rb_block_proc());
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);
return Qnil;
}
/* This method is hidden from Ruby, and only called directly from
* DescriptorPool_build(). */
VALUE Builder_build(VALUE _self) {
DEFINE_SELF(Builder, self, _self);
if (self->default_file_builder != Qnil) {
FileBuilderContext_build(self->default_file_builder);
self->default_file_builder = 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.");
}
}
}
return Qnil;
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'.");
}
}
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 = rb_hash_aref(descriptor_pool->def_to_descriptor, key);
/*
* 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) {
DEFINE_SELF(Builder, self, _self);
if (ptr == NULL) {
return Qnil;
}
DescriptorPool* pool = ruby_to_DescriptorPool(pool_rb);
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);
}
REALLOC_N(self->defs, upb_def*, RARRAY_LEN(self->pending_list));
return def;
}
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;
VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def) {
return get_def_obj(descriptor_pool, def, cDescriptor);
}
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;
VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def) {
return get_def_obj(descriptor_pool, def, cEnumDescriptor);
}
if (upb_filedef_syntax(upb_def_file(self->defs[i])) == UPB_SYNTAX_PROTO3) {
proto3_validate_enumdef((const upb_enumdef*)self->defs[i]);
}
}
}
VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_fielddef* def) {
return get_def_obj(descriptor_pool, def, cFieldDescriptor);
}
CHECK_UPB(upb_symtab_add(pool->symtab, (upb_def**)self->defs,
RARRAY_LEN(self->pending_list), NULL, &status),
"Unable to add defs to DescriptorPool");
VALUE get_filedef_obj(VALUE descriptor_pool, const upb_filedef* def) {
return get_def_obj(descriptor_pool, def, cFileDescriptor);
}
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);
}
VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def) {
return get_def_obj(descriptor_pool, def, cOneofDescriptor);
self->pending_list = rb_ary_new();
return Qnil;
}
ruby/ext/google/protobuf_c/encode_decode.c
View file @ 1568deab
......@@ -117,18 +117,18 @@ static const void* newhandlerdata(upb_handlers* h, uint32_t ofs, int32_t hasbit)
typedef struct {
size_t ofs;
int32_t hasbit;
VALUE subklass;
const upb_msgdef *md;
} submsg_handlerdata_t;
// Creates a handlerdata that contains offset and submessage type information.
static const void *newsubmsghandlerdata(upb_handlers* h,
uint32_t ofs,
int32_t hasbit,
VALUE subklass) {
const upb_fielddef* f) {
submsg_handlerdata_t *hd = ALLOC(submsg_handlerdata_t);
hd->ofs = ofs;
hd->hasbit = hasbit;
hd->subklass = subklass;
hd->md = upb_fielddef_msgsubdef(f);
upb_handlers_addcleanup(h, hd, xfree);
return hd;
}
......@@ -137,14 +137,13 @@ typedef struct {
size_t ofs; // union data slot
size_t case_ofs; // oneof_case field
uint32_t oneof_case_num; // oneof-case number to place in oneof_case field
VALUE subklass;
const upb_msgdef *md; // msgdef, for oneof submessage handler
} oneof_handlerdata_t;
static const void *newoneofhandlerdata(upb_handlers *h,
uint32_t ofs,
uint32_t case_ofs,
const upb_fielddef *f,
const Descriptor* desc) {
const upb_fielddef *f) {
oneof_handlerdata_t *hd = ALLOC(oneof_handlerdata_t);
hd->ofs = ofs;
hd->case_ofs = case_ofs;
......@@ -155,7 +154,11 @@ static const void *newoneofhandlerdata(upb_handlers *h,
// create a separate ID space. In addition, using the field tag number here
// lets us easily look up the field in the oneof accessor.
hd->oneof_case_num = upb_fielddef_number(f);
hd->subklass = field_type_class(desc->layout, f);
if (upb_fielddef_type(f) == UPB_TYPE_MESSAGE) {
hd->md = upb_fielddef_msgsubdef(f);
} else {
hd->md = NULL;
}
upb_handlers_addcleanup(h, hd, xfree);
return hd;
}
......@@ -251,13 +254,13 @@ static size_t stringdata_handler(void* closure, const void* hd,
}
static bool stringdata_end_handler(void* closure, const void* hd) {
VALUE rb_str = (VALUE)closure;
VALUE rb_str = closure;
rb_obj_freeze(rb_str);
return true;
}
static bool appendstring_end_handler(void* closure, const void* hd) {
VALUE rb_str = (VALUE)closure;
VALUE rb_str = closure;
rb_obj_freeze(rb_str);
return true;
}
......@@ -266,9 +269,12 @@ static bool appendstring_end_handler(void* closure, const void* hd) {
static void *appendsubmsg_handler(void *closure, const void *hd) {
VALUE ary = (VALUE)closure;
const submsg_handlerdata_t *submsgdata = hd;
VALUE subdesc =
get_def_obj((void*)submsgdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
MessageHeader* submsg;
VALUE submsg_rb = rb_class_new_instance(0, NULL, submsgdata->subklass);
VALUE submsg_rb = rb_class_new_instance(0, NULL, subklass);
RepeatedField_push(ary, submsg_rb);
TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
......@@ -279,12 +285,15 @@ static void *appendsubmsg_handler(void *closure, const void *hd) {
static void *submsg_handler(void *closure, const void *hd) {
MessageHeader* msg = closure;
const submsg_handlerdata_t* submsgdata = hd;
VALUE subdesc =
get_def_obj((void*)submsgdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
VALUE submsg_rb;
MessageHeader* submsg;
if (DEREF(msg, submsgdata->ofs, VALUE) == Qnil) {
DEREF(msg, submsgdata->ofs, VALUE) =
rb_class_new_instance(0, NULL, submsgdata->subklass);
rb_class_new_instance(0, NULL, subklass);
}
set_hasbit(closure, submsgdata->hasbit);
......@@ -300,7 +309,11 @@ typedef struct {
size_t ofs;
upb_fieldtype_t key_field_type;
upb_fieldtype_t value_field_type;
VALUE subklass;
// We know that we can hold this reference because the handlerdata has the
// same lifetime as the upb_handlers struct, and the upb_handlers struct holds
// a reference to the upb_msgdef, which in turn has references to its subdefs.
const upb_def* value_field_subdef;
} map_handlerdata_t;
// Temporary frame for map parsing: at the beginning of a map entry message, a
......@@ -375,7 +388,7 @@ static bool endmap_handler(void *closure, const void *hd, upb_status* s) {
if (mapdata->value_field_type == UPB_TYPE_MESSAGE ||
mapdata->value_field_type == UPB_TYPE_ENUM) {
value_field_typeclass = mapdata->subklass;
value_field_typeclass = get_def_obj(mapdata->value_field_subdef);
}
value = native_slot_get(
......@@ -398,7 +411,7 @@ static bool endmap_handler(void *closure, const void *hd, upb_status* s) {
static map_handlerdata_t* new_map_handlerdata(
size_t ofs,
const upb_msgdef* mapentry_def,
const Descriptor* desc) {
Descriptor* desc) {
const upb_fielddef* key_field;
const upb_fielddef* value_field;
map_handlerdata_t* hd = ALLOC(map_handlerdata_t);
......@@ -409,7 +422,7 @@ static map_handlerdata_t* new_map_handlerdata(
value_field = upb_msgdef_itof(mapentry_def, MAP_VALUE_FIELD);
assert(value_field != NULL);
hd->value_field_type = upb_fielddef_type(value_field);
hd->subklass = field_type_class(desc->layout, value_field);
hd->value_field_subdef = upb_fielddef_subdef(value_field);
return hd;
}
......@@ -475,13 +488,16 @@ static void *oneofsubmsg_handler(void *closure,
const oneof_handlerdata_t *oneofdata = hd;
uint32_t oldcase = DEREF(msg, oneofdata->case_ofs, uint32_t);
VALUE subdesc =
get_def_obj((void*)oneofdata->md);
VALUE subklass = Descriptor_msgclass(subdesc);
VALUE submsg_rb;
MessageHeader* submsg;
if (oldcase != oneofdata->oneof_case_num ||
DEREF(msg, oneofdata->ofs, VALUE) == Qnil) {
DEREF(msg, oneofdata->ofs, VALUE) =
rb_class_new_instance(0, NULL, oneofdata->subklass);
rb_class_new_instance(0, NULL, subklass);
}
// Set the oneof case *after* allocating the new class instance -- otherwise,
// if the Ruby GC is invoked as part of a call into the VM, it might invoke
......@@ -499,12 +515,12 @@ static void *oneofsubmsg_handler(void *closure,
// Set up handlers for a repeated field.
static void add_handlers_for_repeated_field(upb_handlers *h,
const Descriptor* desc,
const upb_fielddef *f,
size_t offset) {
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
attr.handler_data = newhandlerdata(h, offset, -1);
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newhandlerdata(h, offset, -1));
upb_handlers_setstartseq(h, f, startseq_handler, &attr);
upb_handlerattr_uninit(&attr);
switch (upb_fielddef_type(f)) {
......@@ -535,20 +551,20 @@ static void add_handlers_for_repeated_field(upb_handlers *h,
break;
}
case UPB_TYPE_MESSAGE: {
VALUE subklass = field_type_class(desc->layout, f);
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
attr.handler_data = newsubmsghandlerdata(h, 0, -1, subklass);
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newsubmsghandlerdata(h, 0, -1, f));
upb_handlers_setstartsubmsg(h, f, appendsubmsg_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
}
}
// Set up handlers for a singular field.
static void add_handlers_for_singular_field(const Descriptor* desc,
upb_handlers* h,
const upb_fielddef* f,
size_t offset, size_t hasbit_off) {
static void add_handlers_for_singular_field(upb_handlers *h,
const upb_fielddef *f,
size_t offset,
size_t hasbit_off) {
// The offset we pass to UPB points to the start of the Message,
// rather than the start of where our data is stored.
int32_t hasbit = -1;
......@@ -570,20 +586,23 @@ static void add_handlers_for_singular_field(const Descriptor* desc,
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
attr.handler_data = newhandlerdata(h, offset, hasbit);
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr, newhandlerdata(h, offset, hasbit));
upb_handlers_setstartstr(h, f,
is_bytes ? bytes_handler : str_handler,
&attr);
upb_handlers_setstring(h, f, stringdata_handler, &attr);
upb_handlers_setendstr(h, f, stringdata_end_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
case UPB_TYPE_MESSAGE: {
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
attr.handler_data = newsubmsghandlerdata(
h, offset, hasbit, field_type_class(desc->layout, f));
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(&attr,
newsubmsghandlerdata(h, offset,
hasbit, f));
upb_handlers_setstartsubmsg(h, f, submsg_handler, &attr);
upb_handlerattr_uninit(&attr);
break;
}
}
......@@ -593,34 +612,36 @@ static void add_handlers_for_singular_field(const Descriptor* desc,
static void add_handlers_for_mapfield(upb_handlers* h,
const upb_fielddef* fielddef,
size_t offset,
const Descriptor* desc) {
Descriptor* desc) {
const upb_msgdef* map_msgdef = upb_fielddef_msgsubdef(fielddef);
map_handlerdata_t* hd = new_map_handlerdata(offset, map_msgdef, desc);
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlers_addcleanup(h, hd, xfree);
attr.handler_data = hd;
upb_handlerattr_sethandlerdata(&attr, hd);
upb_handlers_setstartsubmsg(h, fielddef, startmapentry_handler, &attr);
upb_handlerattr_uninit(&attr);
}
// Adds handlers to a map-entry msgdef.
static void add_handlers_for_mapentry(const upb_msgdef* msgdef, upb_handlers* h,
const Descriptor* desc) {
static void add_handlers_for_mapentry(const upb_msgdef* msgdef,
upb_handlers* h,
Descriptor* desc) {
const upb_fielddef* key_field = map_entry_key(msgdef);
const upb_fielddef* value_field = map_entry_value(msgdef);
map_handlerdata_t* hd = new_map_handlerdata(0, msgdef, desc);
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlers_addcleanup(h, hd, xfree);
attr.handler_data = hd;
upb_handlerattr_sethandlerdata(&attr, hd);
upb_handlers_setendmsg(h, endmap_handler, &attr);
add_handlers_for_singular_field(
desc, h, key_field,
h, key_field,
offsetof(map_parse_frame_t, key_storage),
MESSAGE_FIELD_NO_HASBIT);
add_handlers_for_singular_field(
desc, h, value_field,
h, value_field,
offsetof(map_parse_frame_t, value_storage),
MESSAGE_FIELD_NO_HASBIT);
}
......@@ -629,11 +650,11 @@ static void add_handlers_for_mapentry(const upb_msgdef* msgdef, upb_handlers* h,
static void add_handlers_for_oneof_field(upb_handlers *h,
const upb_fielddef *f,
size_t offset,
size_t oneof_case_offset,
const Descriptor* desc) {
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
attr.handler_data =
newoneofhandlerdata(h, offset, oneof_case_offset, f, desc);
size_t oneof_case_offset) {
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlerattr_sethandlerdata(
&attr, newoneofhandlerdata(h, offset, oneof_case_offset, f));
switch (upb_fielddef_type(f)) {
......@@ -668,6 +689,8 @@ static void add_handlers_for_oneof_field(upb_handlers *h,
break;
}
}
upb_handlerattr_uninit(&attr);
}
static bool unknown_field_handler(void* closure, const void* hd,
......@@ -685,21 +708,11 @@ static bool unknown_field_handler(void* closure, const void* hd,
return true;
}
void add_handlers_for_message(const void *closure, upb_handlers *h) {
const VALUE descriptor_pool = (VALUE)closure;
static void add_handlers_for_message(const void *closure, upb_handlers *h) {
const upb_msgdef* msgdef = upb_handlers_msgdef(h);
Descriptor* desc =
ruby_to_Descriptor(get_msgdef_obj(descriptor_pool, msgdef));
Descriptor* desc = ruby_to_Descriptor(get_def_obj((void*)msgdef));
upb_msg_field_iter i;
// Ensure layout exists. We may be invoked to create handlers for a given
// message if we are included as a submsg of another message type before our
// class is actually built, so to work around this, we just create the layout
// (and handlers, in the class-building function) on-demand.
if (desc->layout == NULL) {
desc->layout = create_layout(desc);
}
// If this is a mapentry message type, set up a special set of handlers and
// bail out of the normal (user-defined) message type handling.
if (upb_msgdef_mapentry(msgdef)) {
......@@ -707,7 +720,15 @@ void add_handlers_for_message(const void *closure, upb_handlers *h) {
return;
}
upb_handlerattr attr = UPB_HANDLERATTR_INIT;
// Ensure layout exists. We may be invoked to create handlers for a given
// message if we are included as a submsg of another message type before our
// class is actually built, so to work around this, we just create the layout
// (and handlers, in the class-building function) on-demand.
if (desc->layout == NULL) {
desc->layout = create_layout(desc->msgdef);
}
upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
upb_handlers_setunknown(h, unknown_field_handler, &attr);
for (upb_msg_field_begin(&i, desc->msgdef);
......@@ -721,51 +742,64 @@ void add_handlers_for_message(const void *closure, upb_handlers *h) {
size_t oneof_case_offset =
desc->layout->fields[upb_fielddef_index(f)].case_offset +
sizeof(MessageHeader);
add_handlers_for_oneof_field(h, f, offset, oneof_case_offset, desc);
add_handlers_for_oneof_field(h, f, offset, oneof_case_offset);
} else if (is_map_field(f)) {
add_handlers_for_mapfield(h, f, offset, desc);
} else if (upb_fielddef_isseq(f)) {
add_handlers_for_repeated_field(h, desc, f, offset);
add_handlers_for_repeated_field(h, f, offset);
} else {
add_handlers_for_singular_field(
desc, h, f, offset,
desc->layout->fields[upb_fielddef_index(f)].hasbit);
h, f, offset, desc->layout->fields[upb_fielddef_index(f)].hasbit);
}
}
}
// Creates upb handlers for populating a message.
static const upb_handlers *new_fill_handlers(Descriptor* desc,
const void* owner) {
// TODO(cfallin, haberman): once upb gets a caching/memoization layer for
// handlers, reuse subdef handlers so that e.g. if we already parse
// B-with-field-of-type-C, we don't have to rebuild the whole hierarchy to
// parse A-with-field-of-type-B-with-field-of-type-C.
return upb_handlers_newfrozen(desc->msgdef, owner,
add_handlers_for_message, NULL);
}
// Constructs the handlers for filling a message's data into an in-memory
// object.
const upb_handlers* get_fill_handlers(Descriptor* desc) {
DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
return upb_handlercache_get(pool->fill_handler_cache, desc->msgdef);
if (!desc->fill_handlers) {
desc->fill_handlers =
new_fill_handlers(desc, &desc->fill_handlers);
}
return desc->fill_handlers;
}
static const upb_pbdecodermethod *msgdef_decodermethod(Descriptor* desc) {
DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
return upb_pbcodecache_get(pool->fill_method_cache, desc->msgdef);
}
// Constructs the upb decoder method for parsing messages of this type.
// This is called from the message class creation code.
const upb_pbdecodermethod *new_fillmsg_decodermethod(Descriptor* desc,
const void* owner) {
const upb_handlers* handlers = get_fill_handlers(desc);
upb_pbdecodermethodopts opts;
upb_pbdecodermethodopts_init(&opts, handlers);
static const upb_json_parsermethod *msgdef_jsonparsermethod(Descriptor* desc) {
DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
return upb_json_codecache_get(pool->json_fill_method_cache, desc->msgdef);
return upb_pbdecodermethod_new(&opts, owner);
}
static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
return upb_handlercache_get(pool->pb_serialize_handler_cache, desc->msgdef);
static const upb_pbdecodermethod *msgdef_decodermethod(Descriptor* desc) {
if (desc->fill_method == NULL) {
desc->fill_method = new_fillmsg_decodermethod(
desc, &desc->fill_method);
}
return desc->fill_method;
}
static const upb_handlers* msgdef_json_serialize_handlers(
Descriptor* desc, bool preserve_proto_fieldnames) {
DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
if (preserve_proto_fieldnames) {
return upb_handlercache_get(pool->json_serialize_handler_preserve_cache,
desc->msgdef);
} else {
return upb_handlercache_get(pool->json_serialize_handler_cache,
desc->msgdef);
static const upb_json_parsermethod *msgdef_jsonparsermethod(Descriptor* desc) {
if (desc->json_fill_method == NULL) {
desc->json_fill_method =
upb_json_parsermethod_new(desc->msgdef, &desc->json_fill_method);
}
return desc->json_fill_method;
}
......@@ -775,8 +809,7 @@ static const upb_handlers* msgdef_json_serialize_handlers(
// if any error occurs.
#define STACK_ENV_STACKBYTES 4096
typedef struct {
upb_arena *arena;
upb_status status;
upb_env env;
const char* ruby_error_template;
char allocbuf[STACK_ENV_STACKBYTES];
} stackenv;
......@@ -784,22 +817,29 @@ typedef struct {
static void stackenv_init(stackenv* se, const char* errmsg);
static void stackenv_uninit(stackenv* se);
// Callback invoked by upb if any error occurs during parsing or serialization.
static bool env_error_func(void* ud, const upb_status* status) {
stackenv* se = ud;
// Free the env -- rb_raise will longjmp up the stack past the encode/decode
// function so it would not otherwise have been freed.
stackenv_uninit(se);
// TODO(haberman): have a way to verify that this is actually a parse error,
// instead of just throwing "parse error" unconditionally.
rb_raise(cParseError, se->ruby_error_template, upb_status_errmsg(status));
// Never reached: rb_raise() always longjmp()s up the stack, past all of our
// code, back to Ruby.
return false;
}
static void stackenv_init(stackenv* se, const char* errmsg) {
se->ruby_error_template = errmsg;
se->arena =
upb_arena_init(se->allocbuf, sizeof(se->allocbuf), &upb_alloc_global);
upb_status_clear(&se->status);
upb_env_init2(&se->env, se->allocbuf, sizeof(se->allocbuf), NULL);
upb_env_seterrorfunc(&se->env, env_error_func, se);
}
static void stackenv_uninit(stackenv* se) {
upb_arena_free(se->arena);
if (!upb_ok(&se->status)) {
// TODO(haberman): have a way to verify that this is actually a parse error,
// instead of just throwing "parse error" unconditionally.
VALUE errmsg = rb_str_new2(upb_status_errmsg(&se->status));
rb_raise(cParseError, se->ruby_error_template, errmsg);
}
upb_env_uninit(&se->env);
}
/*
......@@ -830,10 +870,10 @@ VALUE Message_decode(VALUE klass, VALUE data) {
stackenv se;
upb_sink sink;
upb_pbdecoder* decoder;
stackenv_init(&se, "Error occurred during parsing: %" PRIsVALUE);
stackenv_init(&se, "Error occurred during parsing: %s");
upb_sink_reset(&sink, h, msg);
decoder = upb_pbdecoder_create(se.arena, method, sink, &se.status);
decoder = upb_pbdecoder_create(&se.env, method, &sink);
upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
upb_pbdecoder_input(decoder));
......@@ -852,8 +892,7 @@ VALUE Message_decode(VALUE klass, VALUE data) {
* and returns a message object with the corresponding field values.
*
* @param options [Hash] options for the decoder
* ignore_unknown_fields: set true to ignore unknown fields (default is to
* raise an error)
* ignore_unknown_fields: set true to ignore unknown fields (default is to raise an error)
*/
VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
......@@ -881,7 +920,6 @@ VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
if (TYPE(data) != T_STRING) {
rb_raise(rb_eArgError, "Expected string for JSON data.");
}
// TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to
// convert, because string handlers pass data directly to message string
// fields.
......@@ -895,11 +933,11 @@ VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
upb_sink sink;
upb_json_parser* parser;
DescriptorPool* pool = ruby_to_DescriptorPool(generated_pool);
stackenv_init(&se, "Error occurred during parsing: %" PRIsVALUE);
stackenv_init(&se, "Error occurred during parsing: %s");
upb_sink_reset(&sink, get_fill_handlers(desc), msg);
parser = upb_json_parser_create(se.arena, method, pool->symtab, sink,
&se.status, RTEST(ignore_unknown_fields));
parser = upb_json_parser_create(&se.env, method, pool->symtab,
&sink, ignore_unknown_fields);
upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
upb_json_parser_input(parser));
......@@ -915,8 +953,9 @@ VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
/* msgvisitor *****************************************************************/
static void putmsg(VALUE msg, const Descriptor* desc, upb_sink sink, int depth,
bool emit_defaults, bool is_json, bool open_msg);
static void putmsg(VALUE msg, const Descriptor* desc,
upb_sink *sink, int depth, bool emit_defaults,
bool is_json, bool open_msg);
static upb_selector_t getsel(const upb_fielddef *f, upb_handlertype_t type) {
upb_selector_t ret;
......@@ -925,7 +964,7 @@ static upb_selector_t getsel(const upb_fielddef *f, upb_handlertype_t type) {
return ret;
}
static void putstr(VALUE str, const upb_fielddef *f, upb_sink sink) {
static void putstr(VALUE str, const upb_fielddef *f, upb_sink *sink) {
upb_sink subsink;
if (str == Qnil) return;
......@@ -942,12 +981,12 @@ static void putstr(VALUE str, const upb_fielddef *f, upb_sink sink) {
upb_sink_startstr(sink, getsel(f, UPB_HANDLER_STARTSTR), RSTRING_LEN(str),
&subsink);
upb_sink_putstring(subsink, getsel(f, UPB_HANDLER_STRING), RSTRING_PTR(str),
upb_sink_putstring(&subsink, getsel(f, UPB_HANDLER_STRING), RSTRING_PTR(str),
RSTRING_LEN(str), NULL);
upb_sink_endstr(sink, getsel(f, UPB_HANDLER_ENDSTR));
}
static void putsubmsg(VALUE submsg, const upb_fielddef *f, upb_sink sink,
static void putsubmsg(VALUE submsg, const upb_fielddef *f, upb_sink *sink,
int depth, bool emit_defaults, bool is_json) {
upb_sink subsink;
VALUE descriptor;
......@@ -959,12 +998,12 @@ static void putsubmsg(VALUE submsg, const upb_fielddef *f, upb_sink sink,
subdesc = ruby_to_Descriptor(descriptor);
upb_sink_startsubmsg(sink, getsel(f, UPB_HANDLER_STARTSUBMSG), &subsink);
putmsg(submsg, subdesc, subsink, depth + 1, emit_defaults, is_json, true);
putmsg(submsg, subdesc, &subsink, depth + 1, emit_defaults, is_json, true);
upb_sink_endsubmsg(sink, getsel(f, UPB_HANDLER_ENDSUBMSG));
}
static void putary(VALUE ary, const upb_fielddef* f, upb_sink sink, int depth,
bool emit_defaults, bool is_json) {
static void putary(VALUE ary, const upb_fielddef *f, upb_sink *sink,
int depth, bool emit_defaults, bool is_json) {
upb_sink subsink;
upb_fieldtype_t type = upb_fielddef_type(f);
upb_selector_t sel = 0;
......@@ -987,7 +1026,7 @@ static void putary(VALUE ary, const upb_fielddef* f, upb_sink sink, int depth,
switch (type) {
#define T(upbtypeconst, upbtype, ctype) \
case upbtypeconst: \
upb_sink_put##upbtype(subsink, sel, *((ctype*)memory)); \
upb_sink_put##upbtype(&subsink, sel, *((ctype *)memory)); \
break;
T(UPB_TYPE_FLOAT, float, float)
......@@ -1001,10 +1040,11 @@ static void putary(VALUE ary, const upb_fielddef* f, upb_sink sink, int depth,
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
putstr(*((VALUE *)memory), f, subsink);
putstr(*((VALUE *)memory), f, &subsink);
break;
case UPB_TYPE_MESSAGE:
putsubmsg(*((VALUE*)memory), f, subsink, depth, emit_defaults, is_json);
putsubmsg(*((VALUE *)memory), f, &subsink, depth,
emit_defaults, is_json);
break;
#undef T
......@@ -1014,8 +1054,12 @@ static void putary(VALUE ary, const upb_fielddef* f, upb_sink sink, int depth,
upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
}
static void put_ruby_value(VALUE value, const upb_fielddef* f, VALUE type_class,
int depth, upb_sink sink, bool emit_defaults,
static void put_ruby_value(VALUE value,
const upb_fielddef *f,
VALUE type_class,
int depth,
upb_sink *sink,
bool emit_defaults,
bool is_json) {
if (depth > ENCODE_MAX_NESTING) {
rb_raise(rb_eRuntimeError,
......@@ -1065,8 +1109,8 @@ static void put_ruby_value(VALUE value, const upb_fielddef* f, VALUE type_class,
}
}
static void putmap(VALUE map, const upb_fielddef* f, upb_sink sink, int depth,
bool emit_defaults, bool is_json) {
static void putmap(VALUE map, const upb_fielddef *f, upb_sink *sink,
int depth, bool emit_defaults, bool is_json) {
Map* self;
upb_sink subsink;
const upb_fielddef* key_field;
......@@ -1090,17 +1134,17 @@ static void putmap(VALUE map, const upb_fielddef* f, upb_sink sink, int depth,
upb_status status;
upb_sink entry_sink;
upb_sink_startsubmsg(subsink, getsel(f, UPB_HANDLER_STARTSUBMSG),
upb_sink_startsubmsg(&subsink, getsel(f, UPB_HANDLER_STARTSUBMSG),
&entry_sink);
upb_sink_startmsg(entry_sink);
upb_sink_startmsg(&entry_sink);
put_ruby_value(key, key_field, Qnil, depth + 1, entry_sink, emit_defaults,
is_json);
put_ruby_value(key, key_field, Qnil, depth + 1, &entry_sink,
emit_defaults, is_json);
put_ruby_value(value, value_field, self->value_type_class, depth + 1,
entry_sink, emit_defaults, is_json);
&entry_sink, emit_defaults, is_json);
upb_sink_endmsg(entry_sink, &status);
upb_sink_endsubmsg(subsink, getsel(f, UPB_HANDLER_ENDSUBMSG));
upb_sink_endmsg(&entry_sink, &status);
upb_sink_endsubmsg(&subsink, getsel(f, UPB_HANDLER_ENDSUBMSG));
}
upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
......@@ -1109,8 +1153,8 @@ static void putmap(VALUE map, const upb_fielddef* f, upb_sink sink, int depth,
static const upb_handlers* msgdef_json_serialize_handlers(
Descriptor* desc, bool preserve_proto_fieldnames);
static void putjsonany(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
int depth, bool emit_defaults) {
static void putjsonany(VALUE msg_rb, const Descriptor* desc,
upb_sink* sink, int depth, bool emit_defaults) {
upb_status status;
MessageHeader* msg = NULL;
const upb_fielddef* type_field = upb_msgdef_itof(desc->msgdef, UPB_ANY_TYPE);
......@@ -1166,7 +1210,7 @@ static void putjsonany(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
value_len = RSTRING_LEN(value_str_rb);
if (value_len > 0) {
VALUE payload_desc_rb = get_msgdef_obj(generated_pool, payload_type);
VALUE payload_desc_rb = get_def_obj(payload_type);
Descriptor* payload_desc = ruby_to_Descriptor(payload_desc_rb);
VALUE payload_class = Descriptor_msgclass(payload_desc_rb);
upb_sink subsink;
......@@ -1184,8 +1228,8 @@ static void putjsonany(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
subsink.handlers =
msgdef_json_serialize_handlers(payload_desc, true);
subsink.closure = sink.closure;
putmsg(payload_msg_rb, payload_desc, subsink, depth, emit_defaults, true,
subsink.closure = sink->closure;
putmsg(payload_msg_rb, payload_desc, &subsink, depth, emit_defaults, true,
is_wellknown);
}
}
......@@ -1193,8 +1237,9 @@ static void putjsonany(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
upb_sink_endmsg(sink, &status);
}
static void putmsg(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
int depth, bool emit_defaults, bool is_json, bool open_msg) {
static void putmsg(VALUE msg_rb, const Descriptor* desc,
upb_sink *sink, int depth, bool emit_defaults,
bool is_json, bool open_msg) {
MessageHeader* msg;
upb_msg_field_iter i;
upb_status status;
......@@ -1289,7 +1334,8 @@ static void putmsg(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
if (is_matching_oneof || emit_defaults || !is_default) { \
upb_sink_put##upbtype(sink, sel, value); \
} \
} break;
} \
break;
switch (upb_fielddef_type(f)) {
T(UPB_TYPE_FLOAT, float, float, 0.0)
......@@ -1321,6 +1367,33 @@ static void putmsg(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
}
}
static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
if (desc->pb_serialize_handlers == NULL) {
desc->pb_serialize_handlers =
upb_pb_encoder_newhandlers(desc->msgdef, &desc->pb_serialize_handlers);
}
return desc->pb_serialize_handlers;
}
static const upb_handlers* msgdef_json_serialize_handlers(
Descriptor* desc, bool preserve_proto_fieldnames) {
if (preserve_proto_fieldnames) {
if (desc->json_serialize_handlers == NULL) {
desc->json_serialize_handlers =
upb_json_printer_newhandlers(
desc->msgdef, true, &desc->json_serialize_handlers);
}
return desc->json_serialize_handlers;
} else {
if (desc->json_serialize_handlers_preserve == NULL) {
desc->json_serialize_handlers_preserve =
upb_json_printer_newhandlers(
desc->msgdef, false, &desc->json_serialize_handlers_preserve);
}
return desc->json_serialize_handlers_preserve;
}
}
/*
* call-seq:
* MessageClass.encode(msg) => bytes
......@@ -1343,8 +1416,8 @@ VALUE Message_encode(VALUE klass, VALUE msg_rb) {
upb_pb_encoder* encoder;
VALUE ret;
stackenv_init(&se, "Error occurred during encoding: %" PRIsVALUE);
encoder = upb_pb_encoder_create(se.arena, serialize_handlers, sink.sink);
stackenv_init(&se, "Error occurred during encoding: %s");
encoder = upb_pb_encoder_create(&se.env, serialize_handlers, &sink.sink);
putmsg(msg_rb, desc, upb_pb_encoder_input(encoder), 0, false, false, true);
......@@ -1401,8 +1474,8 @@ VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
stackenv se;
VALUE ret;
stackenv_init(&se, "Error occurred during encoding: %" PRIsVALUE);
printer = upb_json_printer_create(se.arena, serialize_handlers, sink.sink);
stackenv_init(&se, "Error occurred during encoding: %s");
printer = upb_json_printer_create(&se.env, serialize_handlers, &sink.sink);
putmsg(msg_rb, desc, upb_json_printer_input(printer), 0,
RTEST(emit_defaults), true, true);
......
ruby/ext/google/protobuf_c/message.c
View file @ 1568deab
......@@ -60,11 +60,6 @@ rb_data_type_t Message_type = {
VALUE Message_alloc(VALUE klass) {
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
Descriptor* desc = ruby_to_Descriptor(descriptor);
if (desc->layout == NULL) {
desc->layout = create_layout(desc);
}
MessageHeader* msg = (MessageHeader*)ALLOC_N(
uint8_t, sizeof(MessageHeader) + desc->layout->size);
VALUE ret;
......@@ -281,7 +276,7 @@ VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
} else if (accessor_type == METHOD_PRESENCE) {
return layout_has(self->descriptor->layout, Message_data(self), f);
} else if (accessor_type == METHOD_ENUM_GETTER) {
VALUE enum_type = field_type_class(self->descriptor->layout, f);
VALUE enum_type = field_type_class(f);
VALUE method = rb_intern("const_get");
VALUE raw_value = layout_get(self->descriptor->layout, Message_data(self), f);
......@@ -325,13 +320,15 @@ VALUE Message_respond_to_missing(int argc, VALUE* argv, VALUE _self) {
}
}
VALUE create_submsg_from_hash(const MessageLayout* layout,
const upb_fielddef* f, VALUE hash) {
const upb_msgdef *d = upb_fielddef_msgsubdef(f);
VALUE create_submsg_from_hash(const upb_fielddef *f, VALUE hash) {
const upb_def *d = upb_fielddef_subdef(f);
assert(d != NULL);
VALUE descriptor = get_def_obj(d);
VALUE msgclass = rb_funcall(descriptor, rb_intern("msgclass"), 0, NULL);
VALUE args[1] = { hash };
return rb_class_new_instance(1, args, field_type_class(layout, f));
return rb_class_new_instance(1, args, msgclass);
}
int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
......@@ -381,14 +378,14 @@ int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
for (int i = 0; i < RARRAY_LEN(val); i++) {
VALUE entry = rb_ary_entry(val, i);
if (TYPE(entry) == T_HASH && upb_fielddef_issubmsg(f)) {
entry = create_submsg_from_hash(self->descriptor->layout, f, entry);
entry = create_submsg_from_hash(f, entry);
}
RepeatedField_push(ary, entry);
}
} else {
if (TYPE(val) == T_HASH && upb_fielddef_issubmsg(f)) {
val = create_submsg_from_hash(self->descriptor->layout, f, val);
val = create_submsg_from_hash(f, val);
}
layout_set(self->descriptor->layout, Message_data(self), f, val);
......@@ -633,11 +630,17 @@ VALUE Message_descriptor(VALUE klass) {
return rb_ivar_get(klass, descriptor_instancevar_interned);
}
VALUE build_class_from_descriptor(VALUE descriptor) {
Descriptor* desc = ruby_to_Descriptor(descriptor);
VALUE build_class_from_descriptor(Descriptor* desc) {
const char *name;
VALUE klass;
if (desc->layout == NULL) {
desc->layout = create_layout(desc->msgdef);
}
if (desc->fill_method == NULL) {
desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
}
name = upb_msgdef_fullname(desc->msgdef);
if (name == NULL) {
rb_raise(rb_eRuntimeError, "Descriptor does not have assigned name.");
......@@ -648,7 +651,8 @@ VALUE build_class_from_descriptor(VALUE descriptor) {
// their own toplevel constant class name.
rb_intern("Message"),
rb_cObject);
rb_ivar_set(klass, descriptor_instancevar_interned, descriptor);
rb_ivar_set(klass, descriptor_instancevar_interned,
get_def_obj(desc->msgdef));
rb_define_alloc_func(klass, Message_alloc);
rb_require("google/protobuf/message_exts");
rb_include_module(klass, rb_eval_string("::Google::Protobuf::MessageExts"));
......@@ -733,8 +737,7 @@ VALUE enum_descriptor(VALUE self) {
return rb_ivar_get(self, descriptor_instancevar_interned);
}
VALUE build_module_from_enumdesc(VALUE _enumdesc) {
EnumDescriptor* enumdesc = ruby_to_EnumDescriptor(_enumdesc);
VALUE build_module_from_enumdesc(EnumDescriptor* enumdesc) {
VALUE mod = rb_define_module_id(
rb_intern(upb_enumdef_fullname(enumdesc->enumdef)));
......@@ -755,7 +758,8 @@ VALUE build_module_from_enumdesc(VALUE _enumdesc) {
rb_define_singleton_method(mod, "lookup", enum_lookup, 1);
rb_define_singleton_method(mod, "resolve", enum_resolve, 1);
rb_define_singleton_method(mod, "descriptor", enum_descriptor, 0);
rb_ivar_set(mod, descriptor_instancevar_interned, _enumdesc);
rb_ivar_set(mod, descriptor_instancevar_interned,
get_def_obj(enumdesc->enumdef));
return mod;
}
......
ruby/ext/google/protobuf_c/protobuf.c
View file @ 1568deab
......@@ -30,10 +30,26 @@
#include "protobuf.h"
// -----------------------------------------------------------------------------
// Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
// instances.
// -----------------------------------------------------------------------------
// This is a hash table from def objects (encoded by converting pointers to
// Ruby integers) to MessageDef/EnumDef instances (as Ruby values).
VALUE upb_def_to_ruby_obj_map;
VALUE cError;
VALUE cParseError;
VALUE cTypeError;
VALUE c_only_cookie;
void add_def_obj(const void* def, VALUE value) {
rb_hash_aset(upb_def_to_ruby_obj_map, ULL2NUM((intptr_t)def), value);
}
VALUE get_def_obj(const void* def) {
return rb_hash_aref(upb_def_to_ruby_obj_map, ULL2NUM((intptr_t)def));
}
// -----------------------------------------------------------------------------
// Utilities.
......@@ -100,6 +116,6 @@ void Init_protobuf_c() {
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(&upb_def_to_ruby_obj_map);
upb_def_to_ruby_obj_map = rb_hash_new();
}
ruby/ext/google/protobuf_c/protobuf.h
View file @ 1568deab
......@@ -107,68 +107,62 @@ typedef struct Builder Builder;
// -----------------------------------------------------------------------------
struct DescriptorPool {
VALUE def_to_descriptor; // Hash table of def* -> Ruby descriptor.
upb_symtab* symtab;
upb_handlercache* fill_handler_cache;
upb_handlercache* pb_serialize_handler_cache;
upb_handlercache* json_serialize_handler_cache;
upb_handlercache* json_serialize_handler_preserve_cache;
upb_pbcodecache* fill_method_cache;
upb_json_codecache* json_fill_method_cache;
};
struct Descriptor {
const upb_msgdef* msgdef;
MessageLayout* layout;
VALUE klass;
VALUE descriptor_pool;
VALUE klass; // begins as nil
const upb_handlers* fill_handlers;
const upb_pbdecodermethod* fill_method;
const upb_json_parsermethod* json_fill_method;
const upb_handlers* pb_serialize_handlers;
const upb_handlers* json_serialize_handlers;
const upb_handlers* json_serialize_handlers_preserve;
};
struct FileDescriptor {
const upb_filedef* filedef;
VALUE descriptor_pool; // Owns the upb_filedef.
};
struct FieldDescriptor {
const upb_fielddef* fielddef;
VALUE descriptor_pool; // Owns the upb_fielddef.
};
struct OneofDescriptor {
const upb_oneofdef* oneofdef;
VALUE descriptor_pool; // Owns the upb_oneofdef.
};
struct EnumDescriptor {
const upb_enumdef* enumdef;
VALUE module; // begins as nil
VALUE descriptor_pool; // Owns the upb_enumdef.
};
struct MessageBuilderContext {
google_protobuf_DescriptorProto* msg_proto;
VALUE file_builder;
VALUE descriptor;
VALUE builder;
};
struct OneofBuilderContext {
int oneof_index;
VALUE message_builder;
VALUE descriptor;
VALUE builder;
};
struct EnumBuilderContext {
google_protobuf_EnumDescriptorProto* enum_proto;
VALUE file_builder;
VALUE enumdesc;
};
struct FileBuilderContext {
upb_arena *arena;
google_protobuf_FileDescriptorProto* file_proto;
VALUE descriptor_pool;
VALUE pending_list;
VALUE file_descriptor;
VALUE builder;
};
struct Builder {
VALUE descriptor_pool;
VALUE default_file_builder;
VALUE pending_list;
VALUE default_file_descriptor;
upb_def** defs; // used only while finalizing
};
extern VALUE cDescriptorPool;
......@@ -197,6 +191,7 @@ void DescriptorPool_free(void* _self);
VALUE DescriptorPool_alloc(VALUE klass);
void DescriptorPool_register(VALUE module);
DescriptorPool* ruby_to_DescriptorPool(VALUE value);
VALUE DescriptorPool_add(VALUE _self, VALUE def);
VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self);
VALUE DescriptorPool_lookup(VALUE _self, VALUE name);
VALUE DescriptorPool_generated_pool(VALUE _self);
......@@ -208,11 +203,13 @@ void Descriptor_free(void* _self);
VALUE Descriptor_alloc(VALUE klass);
void Descriptor_register(VALUE module);
Descriptor* ruby_to_Descriptor(VALUE value);
VALUE Descriptor_initialize(VALUE _self, VALUE cookie, VALUE descriptor_pool,
VALUE ptr);
VALUE Descriptor_initialize(VALUE _self, VALUE file_descriptor_rb);
VALUE Descriptor_name(VALUE _self);
VALUE Descriptor_name_set(VALUE _self, VALUE str);
VALUE Descriptor_each(VALUE _self);
VALUE Descriptor_lookup(VALUE _self, VALUE name);
VALUE Descriptor_add_field(VALUE _self, VALUE obj);
VALUE Descriptor_add_oneof(VALUE _self, VALUE obj);
VALUE Descriptor_each_oneof(VALUE _self);
VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name);
VALUE Descriptor_msgclass(VALUE _self);
......@@ -224,24 +221,28 @@ void FileDescriptor_free(void* _self);
VALUE FileDescriptor_alloc(VALUE klass);
void FileDescriptor_register(VALUE module);
FileDescriptor* ruby_to_FileDescriptor(VALUE value);
VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr);
VALUE FileDescriptor_initialize(int argc, VALUE* argv, VALUE _self);
VALUE FileDescriptor_name(VALUE _self);
VALUE FileDescriptor_syntax(VALUE _self);
VALUE FileDescriptor_syntax_set(VALUE _self, VALUE syntax);
void FieldDescriptor_mark(void* _self);
void FieldDescriptor_free(void* _self);
VALUE FieldDescriptor_alloc(VALUE klass);
void FieldDescriptor_register(VALUE module);
FieldDescriptor* ruby_to_FieldDescriptor(VALUE value);
VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr);
VALUE FieldDescriptor_name(VALUE _self);
VALUE FieldDescriptor_name_set(VALUE _self, VALUE str);
VALUE FieldDescriptor_type(VALUE _self);
VALUE FieldDescriptor_type_set(VALUE _self, VALUE type);
VALUE FieldDescriptor_default(VALUE _self);
VALUE FieldDescriptor_default_set(VALUE _self, VALUE default_value);
VALUE FieldDescriptor_label(VALUE _self);
VALUE FieldDescriptor_label_set(VALUE _self, VALUE label);
VALUE FieldDescriptor_number(VALUE _self);
VALUE FieldDescriptor_number_set(VALUE _self, VALUE number);
VALUE FieldDescriptor_submsg_name(VALUE _self);
VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value);
VALUE FieldDescriptor_subtype(VALUE _self);
VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb);
VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb);
......@@ -255,20 +256,21 @@ void OneofDescriptor_free(void* _self);
VALUE OneofDescriptor_alloc(VALUE klass);
void OneofDescriptor_register(VALUE module);
OneofDescriptor* ruby_to_OneofDescriptor(VALUE value);
VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr);
VALUE OneofDescriptor_name(VALUE _self);
VALUE OneofDescriptor_name_set(VALUE _self, VALUE value);
VALUE OneofDescriptor_add_field(VALUE _self, VALUE field);
VALUE OneofDescriptor_each(VALUE _self, VALUE field);
void EnumDescriptor_mark(void* _self);
void EnumDescriptor_free(void* _self);
VALUE EnumDescriptor_alloc(VALUE klass);
VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
VALUE descriptor_pool, VALUE ptr);
void EnumDescriptor_register(VALUE module);
EnumDescriptor* ruby_to_EnumDescriptor(VALUE value);
VALUE EnumDescriptor_initialize(VALUE _self, VALUE file_descriptor_rb);
VALUE EnumDescriptor_file_descriptor(VALUE _self);
VALUE EnumDescriptor_name(VALUE _self);
VALUE EnumDescriptor_name_set(VALUE _self, VALUE str);
VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number);
VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name);
VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number);
VALUE EnumDescriptor_each(VALUE _self);
......@@ -281,8 +283,8 @@ VALUE MessageBuilderContext_alloc(VALUE klass);
void MessageBuilderContext_register(VALUE module);
MessageBuilderContext* ruby_to_MessageBuilderContext(VALUE value);
VALUE MessageBuilderContext_initialize(VALUE _self,
VALUE _file_builder,
VALUE name);
VALUE descriptor,
VALUE builder);
VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self);
VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self);
VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self);
......@@ -304,19 +306,15 @@ void EnumBuilderContext_free(void* _self);
VALUE EnumBuilderContext_alloc(VALUE klass);
void EnumBuilderContext_register(VALUE module);
EnumBuilderContext* ruby_to_EnumBuilderContext(VALUE value);
VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
VALUE name);
VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdesc);
VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number);
void FileBuilderContext_mark(void* _self);
void FileBuilderContext_free(void* _self);
VALUE FileBuilderContext_alloc(VALUE klass);
void FileBuilderContext_register(VALUE module);
FileBuilderContext* ruby_to_FileBuilderContext(VALUE _self);
upb_strview FileBuilderContext_strdup(VALUE _self, VALUE rb_str);
upb_strview FileBuilderContext_strdup_name(VALUE _self, VALUE rb_str);
VALUE FileBuilderContext_initialize(VALUE _self, VALUE descriptor_pool,
VALUE name, VALUE options);
VALUE FileBuilderContext_initialize(VALUE _self, VALUE file_descriptor,
VALUE builder);
VALUE FileBuilderContext_add_message(VALUE _self, VALUE name);
VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name);
VALUE FileBuilderContext_pending_descriptors(VALUE _self);
......@@ -326,8 +324,7 @@ void Builder_free(void* _self);
VALUE Builder_alloc(VALUE klass);
void Builder_register(VALUE module);
Builder* ruby_to_Builder(VALUE value);
VALUE Builder_build(VALUE _self);
VALUE Builder_initialize(VALUE _self, VALUE descriptor_pool);
VALUE Builder_initialize(VALUE _self);
VALUE Builder_add_file(int argc, VALUE *argv, VALUE _self);
VALUE Builder_add_message(VALUE _self, VALUE name);
VALUE Builder_add_enum(VALUE _self, VALUE name);
......@@ -371,7 +368,7 @@ extern rb_encoding* kRubyStringUtf8Encoding;
extern rb_encoding* kRubyStringASCIIEncoding;
extern rb_encoding* kRubyString8bitEncoding;
VALUE field_type_class(const MessageLayout* layout, const upb_fielddef* field);
VALUE field_type_class(const upb_fielddef* field);
#define MAP_KEY_FIELD 1
#define MAP_VALUE_FIELD 2
......@@ -504,15 +501,13 @@ struct MessageField {
size_t hasbit;
};
// MessageLayout is owned by the enclosing Descriptor, which must outlive us.
struct MessageLayout {
const Descriptor* desc;
const upb_msgdef* msgdef;
MessageField* fields;
size_t size;
};
MessageLayout* create_layout(const Descriptor* desc);
MessageLayout* create_layout(const upb_msgdef* msgdef);
void free_layout(MessageLayout* layout);
bool field_contains_hasbit(MessageLayout* layout,
const upb_fielddef* field);
......@@ -561,7 +556,7 @@ struct MessageHeader {
extern rb_data_type_t Message_type;
VALUE build_class_from_descriptor(VALUE descriptor);
VALUE build_class_from_descriptor(Descriptor* descriptor);
void* Message_data(void* msg);
void Message_mark(void* self);
void Message_free(void* self);
......@@ -585,13 +580,12 @@ VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass);
VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb);
VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj);
VALUE build_module_from_enumdesc(VALUE _enumdesc);
VALUE build_module_from_enumdesc(EnumDescriptor* enumdef);
VALUE enum_lookup(VALUE self, VALUE number);
VALUE enum_resolve(VALUE self, VALUE sym);
const upb_pbdecodermethod *new_fillmsg_decodermethod(
Descriptor* descriptor, const void *owner);
void add_handlers_for_message(const void *closure, upb_handlers *h);
// Maximum depth allowed during encoding, to avoid stack overflows due to
// cycles.
......@@ -601,11 +595,8 @@ void add_handlers_for_message(const void *closure, upb_handlers *h);
// Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
// instances.
// -----------------------------------------------------------------------------
VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def);
VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def);
VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_fielddef* def);
VALUE get_filedef_obj(VALUE descriptor_pool, const upb_filedef* def);
VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def);
void add_def_obj(const void* def, VALUE value);
VALUE get_def_obj(const void* def);
// -----------------------------------------------------------------------------
// Utilities.
......@@ -621,9 +612,4 @@ void check_upb_status(const upb_status* status, const char* msg);
extern ID descriptor_instancevar_interned;
// A distinct object that is not accessible from Ruby. We use this as a
// constructor argument to enforce that certain objects cannot be created from
// Ruby.
extern VALUE c_only_cookie;
#endif // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
ruby/ext/google/protobuf_c/storage.c
View file @ 1568deab
......@@ -430,10 +430,8 @@ static size_t align_up_to(size_t offset, size_t granularity) {
return (offset + granularity - 1) & ~(granularity - 1);
}
MessageLayout* create_layout(const Descriptor* desc) {
const upb_msgdef *msgdef = desc->msgdef;
MessageLayout* create_layout(const upb_msgdef* msgdef) {
MessageLayout* layout = ALLOC(MessageLayout);
layout->desc = desc;
int nfields = upb_msgdef_numfields(msgdef);
upb_msg_field_iter it;
upb_msg_oneof_iter oit;
......@@ -539,25 +537,28 @@ MessageLayout* create_layout(const Descriptor* desc) {
}
layout->size = off;
layout->msgdef = msgdef;
upb_msgdef_ref(layout->msgdef, &layout->msgdef);
return layout;
}
void free_layout(MessageLayout* layout) {
xfree(layout->fields);
upb_msgdef_unref(layout->msgdef, &layout->msgdef);
xfree(layout);
}
VALUE field_type_class(const MessageLayout* layout, const upb_fielddef* field) {
VALUE field_type_class(const upb_fielddef* field) {
VALUE type_class = Qnil;
if (upb_fielddef_type(field) == UPB_TYPE_MESSAGE) {
VALUE submsgdesc = get_msgdef_obj(layout->desc->descriptor_pool,
upb_fielddef_msgsubdef(field));
VALUE submsgdesc =
get_def_obj(upb_fielddef_subdef(field));
type_class = Descriptor_msgclass(submsgdesc);
} else if (upb_fielddef_type(field) == UPB_TYPE_ENUM) {
VALUE subenumdesc = get_enumdef_obj(layout->desc->descriptor_pool,
upb_fielddef_enumsubdef(field));
VALUE subenumdesc =
get_def_obj(upb_fielddef_subdef(field));
type_class = EnumDescriptor_enummodule(subenumdesc);
}
return type_class;
......@@ -631,7 +632,7 @@ void layout_clear(MessageLayout* layout,
const upb_fielddef* key_field = map_field_key(field);
const upb_fielddef* value_field = map_field_value(field);
VALUE type_class = field_type_class(layout, value_field);
VALUE type_class = field_type_class(value_field);
if (type_class != Qnil) {
VALUE args[3] = {
......@@ -652,7 +653,7 @@ void layout_clear(MessageLayout* layout,
} else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
VALUE ary = Qnil;
VALUE type_class = field_type_class(layout, field);
VALUE type_class = field_type_class(field);
if (type_class != Qnil) {
VALUE args[2] = {
......@@ -667,9 +668,9 @@ void layout_clear(MessageLayout* layout,
DEREF(memory, VALUE) = ary;
} else {
native_slot_set(upb_fielddef_name(field), upb_fielddef_type(field),
field_type_class(layout, field), memory,
layout_get_default(field));
native_slot_set(upb_fielddef_name(field),
upb_fielddef_type(field), field_type_class(field),
memory, layout_get_default(field));
}
}
......@@ -727,19 +728,20 @@ VALUE layout_get(MessageLayout* layout,
return layout_get_default(field);
}
return native_slot_get(upb_fielddef_type(field),
field_type_class(layout, field), memory);
field_type_class(field),
memory);
} else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
return *((VALUE *)memory);
} else if (!field_set) {
return layout_get_default(field);
} else {
return native_slot_get(upb_fielddef_type(field),
field_type_class(layout, field), memory);
field_type_class(field),
memory);
}
}
static void check_repeated_field_type(const MessageLayout* layout, VALUE val,
const upb_fielddef* field) {
static void check_repeated_field_type(VALUE val, const upb_fielddef* field) {
RepeatedField* self;
assert(upb_fielddef_label(field) == UPB_LABEL_REPEATED);
......@@ -753,13 +755,25 @@ static void check_repeated_field_type(const MessageLayout* layout, VALUE val,
rb_raise(cTypeError, "Repeated field array has wrong element type");
}
if (self->field_type_class != field_type_class(layout, field)) {
rb_raise(cTypeError, "Repeated field array has wrong message/enum class");
if (self->field_type == UPB_TYPE_MESSAGE) {
if (self->field_type_class !=
Descriptor_msgclass(get_def_obj(upb_fielddef_subdef(field)))) {
rb_raise(cTypeError,
"Repeated field array has wrong message class");
}
}
if (self->field_type == UPB_TYPE_ENUM) {
if (self->field_type_class !=
EnumDescriptor_enummodule(get_def_obj(upb_fielddef_subdef(field)))) {
rb_raise(cTypeError,
"Repeated field array has wrong enum class");
}
}
}
static void check_map_field_type(const MessageLayout* layout, VALUE val,
const upb_fielddef* field) {
static void check_map_field_type(VALUE val, const upb_fielddef* field) {
const upb_fielddef* key_field = map_field_key(field);
const upb_fielddef* value_field = map_field_value(field);
Map* self;
......@@ -776,11 +790,17 @@ static void check_map_field_type(const MessageLayout* layout, VALUE val,
if (self->value_type != upb_fielddef_type(value_field)) {
rb_raise(cTypeError, "Map value type does not match field's value type");
}
if (self->value_type_class != field_type_class(layout, value_field)) {
rb_raise(cTypeError, "Map value type has wrong message/enum class");
if (upb_fielddef_type(value_field) == UPB_TYPE_MESSAGE ||
upb_fielddef_type(value_field) == UPB_TYPE_ENUM) {
if (self->value_type_class !=
get_def_obj(upb_fielddef_subdef(value_field))) {
rb_raise(cTypeError,
"Map value type has wrong message/enum class");
}
}
}
void layout_set(MessageLayout* layout,
void* storage,
const upb_fielddef* field,
......@@ -808,19 +828,20 @@ void layout_set(MessageLayout* layout,
// and case number are altered atomically (w.r.t. the Ruby VM).
native_slot_set_value_and_case(
upb_fielddef_name(field),
upb_fielddef_type(field), field_type_class(layout, field),
upb_fielddef_type(field), field_type_class(field),
memory, val,
oneof_case, upb_fielddef_number(field));
}
} else if (is_map_field(field)) {
check_map_field_type(layout, val, field);
check_map_field_type(val, field);
DEREF(memory, VALUE) = val;
} else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
check_repeated_field_type(layout, val, field);
check_repeated_field_type(val, field);
DEREF(memory, VALUE) = val;
} else {
native_slot_set(upb_fielddef_name(field), upb_fielddef_type(field),
field_type_class(layout, field), memory, val);
native_slot_set(upb_fielddef_name(field),
upb_fielddef_type(field), field_type_class(field),
memory, val);
}
if (layout->fields[upb_fielddef_index(field)].hasbit !=
......
ruby/ext/google/protobuf_c/upb.c
View file @ 1568deab
This source diff could not be displayed because it is too large. You can view the blob instead.
ruby/ext/google/protobuf_c/upb.h
View file @ 1568deab
This source diff could not be displayed because it is too large. You can view the blob instead.
ruby/lib/google/protobuf.rb
View file @ 1568deab
......@@ -50,72 +50,6 @@ else
rescue LoadError
require 'google/protobuf_c'
end
module Google
module Protobuf
module Internal
def self.infer_package(names)
# Package is longest common prefix ending in '.', if any.
min, max = names.minmax
last_common_dot = nil
min.size.times { |i|
if min[i] != max[i] then break end
if min[i] == ?. then last_common_dot = i end
}
if last_common_dot
return min.slice(0, last_common_dot)
end
end
class NestingBuilder
def initialize(msg_names, enum_names)
@to_pos = {nil=>nil}
@msg_children = Hash.new { |hash, key| hash[key] = [] }
@enum_children = Hash.new { |hash, key| hash[key] = [] }
msg_names.each_with_index { |name, idx| @to_pos[name] = idx }
enum_names.each_with_index { |name, idx| @to_pos[name] = idx }
msg_names.each { |name| @msg_children[parent(name)] << name }
enum_names.each { |name| @enum_children[parent(name)] << name }
end
def build(package)
return build_msg(package)
end
private
def build_msg(msg)
return {
:pos => @to_pos[msg],
:msgs => @msg_children[msg].map { |child| build_msg(child) },
:enums => @enum_children[msg].map { |child| @to_pos[child] },
}
end
private
def parent(name)
idx = name.rindex(?.)
if idx
return name.slice(0, idx)
else
return nil
end
end
end
def self.fixup_descriptor(package, msg_names, enum_names)
if package.nil?
package = self.infer_package(msg_names + enum_names)
end
nesting = NestingBuilder.new(msg_names, enum_names).build(package)
return package, nesting
end
end
end
end
end
require 'google/protobuf/repeated_field'
......
ruby/tests/basic.rb
View file @ 1568deab
......@@ -17,6 +17,7 @@ module BasicTest
add_message "BadFieldNames" do
optional :dup, :int32, 1
optional :class, :int32, 2
optional :"a.b", :int32, 3
end
end
......@@ -350,6 +351,11 @@ module BasicTest
assert nil != file_descriptor
assert_equal "tests/basic_test.proto", file_descriptor.name
assert_equal :proto3, file_descriptor.syntax
file_descriptor = BadFieldNames.descriptor.file_descriptor
assert nil != file_descriptor
assert_equal nil, file_descriptor.name
assert_equal :proto3, file_descriptor.syntax
end
def test_map_freeze
......
ruby/tests/basic_proto2.rb
View file @ 1568deab
......@@ -18,6 +18,7 @@ module BasicTestProto2
add_message "BadFieldNames" do
optional :dup, :int32, 1
optional :class, :int32, 2
optional :"a.b", :int32, 3
end
end
end
......
ruby/tests/common_tests.rb
View file @ 1568deab
......@@ -807,7 +807,7 @@ module CommonTests
proto_module::TestMessage2.new(:foo => 2)])
data = proto_module::TestMessage.encode m
m2 = proto_module::TestMessage.decode data
assert_equal m, m2
assert m == m2
data = Google::Protobuf.encode m
m2 = Google::Protobuf.decode(proto_module::TestMessage, data)
......@@ -902,6 +902,8 @@ module CommonTests
assert m['class'] == 2
m['dup'] = 3
assert m['dup'] == 3
m['a.b'] = 4
assert m['a.b'] == 4
end
def test_int_ranges
......@@ -1082,7 +1084,9 @@ module CommonTests
json_text = proto_module::TestMessage.encode_json(m)
m2 = proto_module::TestMessage.decode_json(json_text)
assert_equal m, m2
puts m.inspect
puts m2.inspect
assert m == m2
# Crash case from GitHub issue 283.
bar = proto_module::Bar.new(msg: "bar")
......@@ -1128,7 +1132,7 @@ module CommonTests
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
assert JSON.parse(actual, :symbolize_names => true) == expected
end
def test_json_emit_defaults_submsg
......@@ -1163,7 +1167,7 @@ module CommonTests
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
assert JSON.parse(actual, :symbolize_names => true) == expected
end
def test_json_emit_defaults_repeated_submsg
......@@ -1197,7 +1201,7 @@ module CommonTests
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
assert JSON.parse(actual, :symbolize_names => true) == expected
end
def value_from_ruby(value)
......
ruby/tests/type_errors.rb
View file @ 1568deab
......@@ -10,11 +10,11 @@ require 'generated_code_pb'
class TestTypeErrors < Test::Unit::TestCase
def test_bad_string
check_error Google::Protobuf::TypeError,
"Invalid argument for string field 'optional_string' (given Fixnum)." do
"Invalid argument for string field 'optional_string' (given Integer)." do
A::B::C::TestMessage.new(optional_string: 4)
end
check_error Google::Protobuf::TypeError,
"Invalid argument for string field 'oneof_string' (given Fixnum)." do
"Invalid argument for string field 'oneof_string' (given Integer)." do
A::B::C::TestMessage.new(oneof_string: 4)
end
check_error ArgumentError,
......@@ -151,7 +151,7 @@ class TestTypeErrors < Test::Unit::TestCase
def test_bad_msg
check_error Google::Protobuf::TypeError,
"Invalid type Fixnum to assign to submessage field 'optional_msg'." do
"Invalid type Integer to assign to submessage field 'optional_msg'." do
A::B::C::TestMessage.new(optional_msg: 2)
end
check_error Google::Protobuf::TypeError,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment