| #include <stdint.h> |
| #include <protobuf.h> |
| |
| // ----------------------------------------------------------------------------- |
| // PHP <-> native slot management. |
| // ----------------------------------------------------------------------------- |
| |
| static zval* int32_to_zval(int32_t value) { |
| zval* tmp; |
| MAKE_STD_ZVAL(tmp); |
| ZVAL_LONG(tmp, value); |
| php_printf("int32 to zval\n"); |
| // ZVAL_LONG(tmp, 1); |
| return tmp; |
| } |
| |
| #define DEREF(memory, type) *(type*)(memory) |
| |
| size_t native_slot_size(upb_fieldtype_t type) { |
| switch (type) { |
| case UPB_TYPE_FLOAT: return 4; |
| case UPB_TYPE_DOUBLE: return 8; |
| case UPB_TYPE_BOOL: return 1; |
| case UPB_TYPE_STRING: return sizeof(zval*); |
| case UPB_TYPE_BYTES: return sizeof(zval*); |
| case UPB_TYPE_MESSAGE: return sizeof(zval*); |
| case UPB_TYPE_ENUM: return 4; |
| case UPB_TYPE_INT32: return 4; |
| case UPB_TYPE_INT64: return 8; |
| case UPB_TYPE_UINT32: return 4; |
| case UPB_TYPE_UINT64: return 8; |
| default: return 0; |
| } |
| } |
| |
| static bool is_php_num(zval* value) { |
| // Is numerial string also valid? |
| return (Z_TYPE_P(value) == IS_LONG || |
| Z_TYPE_P(value) == IS_DOUBLE); |
| } |
| |
| void native_slot_check_int_range_precision(upb_fieldtype_t type, zval* val) { |
| // TODO(teboring): Add it back. |
| // if (!is_php_num(val)) { |
| // zend_error(E_ERROR, "Expected number type for integral field."); |
| // } |
| |
| // if (Z_TYPE_P(val) == IS_DOUBLE) { |
| // double dbl_val = NUM2DBL(val); |
| // if (floor(dbl_val) != dbl_val) { |
| // zend_error(E_ERROR, |
| // "Non-integral floating point value assigned to integer field."); |
| // } |
| // } |
| // if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) { |
| // if (NUM2DBL(val) < 0) { |
| // zend_error(E_ERROR, |
| // "Assigning negative value to unsigned integer field."); |
| // } |
| // } |
| } |
| |
| zval* native_slot_get(upb_fieldtype_t type, /*VALUE type_class,*/ |
| const void* memory TSRMLS_DC) { |
| zval* retval = NULL; |
| switch (type) { |
| // TODO(teboring): Add it back. |
| // case UPB_TYPE_FLOAT: |
| // return DBL2NUM(DEREF(memory, float)); |
| // case UPB_TYPE_DOUBLE: |
| // return DBL2NUM(DEREF(memory, double)); |
| // case UPB_TYPE_BOOL: |
| // return DEREF(memory, int8_t) ? Qtrue : Qfalse; |
| // case UPB_TYPE_STRING: |
| // case UPB_TYPE_BYTES: |
| // case UPB_TYPE_MESSAGE: |
| // return DEREF(memory, VALUE); |
| // case UPB_TYPE_ENUM: { |
| // int32_t val = DEREF(memory, int32_t); |
| // VALUE symbol = enum_lookup(type_class, INT2NUM(val)); |
| // if (symbol == Qnil) { |
| // return INT2NUM(val); |
| // } else { |
| // return symbol; |
| // } |
| // } |
| case UPB_TYPE_INT32: |
| return int32_to_zval(DEREF(memory, int32_t)); |
| // TODO(teboring): Add it back. |
| // case UPB_TYPE_INT64: |
| // return LL2NUM(DEREF(memory, int64_t)); |
| // case UPB_TYPE_UINT32: |
| // return UINT2NUM(DEREF(memory, uint32_t)); |
| // case UPB_TYPE_UINT64: |
| // return ULL2NUM(DEREF(memory, uint64_t)); |
| default: |
| return EG(uninitialized_zval_ptr); |
| } |
| } |
| |
| void native_slot_init(upb_fieldtype_t type, void* memory) { |
| switch (type) { |
| case UPB_TYPE_FLOAT: |
| DEREF(memory, float) = 0.0; |
| break; |
| case UPB_TYPE_DOUBLE: |
| DEREF(memory, double) = 0.0; |
| break; |
| case UPB_TYPE_BOOL: |
| DEREF(memory, int8_t) = 0; |
| break; |
| // TODO(teboring): Add it back. |
| // case UPB_TYPE_STRING: |
| // case UPB_TYPE_BYTES: |
| // DEREF(memory, VALUE) = php_str_new2(""); |
| // php_enc_associate(DEREF(memory, VALUE), (type == UPB_TYPE_BYTES) |
| // ? kRubyString8bitEncoding |
| // : kRubyStringUtf8Encoding); |
| // break; |
| // case UPB_TYPE_MESSAGE: |
| // DEREF(memory, VALUE) = Qnil; |
| // break; |
| case UPB_TYPE_ENUM: |
| case UPB_TYPE_INT32: |
| DEREF(memory, int32_t) = 0; |
| break; |
| case UPB_TYPE_INT64: |
| DEREF(memory, int64_t) = 0; |
| break; |
| case UPB_TYPE_UINT32: |
| DEREF(memory, uint32_t) = 0; |
| break; |
| case UPB_TYPE_UINT64: |
| DEREF(memory, uint64_t) = 0; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void native_slot_set(upb_fieldtype_t type, /*VALUE type_class,*/ void* memory, |
| zval* value) { |
| native_slot_set_value_and_case(type, /*type_class,*/ memory, value, NULL, 0); |
| } |
| |
| void native_slot_set_value_and_case(upb_fieldtype_t type, /*VALUE type_class,*/ |
| void* memory, zval* value, |
| uint32_t* case_memory, |
| uint32_t case_number) { |
| switch (type) { |
| case UPB_TYPE_FLOAT: |
| if (!Z_TYPE_P(value) == IS_LONG) { |
| zend_error(E_ERROR, "Expected number type for float field."); |
| } |
| DEREF(memory, float) = Z_DVAL_P(value); |
| break; |
| case UPB_TYPE_DOUBLE: |
| // TODO(teboring): Add it back. |
| // if (!is_php_num(value)) { |
| // zend_error(E_ERROR, "Expected number type for double field."); |
| // } |
| // DEREF(memory, double) = Z_DVAL_P(value); |
| break; |
| case UPB_TYPE_BOOL: { |
| int8_t val = -1; |
| if (zval_is_true(value)) { |
| val = 1; |
| } else { |
| val = 0; |
| } |
| // TODO(teboring): Add it back. |
| // else if (value == Qfalse) { |
| // val = 0; |
| // } |
| // else { |
| // php_raise(php_eTypeError, "Invalid argument for boolean field."); |
| // } |
| DEREF(memory, int8_t) = val; |
| break; |
| } |
| case UPB_TYPE_STRING: |
| case UPB_TYPE_BYTES: { |
| // TODO(teboring): Add it back. |
| // if (Z_TYPE_P(value) != IS_STRING) { |
| // zend_error(E_ERROR, "Invalid argument for string field."); |
| // } |
| // native_slot_validate_string_encoding(type, value); |
| // DEREF(memory, zval*) = value; |
| break; |
| } |
| case UPB_TYPE_MESSAGE: { |
| // TODO(teboring): Add it back. |
| // if (CLASS_OF(value) == CLASS_OF(Qnil)) { |
| // value = Qnil; |
| // } else if (CLASS_OF(value) != type_class) { |
| // php_raise(php_eTypeError, |
| // "Invalid type %s to assign to submessage field.", |
| // php_class2name(CLASS_OF(value))); |
| // } |
| // DEREF(memory, VALUE) = value; |
| break; |
| } |
| case UPB_TYPE_ENUM: { |
| // TODO(teboring): Add it back. |
| // int32_t int_val = 0; |
| // if (!is_php_num(value) && TYPE(value) != T_SYMBOL) { |
| // php_raise(php_eTypeError, |
| // "Expected number or symbol type for enum field."); |
| // } |
| // if (TYPE(value) == T_SYMBOL) { |
| // // Ensure that the given symbol exists in the enum module. |
| // VALUE lookup = php_funcall(type_class, php_intern("resolve"), 1, value); |
| // if (lookup == Qnil) { |
| // php_raise(php_eRangeError, "Unknown symbol value for enum field."); |
| // } else { |
| // int_val = NUM2INT(lookup); |
| // } |
| // } else { |
| // native_slot_check_int_range_precision(UPB_TYPE_INT32, value); |
| // int_val = NUM2INT(value); |
| // } |
| // DEREF(memory, int32_t) = int_val; |
| // break; |
| } |
| case UPB_TYPE_INT32: |
| case UPB_TYPE_INT64: |
| case UPB_TYPE_UINT32: |
| case UPB_TYPE_UINT64: |
| native_slot_check_int_range_precision(type, value); |
| switch (type) { |
| case UPB_TYPE_INT32: |
| php_printf("Setting INT32 field\n"); |
| DEREF(memory, int32_t) = Z_LVAL_P(value); |
| break; |
| case UPB_TYPE_INT64: |
| // TODO(teboring): Add it back. |
| // DEREF(memory, int64_t) = NUM2LL(value); |
| break; |
| case UPB_TYPE_UINT32: |
| // TODO(teboring): Add it back. |
| // DEREF(memory, uint32_t) = NUM2UINT(value); |
| break; |
| case UPB_TYPE_UINT64: |
| // TODO(teboring): Add it back. |
| // DEREF(memory, uint64_t) = NUM2ULL(value); |
| break; |
| default: |
| break; |
| } |
| break; |
| default: |
| break; |
| } |
| |
| if (case_memory != NULL) { |
| *case_memory = case_number; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Map field utilities. |
| // ---------------------------------------------------------------------------- |
| |
| const upb_msgdef* tryget_map_entry_msgdef(const upb_fielddef* field) { |
| const upb_msgdef* subdef; |
| if (upb_fielddef_label(field) != UPB_LABEL_REPEATED || |
| upb_fielddef_type(field) != UPB_TYPE_MESSAGE) { |
| return NULL; |
| } |
| subdef = upb_fielddef_msgsubdef(field); |
| return upb_msgdef_mapentry(subdef) ? subdef : NULL; |
| } |
| |
| const upb_msgdef* map_entry_msgdef(const upb_fielddef* field) { |
| const upb_msgdef* subdef = tryget_map_entry_msgdef(field); |
| assert(subdef); |
| return subdef; |
| } |
| |
| bool is_map_field(const upb_fielddef* field) { |
| return tryget_map_entry_msgdef(field) != NULL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Memory layout management. |
| // ----------------------------------------------------------------------------- |
| |
| static size_t align_up_to(size_t offset, size_t granularity) { |
| // Granularity must be a power of two. |
| return (offset + granularity - 1) & ~(granularity - 1); |
| } |
| |
| MessageLayout* create_layout(const upb_msgdef* msgdef) { |
| MessageLayout* layout = ALLOC(MessageLayout); |
| int nfields = upb_msgdef_numfields(msgdef); |
| upb_msg_field_iter it; |
| upb_msg_oneof_iter oit; |
| size_t off = 0; |
| |
| layout->fields = ALLOC_N(MessageField, nfields); |
| |
| 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); |
| size_t field_size; |
| |
| if (upb_fielddef_containingoneof(field)) { |
| // Oneofs are handled separately below. |
| continue; |
| } |
| |
| // Allocate |field_size| bytes for this field in the layout. |
| field_size = 0; |
| if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) { |
| field_size = sizeof(zval*); |
| } else { |
| field_size = native_slot_size(upb_fielddef_type(field)); |
| } |
| |
| // Align current offset up to | size | granularity. |
| off = align_up_to(off, field_size); |
| layout->fields[upb_fielddef_index(field)].offset = off; |
| layout->fields[upb_fielddef_index(field)].case_offset = |
| MESSAGE_FIELD_NO_CASE; |
| off += field_size; |
| } |
| |
| // Handle oneofs now -- we iterate over oneofs specifically and allocate only |
| // one slot per oneof. |
| // |
| // We assign all value slots first, then pack the 'case' fields at the end, |
| // since in the common case (modern 64-bit platform) these are 8 bytes and 4 |
| // bytes respectively and we want to avoid alignment overhead. |
| // |
| // Note that we reserve 4 bytes (a uint32) per 'case' slot because the value |
| // space for oneof cases is conceptually as wide as field tag numbers. In |
| // practice, it's unlikely that a oneof would have more than e.g. 256 or 64K |
| // members (8 or 16 bits respectively), so conceivably we could assign |
| // consecutive case numbers and then pick a smaller oneof case slot size, but |
| // the complexity to implement this indirection is probably not worthwhile. |
| for (upb_msg_oneof_begin(&oit, msgdef); !upb_msg_oneof_done(&oit); |
| upb_msg_oneof_next(&oit)) { |
| const upb_oneofdef* oneof = upb_msg_iter_oneof(&oit); |
| upb_oneof_iter fit; |
| |
| // Always allocate NATIVE_SLOT_MAX_SIZE bytes, but share the slot between |
| // all fields. |
| size_t field_size = NATIVE_SLOT_MAX_SIZE; |
| // Align the offset . |
| off = align_up_to( off, field_size); |
| // Assign all fields in the oneof this same offset. |
| for (upb_oneof_begin(&fit, oneof); !upb_oneof_done(&fit); |
| upb_oneof_next(&fit)) { |
| const upb_fielddef* field = upb_oneof_iter_field(&fit); |
| layout->fields[upb_fielddef_index(field)].offset = off; |
| } |
| off += field_size; |
| } |
| |
| // Now the case fields. |
| for (upb_msg_oneof_begin(&oit, msgdef); !upb_msg_oneof_done(&oit); |
| upb_msg_oneof_next(&oit)) { |
| const upb_oneofdef* oneof = upb_msg_iter_oneof(&oit); |
| upb_oneof_iter fit; |
| |
| size_t field_size = sizeof(uint32_t); |
| // Align the offset . |
| off = (off + field_size - 1) & ~(field_size - 1); |
| // Assign all fields in the oneof this same offset. |
| for (upb_oneof_begin(&fit, oneof); !upb_oneof_done(&fit); |
| upb_oneof_next(&fit)) { |
| const upb_fielddef* field = upb_oneof_iter_field(&fit); |
| layout->fields[upb_fielddef_index(field)].case_offset = off; |
| } |
| off += field_size; |
| } |
| |
| layout->size = off; |
| |
| layout->msgdef = msgdef; |
| upb_msgdef_ref(layout->msgdef, &layout->msgdef); |
| |
| return layout; |
| } |
| |
| void free_layout(MessageLayout* layout) { |
| FREE(layout->fields); |
| upb_msgdef_unref(layout->msgdef, &layout->msgdef); |
| FREE(layout); |
| } |
| |
| // TODO(teboring): Add it back. |
| // VALUE field_type_class(const upb_fielddef* field) { |
| // VALUE type_class = Qnil; |
| // if (upb_fielddef_type(field) == UPB_TYPE_MESSAGE) { |
| // 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_def_obj(upb_fielddef_subdef(field)); |
| // type_class = EnumDescriptor_enummodule(subenumdesc); |
| // } |
| // return type_class; |
| // } |
| |
| static void* slot_memory(MessageLayout* layout, const void* storage, |
| const upb_fielddef* field) { |
| return ((uint8_t*)storage) + layout->fields[upb_fielddef_index(field)].offset; |
| } |
| |
| static uint32_t* slot_oneof_case(MessageLayout* layout, const void* storage, |
| const upb_fielddef* field) { |
| return (uint32_t*)(((uint8_t*)storage) + |
| layout->fields[upb_fielddef_index(field)].case_offset); |
| } |
| |
| void layout_set(MessageLayout* layout, void* storage, const upb_fielddef* field, |
| zval* val) { |
| void* memory = slot_memory(layout, storage, field); |
| uint32_t* oneof_case = slot_oneof_case(layout, storage, field); |
| |
| if (upb_fielddef_containingoneof(field)) { |
| if (Z_TYPE_P(val) == IS_NULL) { |
| // Assigning nil to a oneof field clears the oneof completely. |
| *oneof_case = ONEOF_CASE_NONE; |
| memset(memory, 0, NATIVE_SLOT_MAX_SIZE); |
| } else { |
| // The transition between field types for a single oneof (union) slot is |
| // somewhat complex because we need to ensure that a GC triggered at any |
| // point by a call into the Ruby VM sees a valid state for this field and |
| // does not either go off into the weeds (following what it thinks is a |
| // VALUE but is actually a different field type) or miss an object (seeing |
| // what it thinks is a primitive field but is actually a VALUE for the new |
| // field type). |
| // |
| // In order for the transition to be safe, the oneof case slot must be in |
| // sync with the value slot whenever the Ruby VM has been called. Thus, we |
| // use native_slot_set_value_and_case(), which ensures that both the value |
| // and case number are altered atomically (w.r.t. the Ruby VM). |
| native_slot_set_value_and_case(upb_fielddef_type(field), |
| /*field_type_class(field),*/ memory, val, |
| oneof_case, upb_fielddef_number(field)); |
| } |
| } else if (is_map_field(field)) { |
| // TODO(teboring): Add it back. |
| // check_map_field_type(val, field); |
| // DEREF(memory, zval*) = val; |
| } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) { |
| // TODO(teboring): Add it back. |
| // check_repeated_field_type(val, field); |
| // DEREF(memory, zval*) = val; |
| } else { |
| native_slot_set(upb_fielddef_type(field), /*field_type_class(field),*/ memory, |
| val); |
| } |
| } |
| |
| void layout_init(MessageLayout* layout, void* storage) { |
| upb_msg_field_iter it; |
| for (upb_msg_field_begin(&it, layout->msgdef); !upb_msg_field_done(&it); |
| upb_msg_field_next(&it)) { |
| const upb_fielddef* field = upb_msg_iter_field(&it); |
| void* memory = slot_memory(layout, storage, field); |
| uint32_t* oneof_case = slot_oneof_case(layout, storage, field); |
| |
| if (upb_fielddef_containingoneof(field)) { |
| // TODO(teboring): Add it back. |
| // memset(memory, 0, NATIVE_SLOT_MAX_SIZE); |
| // *oneof_case = ONEOF_CASE_NONE; |
| } else if (is_map_field(field)) { |
| // TODO(teboring): Add it back. |
| // VALUE map = Qnil; |
| |
| // const upb_fielddef* key_field = map_field_key(field); |
| // const upb_fielddef* value_field = map_field_value(field); |
| // VALUE type_class = field_type_class(value_field); |
| |
| // if (type_class != Qnil) { |
| // VALUE args[3] = { |
| // fieldtype_to_php(upb_fielddef_type(key_field)), |
| // fieldtype_to_php(upb_fielddef_type(value_field)), type_class, |
| // }; |
| // map = php_class_new_instance(3, args, cMap); |
| // } else { |
| // VALUE args[2] = { |
| // fieldtype_to_php(upb_fielddef_type(key_field)), |
| // fieldtype_to_php(upb_fielddef_type(value_field)), |
| // }; |
| // map = php_class_new_instance(2, args, cMap); |
| // } |
| |
| // DEREF(memory, VALUE) = map; |
| } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) { |
| // TODO(teboring): Add it back. |
| // VALUE ary = Qnil; |
| |
| // VALUE type_class = field_type_class(field); |
| |
| // if (type_class != Qnil) { |
| // VALUE args[2] = { |
| // fieldtype_to_php(upb_fielddef_type(field)), type_class, |
| // }; |
| // ary = php_class_new_instance(2, args, cRepeatedField); |
| // } else { |
| // VALUE args[1] = {fieldtype_to_php(upb_fielddef_type(field))}; |
| // ary = php_class_new_instance(1, args, cRepeatedField); |
| // } |
| |
| // DEREF(memory, VALUE) = ary; |
| } else { |
| native_slot_init(upb_fielddef_type(field), memory); |
| } |
| } |
| } |
| |
| zval* layout_get(MessageLayout* layout, const void* storage, |
| const upb_fielddef* field TSRMLS_DC) { |
| void* memory = slot_memory(layout, storage, field); |
| uint32_t* oneof_case = slot_oneof_case(layout, storage, field); |
| |
| if (upb_fielddef_containingoneof(field)) { |
| if (*oneof_case != upb_fielddef_number(field)) { |
| return NULL; |
| // TODO(teboring): Add it back. |
| // return Qnil; |
| } |
| return NULL; |
| // TODO(teboring): Add it back. |
| // return native_slot_get(upb_fielddef_type(field), field_type_class(field), |
| // memory); |
| } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) { |
| return NULL; |
| // TODO(teboring): Add it back. |
| // return *((VALUE*)memory); |
| } else { |
| return native_slot_get( |
| upb_fielddef_type(field), /*field_type_class(field), */ |
| memory TSRMLS_CC); |
| } |
| } |
