1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2014 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 #include "protobuf.h"
32
33 #include <math.h>
34
35 #include <ruby/encoding.h>
36
37 // -----------------------------------------------------------------------------
38 // Ruby <-> native slot management.
39 // -----------------------------------------------------------------------------
40
41 #define DEREF(memory, type) *(type*)(memory)
42
native_slot_size(upb_fieldtype_t type)43 size_t native_slot_size(upb_fieldtype_t type) {
44 switch (type) {
45 case UPB_TYPE_FLOAT: return 4;
46 case UPB_TYPE_DOUBLE: return 8;
47 case UPB_TYPE_BOOL: return 1;
48 case UPB_TYPE_STRING: return sizeof(VALUE);
49 case UPB_TYPE_BYTES: return sizeof(VALUE);
50 case UPB_TYPE_MESSAGE: return sizeof(VALUE);
51 case UPB_TYPE_ENUM: return 4;
52 case UPB_TYPE_INT32: return 4;
53 case UPB_TYPE_INT64: return 8;
54 case UPB_TYPE_UINT32: return 4;
55 case UPB_TYPE_UINT64: return 8;
56 default: return 0;
57 }
58 }
59
is_ruby_num(VALUE value)60 static bool is_ruby_num(VALUE value) {
61 return (TYPE(value) == T_FLOAT ||
62 TYPE(value) == T_FIXNUM ||
63 TYPE(value) == T_BIGNUM);
64 }
65
native_slot_check_int_range_precision(upb_fieldtype_t type,VALUE val)66 void native_slot_check_int_range_precision(upb_fieldtype_t type, VALUE val) {
67 if (!is_ruby_num(val)) {
68 rb_raise(rb_eTypeError, "Expected number type for integral field.");
69 }
70
71 // NUM2{INT,UINT,LL,ULL} macros do the appropriate range checks on upper
72 // bound; we just need to do precision checks (i.e., disallow rounding) and
73 // check for < 0 on unsigned types.
74 if (TYPE(val) == T_FLOAT) {
75 double dbl_val = NUM2DBL(val);
76 if (floor(dbl_val) != dbl_val) {
77 rb_raise(rb_eRangeError,
78 "Non-integral floating point value assigned to integer field.");
79 }
80 }
81 if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) {
82 if (NUM2DBL(val) < 0) {
83 rb_raise(rb_eRangeError,
84 "Assigning negative value to unsigned integer field.");
85 }
86 }
87 }
88
native_slot_validate_string_encoding(upb_fieldtype_t type,VALUE value)89 void native_slot_validate_string_encoding(upb_fieldtype_t type, VALUE value) {
90 bool bad_encoding = false;
91 rb_encoding* string_encoding = rb_enc_from_index(ENCODING_GET(value));
92 if (type == UPB_TYPE_STRING) {
93 bad_encoding =
94 string_encoding != kRubyStringUtf8Encoding &&
95 string_encoding != kRubyStringASCIIEncoding;
96 } else {
97 bad_encoding =
98 string_encoding != kRubyString8bitEncoding;
99 }
100 // Check that encoding is UTF-8 or ASCII (for string fields) or ASCII-8BIT
101 // (for bytes fields).
102 if (bad_encoding) {
103 rb_raise(rb_eTypeError, "Encoding for '%s' fields must be %s (was %s)",
104 (type == UPB_TYPE_STRING) ? "string" : "bytes",
105 (type == UPB_TYPE_STRING) ? "UTF-8 or ASCII" : "ASCII-8BIT",
106 rb_enc_name(string_encoding));
107 }
108 }
109
native_slot_set(upb_fieldtype_t type,VALUE type_class,void * memory,VALUE value)110 void native_slot_set(upb_fieldtype_t type, VALUE type_class,
111 void* memory, VALUE value) {
112 native_slot_set_value_and_case(type, type_class, memory, value, NULL, 0);
113 }
114
native_slot_set_value_and_case(upb_fieldtype_t type,VALUE type_class,void * memory,VALUE value,uint32_t * case_memory,uint32_t case_number)115 void native_slot_set_value_and_case(upb_fieldtype_t type, VALUE type_class,
116 void* memory, VALUE value,
117 uint32_t* case_memory,
118 uint32_t case_number) {
119 // Note that in order to atomically change the value in memory and the case
120 // value (w.r.t. Ruby VM calls), we must set the value at |memory| only after
121 // all Ruby VM calls are complete. The case is then set at the bottom of this
122 // function.
123 switch (type) {
124 case UPB_TYPE_FLOAT:
125 if (!is_ruby_num(value)) {
126 rb_raise(rb_eTypeError, "Expected number type for float field.");
127 }
128 DEREF(memory, float) = NUM2DBL(value);
129 break;
130 case UPB_TYPE_DOUBLE:
131 if (!is_ruby_num(value)) {
132 rb_raise(rb_eTypeError, "Expected number type for double field.");
133 }
134 DEREF(memory, double) = NUM2DBL(value);
135 break;
136 case UPB_TYPE_BOOL: {
137 int8_t val = -1;
138 if (value == Qtrue) {
139 val = 1;
140 } else if (value == Qfalse) {
141 val = 0;
142 } else {
143 rb_raise(rb_eTypeError, "Invalid argument for boolean field.");
144 }
145 DEREF(memory, int8_t) = val;
146 break;
147 }
148 case UPB_TYPE_STRING:
149 case UPB_TYPE_BYTES: {
150 if (CLASS_OF(value) != rb_cString) {
151 rb_raise(rb_eTypeError, "Invalid argument for string field.");
152 }
153 native_slot_validate_string_encoding(type, value);
154 DEREF(memory, VALUE) = value;
155 break;
156 }
157 case UPB_TYPE_MESSAGE: {
158 if (CLASS_OF(value) == CLASS_OF(Qnil)) {
159 value = Qnil;
160 } else if (CLASS_OF(value) != type_class) {
161 rb_raise(rb_eTypeError,
162 "Invalid type %s to assign to submessage field.",
163 rb_class2name(CLASS_OF(value)));
164 }
165 DEREF(memory, VALUE) = value;
166 break;
167 }
168 case UPB_TYPE_ENUM: {
169 int32_t int_val = 0;
170 if (!is_ruby_num(value) && TYPE(value) != T_SYMBOL) {
171 rb_raise(rb_eTypeError,
172 "Expected number or symbol type for enum field.");
173 }
174 if (TYPE(value) == T_SYMBOL) {
175 // Ensure that the given symbol exists in the enum module.
176 VALUE lookup = rb_funcall(type_class, rb_intern("resolve"), 1, value);
177 if (lookup == Qnil) {
178 rb_raise(rb_eRangeError, "Unknown symbol value for enum field.");
179 } else {
180 int_val = NUM2INT(lookup);
181 }
182 } else {
183 native_slot_check_int_range_precision(UPB_TYPE_INT32, value);
184 int_val = NUM2INT(value);
185 }
186 DEREF(memory, int32_t) = int_val;
187 break;
188 }
189 case UPB_TYPE_INT32:
190 case UPB_TYPE_INT64:
191 case UPB_TYPE_UINT32:
192 case UPB_TYPE_UINT64:
193 native_slot_check_int_range_precision(type, value);
194 switch (type) {
195 case UPB_TYPE_INT32:
196 DEREF(memory, int32_t) = NUM2INT(value);
197 break;
198 case UPB_TYPE_INT64:
199 DEREF(memory, int64_t) = NUM2LL(value);
200 break;
201 case UPB_TYPE_UINT32:
202 DEREF(memory, uint32_t) = NUM2UINT(value);
203 break;
204 case UPB_TYPE_UINT64:
205 DEREF(memory, uint64_t) = NUM2ULL(value);
206 break;
207 default:
208 break;
209 }
210 break;
211 default:
212 break;
213 }
214
215 if (case_memory != NULL) {
216 *case_memory = case_number;
217 }
218 }
219
native_slot_get(upb_fieldtype_t type,VALUE type_class,const void * memory)220 VALUE native_slot_get(upb_fieldtype_t type,
221 VALUE type_class,
222 const void* memory) {
223 switch (type) {
224 case UPB_TYPE_FLOAT:
225 return DBL2NUM(DEREF(memory, float));
226 case UPB_TYPE_DOUBLE:
227 return DBL2NUM(DEREF(memory, double));
228 case UPB_TYPE_BOOL:
229 return DEREF(memory, int8_t) ? Qtrue : Qfalse;
230 case UPB_TYPE_STRING:
231 case UPB_TYPE_BYTES:
232 case UPB_TYPE_MESSAGE:
233 return DEREF(memory, VALUE);
234 case UPB_TYPE_ENUM: {
235 int32_t val = DEREF(memory, int32_t);
236 VALUE symbol = enum_lookup(type_class, INT2NUM(val));
237 if (symbol == Qnil) {
238 return INT2NUM(val);
239 } else {
240 return symbol;
241 }
242 }
243 case UPB_TYPE_INT32:
244 return INT2NUM(DEREF(memory, int32_t));
245 case UPB_TYPE_INT64:
246 return LL2NUM(DEREF(memory, int64_t));
247 case UPB_TYPE_UINT32:
248 return UINT2NUM(DEREF(memory, uint32_t));
249 case UPB_TYPE_UINT64:
250 return ULL2NUM(DEREF(memory, uint64_t));
251 default:
252 return Qnil;
253 }
254 }
255
native_slot_init(upb_fieldtype_t type,void * memory)256 void native_slot_init(upb_fieldtype_t type, void* memory) {
257 switch (type) {
258 case UPB_TYPE_FLOAT:
259 DEREF(memory, float) = 0.0;
260 break;
261 case UPB_TYPE_DOUBLE:
262 DEREF(memory, double) = 0.0;
263 break;
264 case UPB_TYPE_BOOL:
265 DEREF(memory, int8_t) = 0;
266 break;
267 case UPB_TYPE_STRING:
268 case UPB_TYPE_BYTES:
269 DEREF(memory, VALUE) = rb_str_new2("");
270 rb_enc_associate(DEREF(memory, VALUE), (type == UPB_TYPE_BYTES) ?
271 kRubyString8bitEncoding : kRubyStringUtf8Encoding);
272 break;
273 case UPB_TYPE_MESSAGE:
274 DEREF(memory, VALUE) = Qnil;
275 break;
276 case UPB_TYPE_ENUM:
277 case UPB_TYPE_INT32:
278 DEREF(memory, int32_t) = 0;
279 break;
280 case UPB_TYPE_INT64:
281 DEREF(memory, int64_t) = 0;
282 break;
283 case UPB_TYPE_UINT32:
284 DEREF(memory, uint32_t) = 0;
285 break;
286 case UPB_TYPE_UINT64:
287 DEREF(memory, uint64_t) = 0;
288 break;
289 default:
290 break;
291 }
292 }
293
native_slot_mark(upb_fieldtype_t type,void * memory)294 void native_slot_mark(upb_fieldtype_t type, void* memory) {
295 switch (type) {
296 case UPB_TYPE_STRING:
297 case UPB_TYPE_BYTES:
298 case UPB_TYPE_MESSAGE:
299 rb_gc_mark(DEREF(memory, VALUE));
300 break;
301 default:
302 break;
303 }
304 }
305
native_slot_dup(upb_fieldtype_t type,void * to,void * from)306 void native_slot_dup(upb_fieldtype_t type, void* to, void* from) {
307 memcpy(to, from, native_slot_size(type));
308 }
309
native_slot_deep_copy(upb_fieldtype_t type,void * to,void * from)310 void native_slot_deep_copy(upb_fieldtype_t type, void* to, void* from) {
311 switch (type) {
312 case UPB_TYPE_STRING:
313 case UPB_TYPE_BYTES: {
314 VALUE from_val = DEREF(from, VALUE);
315 DEREF(to, VALUE) = (from_val != Qnil) ?
316 rb_funcall(from_val, rb_intern("dup"), 0) : Qnil;
317 break;
318 }
319 case UPB_TYPE_MESSAGE: {
320 VALUE from_val = DEREF(from, VALUE);
321 DEREF(to, VALUE) = (from_val != Qnil) ?
322 Message_deep_copy(from_val) : Qnil;
323 break;
324 }
325 default:
326 memcpy(to, from, native_slot_size(type));
327 }
328 }
329
native_slot_eq(upb_fieldtype_t type,void * mem1,void * mem2)330 bool native_slot_eq(upb_fieldtype_t type, void* mem1, void* mem2) {
331 switch (type) {
332 case UPB_TYPE_STRING:
333 case UPB_TYPE_BYTES:
334 case UPB_TYPE_MESSAGE: {
335 VALUE val1 = DEREF(mem1, VALUE);
336 VALUE val2 = DEREF(mem2, VALUE);
337 VALUE ret = rb_funcall(val1, rb_intern("=="), 1, val2);
338 return ret == Qtrue;
339 }
340 default:
341 return !memcmp(mem1, mem2, native_slot_size(type));
342 }
343 }
344
345 // -----------------------------------------------------------------------------
346 // Map field utilities.
347 // -----------------------------------------------------------------------------
348
tryget_map_entry_msgdef(const upb_fielddef * field)349 const upb_msgdef* tryget_map_entry_msgdef(const upb_fielddef* field) {
350 const upb_msgdef* subdef;
351 if (upb_fielddef_label(field) != UPB_LABEL_REPEATED ||
352 upb_fielddef_type(field) != UPB_TYPE_MESSAGE) {
353 return NULL;
354 }
355 subdef = upb_fielddef_msgsubdef(field);
356 return upb_msgdef_mapentry(subdef) ? subdef : NULL;
357 }
358
map_entry_msgdef(const upb_fielddef * field)359 const upb_msgdef *map_entry_msgdef(const upb_fielddef* field) {
360 const upb_msgdef* subdef = tryget_map_entry_msgdef(field);
361 assert(subdef);
362 return subdef;
363 }
364
is_map_field(const upb_fielddef * field)365 bool is_map_field(const upb_fielddef *field) {
366 return tryget_map_entry_msgdef(field) != NULL;
367 }
368
map_field_key(const upb_fielddef * field)369 const upb_fielddef* map_field_key(const upb_fielddef* field) {
370 const upb_msgdef* subdef = map_entry_msgdef(field);
371 return map_entry_key(subdef);
372 }
373
map_field_value(const upb_fielddef * field)374 const upb_fielddef* map_field_value(const upb_fielddef* field) {
375 const upb_msgdef* subdef = map_entry_msgdef(field);
376 return map_entry_value(subdef);
377 }
378
map_entry_key(const upb_msgdef * msgdef)379 const upb_fielddef* map_entry_key(const upb_msgdef* msgdef) {
380 const upb_fielddef* key_field = upb_msgdef_itof(msgdef, MAP_KEY_FIELD);
381 assert(key_field != NULL);
382 return key_field;
383 }
384
map_entry_value(const upb_msgdef * msgdef)385 const upb_fielddef* map_entry_value(const upb_msgdef* msgdef) {
386 const upb_fielddef* value_field = upb_msgdef_itof(msgdef, MAP_VALUE_FIELD);
387 assert(value_field != NULL);
388 return value_field;
389 }
390
391 // -----------------------------------------------------------------------------
392 // Memory layout management.
393 // -----------------------------------------------------------------------------
394
align_up_to(size_t offset,size_t granularity)395 static size_t align_up_to(size_t offset, size_t granularity) {
396 // Granularity must be a power of two.
397 return (offset + granularity - 1) & ~(granularity - 1);
398 }
399
create_layout(const upb_msgdef * msgdef)400 MessageLayout* create_layout(const upb_msgdef* msgdef) {
401 MessageLayout* layout = ALLOC(MessageLayout);
402 int nfields = upb_msgdef_numfields(msgdef);
403 upb_msg_field_iter it;
404 upb_msg_oneof_iter oit;
405 size_t off = 0;
406
407 layout->fields = ALLOC_N(MessageField, nfields);
408
409 for (upb_msg_field_begin(&it, msgdef);
410 !upb_msg_field_done(&it);
411 upb_msg_field_next(&it)) {
412 const upb_fielddef* field = upb_msg_iter_field(&it);
413 size_t field_size;
414
415 if (upb_fielddef_containingoneof(field)) {
416 // Oneofs are handled separately below.
417 continue;
418 }
419
420 // Allocate |field_size| bytes for this field in the layout.
421 field_size = 0;
422 if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
423 field_size = sizeof(VALUE);
424 } else {
425 field_size = native_slot_size(upb_fielddef_type(field));
426 }
427 // Align current offset up to |size| granularity.
428 off = align_up_to(off, field_size);
429 layout->fields[upb_fielddef_index(field)].offset = off;
430 layout->fields[upb_fielddef_index(field)].case_offset =
431 MESSAGE_FIELD_NO_CASE;
432 off += field_size;
433 }
434
435 // Handle oneofs now -- we iterate over oneofs specifically and allocate only
436 // one slot per oneof.
437 //
438 // We assign all value slots first, then pack the 'case' fields at the end,
439 // since in the common case (modern 64-bit platform) these are 8 bytes and 4
440 // bytes respectively and we want to avoid alignment overhead.
441 //
442 // Note that we reserve 4 bytes (a uint32) per 'case' slot because the value
443 // space for oneof cases is conceptually as wide as field tag numbers. In
444 // practice, it's unlikely that a oneof would have more than e.g. 256 or 64K
445 // members (8 or 16 bits respectively), so conceivably we could assign
446 // consecutive case numbers and then pick a smaller oneof case slot size, but
447 // the complexity to implement this indirection is probably not worthwhile.
448 for (upb_msg_oneof_begin(&oit, msgdef);
449 !upb_msg_oneof_done(&oit);
450 upb_msg_oneof_next(&oit)) {
451 const upb_oneofdef* oneof = upb_msg_iter_oneof(&oit);
452 upb_oneof_iter fit;
453
454 // Always allocate NATIVE_SLOT_MAX_SIZE bytes, but share the slot between
455 // all fields.
456 size_t field_size = NATIVE_SLOT_MAX_SIZE;
457 // Align the offset.
458 off = align_up_to(off, field_size);
459 // Assign all fields in the oneof this same offset.
460 for (upb_oneof_begin(&fit, oneof);
461 !upb_oneof_done(&fit);
462 upb_oneof_next(&fit)) {
463 const upb_fielddef* field = upb_oneof_iter_field(&fit);
464 layout->fields[upb_fielddef_index(field)].offset = off;
465 }
466 off += field_size;
467 }
468
469 // Now the case fields.
470 for (upb_msg_oneof_begin(&oit, msgdef);
471 !upb_msg_oneof_done(&oit);
472 upb_msg_oneof_next(&oit)) {
473 const upb_oneofdef* oneof = upb_msg_iter_oneof(&oit);
474 upb_oneof_iter fit;
475
476 size_t field_size = sizeof(uint32_t);
477 // Align the offset.
478 off = (off + field_size - 1) & ~(field_size - 1);
479 // Assign all fields in the oneof this same offset.
480 for (upb_oneof_begin(&fit, oneof);
481 !upb_oneof_done(&fit);
482 upb_oneof_next(&fit)) {
483 const upb_fielddef* field = upb_oneof_iter_field(&fit);
484 layout->fields[upb_fielddef_index(field)].case_offset = off;
485 }
486 off += field_size;
487 }
488
489 layout->size = off;
490
491 layout->msgdef = msgdef;
492 upb_msgdef_ref(layout->msgdef, &layout->msgdef);
493
494 return layout;
495 }
496
free_layout(MessageLayout * layout)497 void free_layout(MessageLayout* layout) {
498 xfree(layout->fields);
499 upb_msgdef_unref(layout->msgdef, &layout->msgdef);
500 xfree(layout);
501 }
502
field_type_class(const upb_fielddef * field)503 VALUE field_type_class(const upb_fielddef* field) {
504 VALUE type_class = Qnil;
505 if (upb_fielddef_type(field) == UPB_TYPE_MESSAGE) {
506 VALUE submsgdesc =
507 get_def_obj(upb_fielddef_subdef(field));
508 type_class = Descriptor_msgclass(submsgdesc);
509 } else if (upb_fielddef_type(field) == UPB_TYPE_ENUM) {
510 VALUE subenumdesc =
511 get_def_obj(upb_fielddef_subdef(field));
512 type_class = EnumDescriptor_enummodule(subenumdesc);
513 }
514 return type_class;
515 }
516
slot_memory(MessageLayout * layout,const void * storage,const upb_fielddef * field)517 static void* slot_memory(MessageLayout* layout,
518 const void* storage,
519 const upb_fielddef* field) {
520 return ((uint8_t *)storage) +
521 layout->fields[upb_fielddef_index(field)].offset;
522 }
523
slot_oneof_case(MessageLayout * layout,const void * storage,const upb_fielddef * field)524 static uint32_t* slot_oneof_case(MessageLayout* layout,
525 const void* storage,
526 const upb_fielddef* field) {
527 return (uint32_t *)(((uint8_t *)storage) +
528 layout->fields[upb_fielddef_index(field)].case_offset);
529 }
530
531
layout_get(MessageLayout * layout,const void * storage,const upb_fielddef * field)532 VALUE layout_get(MessageLayout* layout,
533 const void* storage,
534 const upb_fielddef* field) {
535 void* memory = slot_memory(layout, storage, field);
536 uint32_t* oneof_case = slot_oneof_case(layout, storage, field);
537
538 if (upb_fielddef_containingoneof(field)) {
539 if (*oneof_case != upb_fielddef_number(field)) {
540 return Qnil;
541 }
542 return native_slot_get(upb_fielddef_type(field),
543 field_type_class(field),
544 memory);
545 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
546 return *((VALUE *)memory);
547 } else {
548 return native_slot_get(upb_fielddef_type(field),
549 field_type_class(field),
550 memory);
551 }
552 }
553
check_repeated_field_type(VALUE val,const upb_fielddef * field)554 static void check_repeated_field_type(VALUE val, const upb_fielddef* field) {
555 RepeatedField* self;
556 assert(upb_fielddef_label(field) == UPB_LABEL_REPEATED);
557
558 if (!RB_TYPE_P(val, T_DATA) || !RTYPEDDATA_P(val) ||
559 RTYPEDDATA_TYPE(val) != &RepeatedField_type) {
560 rb_raise(rb_eTypeError, "Expected repeated field array");
561 }
562
563 self = ruby_to_RepeatedField(val);
564 if (self->field_type != upb_fielddef_type(field)) {
565 rb_raise(rb_eTypeError, "Repeated field array has wrong element type");
566 }
567
568 if (self->field_type == UPB_TYPE_MESSAGE ||
569 self->field_type == UPB_TYPE_ENUM) {
570 if (self->field_type_class !=
571 get_def_obj(upb_fielddef_subdef(field))) {
572 rb_raise(rb_eTypeError,
573 "Repeated field array has wrong message/enum class");
574 }
575 }
576 }
577
check_map_field_type(VALUE val,const upb_fielddef * field)578 static void check_map_field_type(VALUE val, const upb_fielddef* field) {
579 const upb_fielddef* key_field = map_field_key(field);
580 const upb_fielddef* value_field = map_field_value(field);
581 Map* self;
582
583 if (!RB_TYPE_P(val, T_DATA) || !RTYPEDDATA_P(val) ||
584 RTYPEDDATA_TYPE(val) != &Map_type) {
585 rb_raise(rb_eTypeError, "Expected Map instance");
586 }
587
588 self = ruby_to_Map(val);
589 if (self->key_type != upb_fielddef_type(key_field)) {
590 rb_raise(rb_eTypeError, "Map key type does not match field's key type");
591 }
592 if (self->value_type != upb_fielddef_type(value_field)) {
593 rb_raise(rb_eTypeError, "Map value type does not match field's value type");
594 }
595 if (upb_fielddef_type(value_field) == UPB_TYPE_MESSAGE ||
596 upb_fielddef_type(value_field) == UPB_TYPE_ENUM) {
597 if (self->value_type_class !=
598 get_def_obj(upb_fielddef_subdef(value_field))) {
599 rb_raise(rb_eTypeError,
600 "Map value type has wrong message/enum class");
601 }
602 }
603 }
604
605
layout_set(MessageLayout * layout,void * storage,const upb_fielddef * field,VALUE val)606 void layout_set(MessageLayout* layout,
607 void* storage,
608 const upb_fielddef* field,
609 VALUE val) {
610 void* memory = slot_memory(layout, storage, field);
611 uint32_t* oneof_case = slot_oneof_case(layout, storage, field);
612
613 if (upb_fielddef_containingoneof(field)) {
614 if (val == Qnil) {
615 // Assigning nil to a oneof field clears the oneof completely.
616 *oneof_case = ONEOF_CASE_NONE;
617 memset(memory, 0, NATIVE_SLOT_MAX_SIZE);
618 } else {
619 // The transition between field types for a single oneof (union) slot is
620 // somewhat complex because we need to ensure that a GC triggered at any
621 // point by a call into the Ruby VM sees a valid state for this field and
622 // does not either go off into the weeds (following what it thinks is a
623 // VALUE but is actually a different field type) or miss an object (seeing
624 // what it thinks is a primitive field but is actually a VALUE for the new
625 // field type).
626 //
627 // In order for the transition to be safe, the oneof case slot must be in
628 // sync with the value slot whenever the Ruby VM has been called. Thus, we
629 // use native_slot_set_value_and_case(), which ensures that both the value
630 // and case number are altered atomically (w.r.t. the Ruby VM).
631 native_slot_set_value_and_case(
632 upb_fielddef_type(field), field_type_class(field),
633 memory, val,
634 oneof_case, upb_fielddef_number(field));
635 }
636 } else if (is_map_field(field)) {
637 check_map_field_type(val, field);
638 DEREF(memory, VALUE) = val;
639 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
640 check_repeated_field_type(val, field);
641 DEREF(memory, VALUE) = val;
642 } else {
643 native_slot_set(upb_fielddef_type(field), field_type_class(field),
644 memory, val);
645 }
646 }
647
layout_init(MessageLayout * layout,void * storage)648 void layout_init(MessageLayout* layout,
649 void* storage) {
650 upb_msg_field_iter it;
651 for (upb_msg_field_begin(&it, layout->msgdef);
652 !upb_msg_field_done(&it);
653 upb_msg_field_next(&it)) {
654 const upb_fielddef* field = upb_msg_iter_field(&it);
655 void* memory = slot_memory(layout, storage, field);
656 uint32_t* oneof_case = slot_oneof_case(layout, storage, field);
657
658 if (upb_fielddef_containingoneof(field)) {
659 memset(memory, 0, NATIVE_SLOT_MAX_SIZE);
660 *oneof_case = ONEOF_CASE_NONE;
661 } else if (is_map_field(field)) {
662 VALUE map = Qnil;
663
664 const upb_fielddef* key_field = map_field_key(field);
665 const upb_fielddef* value_field = map_field_value(field);
666 VALUE type_class = field_type_class(value_field);
667
668 if (type_class != Qnil) {
669 VALUE args[3] = {
670 fieldtype_to_ruby(upb_fielddef_type(key_field)),
671 fieldtype_to_ruby(upb_fielddef_type(value_field)),
672 type_class,
673 };
674 map = rb_class_new_instance(3, args, cMap);
675 } else {
676 VALUE args[2] = {
677 fieldtype_to_ruby(upb_fielddef_type(key_field)),
678 fieldtype_to_ruby(upb_fielddef_type(value_field)),
679 };
680 map = rb_class_new_instance(2, args, cMap);
681 }
682
683 DEREF(memory, VALUE) = map;
684 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
685 VALUE ary = Qnil;
686
687 VALUE type_class = field_type_class(field);
688
689 if (type_class != Qnil) {
690 VALUE args[2] = {
691 fieldtype_to_ruby(upb_fielddef_type(field)),
692 type_class,
693 };
694 ary = rb_class_new_instance(2, args, cRepeatedField);
695 } else {
696 VALUE args[1] = { fieldtype_to_ruby(upb_fielddef_type(field)) };
697 ary = rb_class_new_instance(1, args, cRepeatedField);
698 }
699
700 DEREF(memory, VALUE) = ary;
701 } else {
702 native_slot_init(upb_fielddef_type(field), memory);
703 }
704 }
705 }
706
layout_mark(MessageLayout * layout,void * storage)707 void layout_mark(MessageLayout* layout, void* storage) {
708 upb_msg_field_iter it;
709 for (upb_msg_field_begin(&it, layout->msgdef);
710 !upb_msg_field_done(&it);
711 upb_msg_field_next(&it)) {
712 const upb_fielddef* field = upb_msg_iter_field(&it);
713 void* memory = slot_memory(layout, storage, field);
714 uint32_t* oneof_case = slot_oneof_case(layout, storage, field);
715
716 if (upb_fielddef_containingoneof(field)) {
717 if (*oneof_case == upb_fielddef_number(field)) {
718 native_slot_mark(upb_fielddef_type(field), memory);
719 }
720 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
721 rb_gc_mark(DEREF(memory, VALUE));
722 } else {
723 native_slot_mark(upb_fielddef_type(field), memory);
724 }
725 }
726 }
727
layout_dup(MessageLayout * layout,void * to,void * from)728 void layout_dup(MessageLayout* layout, void* to, void* from) {
729 upb_msg_field_iter it;
730 for (upb_msg_field_begin(&it, layout->msgdef);
731 !upb_msg_field_done(&it);
732 upb_msg_field_next(&it)) {
733 const upb_fielddef* field = upb_msg_iter_field(&it);
734
735 void* to_memory = slot_memory(layout, to, field);
736 uint32_t* to_oneof_case = slot_oneof_case(layout, to, field);
737 void* from_memory = slot_memory(layout, from, field);
738 uint32_t* from_oneof_case = slot_oneof_case(layout, from, field);
739
740 if (upb_fielddef_containingoneof(field)) {
741 if (*from_oneof_case == upb_fielddef_number(field)) {
742 *to_oneof_case = *from_oneof_case;
743 native_slot_dup(upb_fielddef_type(field), to_memory, from_memory);
744 }
745 } else if (is_map_field(field)) {
746 DEREF(to_memory, VALUE) = Map_dup(DEREF(from_memory, VALUE));
747 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
748 DEREF(to_memory, VALUE) = RepeatedField_dup(DEREF(from_memory, VALUE));
749 } else {
750 native_slot_dup(upb_fielddef_type(field), to_memory, from_memory);
751 }
752 }
753 }
754
layout_deep_copy(MessageLayout * layout,void * to,void * from)755 void layout_deep_copy(MessageLayout* layout, void* to, void* from) {
756 upb_msg_field_iter it;
757 for (upb_msg_field_begin(&it, layout->msgdef);
758 !upb_msg_field_done(&it);
759 upb_msg_field_next(&it)) {
760 const upb_fielddef* field = upb_msg_iter_field(&it);
761
762 void* to_memory = slot_memory(layout, to, field);
763 uint32_t* to_oneof_case = slot_oneof_case(layout, to, field);
764 void* from_memory = slot_memory(layout, from, field);
765 uint32_t* from_oneof_case = slot_oneof_case(layout, from, field);
766
767 if (upb_fielddef_containingoneof(field)) {
768 if (*from_oneof_case == upb_fielddef_number(field)) {
769 *to_oneof_case = *from_oneof_case;
770 native_slot_deep_copy(upb_fielddef_type(field), to_memory, from_memory);
771 }
772 } else if (is_map_field(field)) {
773 DEREF(to_memory, VALUE) =
774 Map_deep_copy(DEREF(from_memory, VALUE));
775 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
776 DEREF(to_memory, VALUE) =
777 RepeatedField_deep_copy(DEREF(from_memory, VALUE));
778 } else {
779 native_slot_deep_copy(upb_fielddef_type(field), to_memory, from_memory);
780 }
781 }
782 }
783
layout_eq(MessageLayout * layout,void * msg1,void * msg2)784 VALUE layout_eq(MessageLayout* layout, void* msg1, void* msg2) {
785 upb_msg_field_iter it;
786 for (upb_msg_field_begin(&it, layout->msgdef);
787 !upb_msg_field_done(&it);
788 upb_msg_field_next(&it)) {
789 const upb_fielddef* field = upb_msg_iter_field(&it);
790
791 void* msg1_memory = slot_memory(layout, msg1, field);
792 uint32_t* msg1_oneof_case = slot_oneof_case(layout, msg1, field);
793 void* msg2_memory = slot_memory(layout, msg2, field);
794 uint32_t* msg2_oneof_case = slot_oneof_case(layout, msg2, field);
795
796 if (upb_fielddef_containingoneof(field)) {
797 if (*msg1_oneof_case != *msg2_oneof_case ||
798 (*msg1_oneof_case == upb_fielddef_number(field) &&
799 !native_slot_eq(upb_fielddef_type(field),
800 msg1_memory,
801 msg2_memory))) {
802 return Qfalse;
803 }
804 } else if (is_map_field(field)) {
805 if (!Map_eq(DEREF(msg1_memory, VALUE),
806 DEREF(msg2_memory, VALUE))) {
807 return Qfalse;
808 }
809 } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
810 if (!RepeatedField_eq(DEREF(msg1_memory, VALUE),
811 DEREF(msg2_memory, VALUE))) {
812 return Qfalse;
813 }
814 } else {
815 if (!native_slot_eq(upb_fielddef_type(field),
816 msg1_memory, msg2_memory)) {
817 return Qfalse;
818 }
819 }
820 }
821 return Qtrue;
822 }
823
layout_hash(MessageLayout * layout,void * storage)824 VALUE layout_hash(MessageLayout* layout, void* storage) {
825 upb_msg_field_iter it;
826 st_index_t h = rb_hash_start(0);
827 VALUE hash_sym = rb_intern("hash");
828 for (upb_msg_field_begin(&it, layout->msgdef);
829 !upb_msg_field_done(&it);
830 upb_msg_field_next(&it)) {
831 const upb_fielddef* field = upb_msg_iter_field(&it);
832 VALUE field_val = layout_get(layout, storage, field);
833 h = rb_hash_uint(h, NUM2LONG(rb_funcall(field_val, hash_sym, 0)));
834 }
835 h = rb_hash_end(h);
836
837 return INT2FIX(h);
838 }
839
layout_inspect(MessageLayout * layout,void * storage)840 VALUE layout_inspect(MessageLayout* layout, void* storage) {
841 VALUE str = rb_str_new2("");
842
843 upb_msg_field_iter it;
844 bool first = true;
845 for (upb_msg_field_begin(&it, layout->msgdef);
846 !upb_msg_field_done(&it);
847 upb_msg_field_next(&it)) {
848 const upb_fielddef* field = upb_msg_iter_field(&it);
849 VALUE field_val = layout_get(layout, storage, field);
850
851 if (!first) {
852 str = rb_str_cat2(str, ", ");
853 } else {
854 first = false;
855 }
856 str = rb_str_cat2(str, upb_fielddef_name(field));
857 str = rb_str_cat2(str, ": ");
858
859 str = rb_str_append(str, rb_funcall(field_val, rb_intern("inspect"), 0));
860 }
861
862 return str;
863 }
864