diff options
Diffstat (limited to 'php/ext/google/protobuf/def.c')
-rw-r--r-- | php/ext/google/protobuf/def.c | 977 |
1 files changed, 783 insertions, 194 deletions
diff --git a/php/ext/google/protobuf/def.c b/php/ext/google/protobuf/def.c index 32b158e2..fa33830b 100644 --- a/php/ext/google/protobuf/def.c +++ b/php/ext/google/protobuf/def.c @@ -31,21 +31,30 @@ #include "protobuf.h" // Forward declare. -static zend_object_value descriptor_create(zend_class_entry *ce TSRMLS_DC); static void descriptor_init_c_instance(Descriptor* intern TSRMLS_DC); static void descriptor_free_c(Descriptor* object TSRMLS_DC); -static void descriptor_free(void* object TSRMLS_DC); -static zend_object_value enum_descriptor_create(zend_class_entry *ce TSRMLS_DC); +static void field_descriptor_init_c_instance(FieldDescriptor* intern TSRMLS_DC); +static void field_descriptor_free_c(FieldDescriptor* object TSRMLS_DC); + static void enum_descriptor_init_c_instance(EnumDescriptor* intern TSRMLS_DC); static void enum_descriptor_free_c(EnumDescriptor* object TSRMLS_DC); -static void enum_descriptor_free(void* object TSRMLS_DC); -static zend_object_value descriptor_pool_create(zend_class_entry *ce TSRMLS_DC); +static void enum_value_descriptor_init_c_instance( + EnumValueDescriptor *intern TSRMLS_DC); +static void enum_value_descriptor_free_c(EnumValueDescriptor *object TSRMLS_DC); + static void descriptor_pool_free_c(DescriptorPool* object TSRMLS_DC); -static void descriptor_pool_free(void* object TSRMLS_DC); static void descriptor_pool_init_c_instance(DescriptorPool* pool TSRMLS_DC); +static void internal_descriptor_pool_free_c( + InternalDescriptorPool *object TSRMLS_DC); +static void internal_descriptor_pool_init_c_instance( + InternalDescriptorPool *pool TSRMLS_DC); + +static void oneof_descriptor_free_c(Oneof* object TSRMLS_DC); +static void oneof_descriptor_init_c_instance(Oneof* pool TSRMLS_DC); + // ----------------------------------------------------------------------------- // Common Utilities // ----------------------------------------------------------------------------- @@ -103,42 +112,6 @@ static void append_map_entry_name(char *result, const char *field_name, check_upb_status(&status, msg); \ } while (0) -// Define PHP class -#define DEFINE_PROTOBUF_INIT_CLASS(name_lower, string_name) \ - void name_lower##_init(TSRMLS_D) { \ - zend_class_entry class_type; \ - INIT_CLASS_ENTRY(class_type, string_name, name_lower##_methods); \ - name_lower##_type = zend_register_internal_class(&class_type TSRMLS_CC); \ - name_lower##_type->create_object = name_lower##_create; \ - } - -#define DEFINE_PROTOBUF_CREATE(name, name_lower) \ - static zend_object_value name_lower##_create( \ - zend_class_entry* ce TSRMLS_DC) { \ - zend_object_value return_value; \ - name* intern = (name*)emalloc(sizeof(name)); \ - memset(intern, 0, sizeof(name)); \ - name_lower##_init_c_instance(intern TSRMLS_CC); \ - return_value.handle = zend_objects_store_put( \ - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, \ - name_lower##_free, NULL TSRMLS_CC); \ - return_value.handlers = zend_get_std_object_handlers(); \ - return return_value; \ - } - -#define DEFINE_PROTOBUF_FREE(name, name_lower) \ - static void name_lower##_free(void* object TSRMLS_DC) { \ - name* intern = (name*)object; \ - name_lower##_free_c(intern TSRMLS_CC); \ - efree(object); \ - } - -#define DEFINE_CLASS(name, name_lower, string_name) \ - zend_class_entry* name_lower##_type; \ - DEFINE_PROTOBUF_FREE(name, name_lower) \ - DEFINE_PROTOBUF_CREATE(name, name_lower) \ - DEFINE_PROTOBUF_INIT_CLASS(name_lower, string_name) - // ----------------------------------------------------------------------------- // GPBType // ----------------------------------------------------------------------------- @@ -177,51 +150,531 @@ void gpb_type_init(TSRMLS_D) { } // ----------------------------------------------------------------------------- +// Descriptor +// ----------------------------------------------------------------------------- + +static zend_function_entry descriptor_methods[] = { + PHP_ME(Descriptor, getClass, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Descriptor, getFullName, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Descriptor, getField, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Descriptor, getFieldCount, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Descriptor, getOneofDecl, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Descriptor, getOneofDeclCount, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +DEFINE_CLASS(Descriptor, descriptor, "Google\\Protobuf\\Descriptor"); + +static void descriptor_free_c(Descriptor *self TSRMLS_DC) { + 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); + } +} + +static void descriptor_init_c_instance(Descriptor *desc TSRMLS_DC) { + desc->msgdef = NULL; + desc->layout = NULL; + desc->klass = NULL; + desc->fill_handlers = NULL; + desc->fill_method = NULL; + desc->json_fill_method = NULL; + desc->pb_serialize_handlers = NULL; + desc->json_serialize_handlers = NULL; + desc->json_serialize_handlers_preserve = NULL; +} + +PHP_METHOD(Descriptor, getClass) { + Descriptor *intern = UNBOX(Descriptor, getThis()); +#if PHP_MAJOR_VERSION < 7 + const char* classname = intern->klass->name; +#else + const char* classname = ZSTR_VAL(intern->klass->name); +#endif + PHP_PROTO_RETVAL_STRINGL(classname, strlen(classname), 1); +} + +PHP_METHOD(Descriptor, getFullName) { + Descriptor *intern = UNBOX(Descriptor, getThis()); + const char* fullname = upb_msgdef_fullname(intern->msgdef); + PHP_PROTO_RETVAL_STRINGL(fullname, strlen(fullname), 1); +} + +PHP_METHOD(Descriptor, getField) { + long index; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == + FAILURE) { + zend_error(E_USER_ERROR, "Expect integer for index.\n"); + return; + } + + Descriptor *intern = UNBOX(Descriptor, getThis()); + int field_num = upb_msgdef_numfields(intern->msgdef); + if (index < 0 || index >= field_num) { + zend_error(E_USER_ERROR, "Cannot get element at %ld.\n", index); + return; + } + + upb_msg_field_iter iter; + int i; + for(upb_msg_field_begin(&iter, intern->msgdef), i = 0; + !upb_msg_field_done(&iter) && i < index; + upb_msg_field_next(&iter), i++); + const upb_fielddef *field = upb_msg_iter_field(&iter); + + PHP_PROTO_HASHTABLE_VALUE field_hashtable_value = get_def_obj(field); + if (field_hashtable_value == NULL) { +#if PHP_MAJOR_VERSION < 7 + MAKE_STD_ZVAL(field_hashtable_value); + ZVAL_OBJ(field_hashtable_value, field_descriptor_type->create_object( + field_descriptor_type TSRMLS_CC)); + Z_DELREF_P(field_hashtable_value); +#else + field_hashtable_value = + field_descriptor_type->create_object(field_descriptor_type TSRMLS_CC); + --GC_REFCOUNT(field_hashtable_value); +#endif + FieldDescriptor *field_php = + UNBOX_HASHTABLE_VALUE(FieldDescriptor, field_hashtable_value); + field_php->fielddef = field; + add_def_obj(field, field_hashtable_value); + } + +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(field_hashtable_value, 1, 0); +#else + ++GC_REFCOUNT(field_hashtable_value); + RETURN_OBJ(field_hashtable_value); +#endif +} + +PHP_METHOD(Descriptor, getFieldCount) { + Descriptor *intern = UNBOX(Descriptor, getThis()); + RETURN_LONG(upb_msgdef_numfields(intern->msgdef)); +} + +PHP_METHOD(Descriptor, getOneofDecl) { + long index; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == + FAILURE) { + zend_error(E_USER_ERROR, "Expect integer for index.\n"); + return; + } + + Descriptor *intern = UNBOX(Descriptor, getThis()); + int field_num = upb_msgdef_numoneofs(intern->msgdef); + if (index < 0 || index >= field_num) { + zend_error(E_USER_ERROR, "Cannot get element at %ld.\n", index); + return; + } + + upb_msg_oneof_iter iter; + int i; + for(upb_msg_oneof_begin(&iter, intern->msgdef), i = 0; + !upb_msg_oneof_done(&iter) && i < index; + upb_msg_oneof_next(&iter), i++); + upb_oneofdef *oneof = upb_msg_iter_oneof(&iter); + + ZVAL_OBJ(return_value, oneof_descriptor_type->create_object( + oneof_descriptor_type TSRMLS_CC)); + Oneof *oneof_php = UNBOX(Oneof, return_value); + oneof_php->oneofdef = oneof; +} + +PHP_METHOD(Descriptor, getOneofDeclCount) { + Descriptor *intern = UNBOX(Descriptor, getThis()); + RETURN_LONG(upb_msgdef_numoneofs(intern->msgdef)); +} + +// ----------------------------------------------------------------------------- +// EnumDescriptor +// ----------------------------------------------------------------------------- + +static zend_function_entry enum_descriptor_methods[] = { + PHP_ME(EnumDescriptor, getValue, NULL, ZEND_ACC_PUBLIC) + PHP_ME(EnumDescriptor, getValueCount, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +DEFINE_CLASS(EnumDescriptor, enum_descriptor, + "Google\\Protobuf\\EnumDescriptor"); + +static void enum_descriptor_free_c(EnumDescriptor *self TSRMLS_DC) { +} + +static void enum_descriptor_init_c_instance(EnumDescriptor *self TSRMLS_DC) { + self->enumdef = NULL; + self->klass = NULL; +} + +PHP_METHOD(EnumDescriptor, getValue) { + long index; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == + FAILURE) { + zend_error(E_USER_ERROR, "Expect integer for index.\n"); + return; + } + + EnumDescriptor *intern = UNBOX(EnumDescriptor, getThis()); + int field_num = upb_enumdef_numvals(intern->enumdef); + if (index < 0 || index >= field_num) { + zend_error(E_USER_ERROR, "Cannot get element at %ld.\n", index); + return; + } + + upb_enum_iter iter; + int i; + for(upb_enum_begin(&iter, intern->enumdef), i = 0; + !upb_enum_done(&iter) && i < index; + upb_enum_next(&iter), i++); + + ZVAL_OBJ(return_value, enum_value_descriptor_type->create_object( + enum_value_descriptor_type TSRMLS_CC)); + EnumValueDescriptor *enum_value_php = + UNBOX(EnumValueDescriptor, return_value); + enum_value_php->name = upb_enum_iter_name(&iter); + enum_value_php->number = upb_enum_iter_number(&iter); +} + +PHP_METHOD(EnumDescriptor, getValueCount) { + EnumDescriptor *intern = UNBOX(EnumDescriptor, getThis()); + RETURN_LONG(upb_enumdef_numvals(intern->enumdef)); +} + +// ----------------------------------------------------------------------------- +// EnumValueDescriptor +// ----------------------------------------------------------------------------- + +static zend_function_entry enum_value_descriptor_methods[] = { + PHP_ME(EnumValueDescriptor, getName, NULL, ZEND_ACC_PUBLIC) + PHP_ME(EnumValueDescriptor, getNumber, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +DEFINE_CLASS(EnumValueDescriptor, enum_value_descriptor, + "Google\\Protobuf\\EnumValueDescriptor"); + +static void enum_value_descriptor_free_c(EnumValueDescriptor *self TSRMLS_DC) { +} + +static void enum_value_descriptor_init_c_instance(EnumValueDescriptor *self TSRMLS_DC) { + self->name = NULL; + self->number = 0; +} + +PHP_METHOD(EnumValueDescriptor, getName) { + EnumValueDescriptor *intern = UNBOX(EnumValueDescriptor, getThis()); + PHP_PROTO_RETVAL_STRINGL(intern->name, strlen(intern->name), 1); +} + +PHP_METHOD(EnumValueDescriptor, getNumber) { + EnumValueDescriptor *intern = UNBOX(EnumValueDescriptor, getThis()); + RETURN_LONG(intern->number); +} + +// ----------------------------------------------------------------------------- +// FieldDescriptor +// ----------------------------------------------------------------------------- + +static zend_function_entry field_descriptor_methods[] = { + PHP_ME(FieldDescriptor, getName, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, getNumber, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, getLabel, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, getType, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, isMap, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, getEnumType, NULL, ZEND_ACC_PUBLIC) + PHP_ME(FieldDescriptor, getMessageType, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +DEFINE_CLASS(FieldDescriptor, field_descriptor, + "Google\\Protobuf\\FieldDescriptor"); + +static void field_descriptor_free_c(FieldDescriptor *self TSRMLS_DC) { +} + +static void field_descriptor_init_c_instance(FieldDescriptor *self TSRMLS_DC) { + self->fielddef = NULL; +} + +upb_fieldtype_t to_fieldtype(upb_descriptortype_t type) { + switch (type) { +#define CASE(descriptor_type, type) \ + case UPB_DESCRIPTOR_TYPE_##descriptor_type: \ + return UPB_TYPE_##type; + + CASE(FLOAT, FLOAT); + CASE(DOUBLE, DOUBLE); + CASE(BOOL, BOOL); + CASE(STRING, STRING); + CASE(BYTES, BYTES); + CASE(MESSAGE, MESSAGE); + CASE(GROUP, MESSAGE); + CASE(ENUM, ENUM); + CASE(INT32, INT32); + CASE(INT64, INT64); + CASE(UINT32, UINT32); + CASE(UINT64, UINT64); + CASE(SINT32, INT32); + CASE(SINT64, INT64); + CASE(FIXED32, UINT32); + CASE(FIXED64, UINT64); + CASE(SFIXED32, INT32); + CASE(SFIXED64, INT64); + +#undef CONVERT + + } + + zend_error(E_ERROR, "Unknown field type."); + return 0; +} + +PHP_METHOD(FieldDescriptor, getName) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + const char* name = upb_fielddef_name(intern->fielddef); + PHP_PROTO_RETVAL_STRINGL(name, strlen(name), 1); +} + +PHP_METHOD(FieldDescriptor, getNumber) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + RETURN_LONG(upb_fielddef_number(intern->fielddef)); +} + +PHP_METHOD(FieldDescriptor, getLabel) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + RETURN_LONG(upb_fielddef_label(intern->fielddef)); +} + +PHP_METHOD(FieldDescriptor, getType) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + RETURN_LONG(upb_fielddef_descriptortype(intern->fielddef)); +} + +PHP_METHOD(FieldDescriptor, isMap) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + RETURN_BOOL(upb_fielddef_ismap(intern->fielddef)); +} + +PHP_METHOD(FieldDescriptor, getEnumType) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + const upb_enumdef *enumdef = upb_fielddef_enumsubdef(intern->fielddef); + if (enumdef == NULL) { + char error_msg[100]; + sprintf(error_msg, "Cannot get enum type for non-enum field '%s'", + upb_fielddef_name(intern->fielddef)); + zend_throw_exception(NULL, error_msg, 0 TSRMLS_CC); + return; + } + PHP_PROTO_HASHTABLE_VALUE desc = get_def_obj(enumdef); + +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(desc, 1, 0); +#else + ++GC_REFCOUNT(desc); + RETURN_OBJ(desc); +#endif +} + +PHP_METHOD(FieldDescriptor, getMessageType) { + FieldDescriptor *intern = UNBOX(FieldDescriptor, getThis()); + const upb_msgdef *msgdef = upb_fielddef_msgsubdef(intern->fielddef); + if (msgdef == NULL) { + char error_msg[100]; + sprintf(error_msg, "Cannot get message type for non-message field '%s'", + upb_fielddef_name(intern->fielddef)); + zend_throw_exception(NULL, error_msg, 0 TSRMLS_CC); + return; + } + PHP_PROTO_HASHTABLE_VALUE desc = get_def_obj(msgdef); + +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(desc, 1, 0); +#else + ++GC_REFCOUNT(desc); + RETURN_OBJ(desc); +#endif +} + +// ----------------------------------------------------------------------------- +// Oneof +// ----------------------------------------------------------------------------- + +static zend_function_entry oneof_descriptor_methods[] = { + PHP_ME(Oneof, getName, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Oneof, getField, NULL, ZEND_ACC_PUBLIC) + PHP_ME(Oneof, getFieldCount, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +DEFINE_CLASS(Oneof, oneof_descriptor, + "Google\\Protobuf\\OneofDescriptor"); + +static void oneof_descriptor_free_c(Oneof *self TSRMLS_DC) { +} + +static void oneof_descriptor_init_c_instance(Oneof *self TSRMLS_DC) { + self->oneofdef = NULL; +} + +PHP_METHOD(Oneof, getName) { + Oneof *intern = UNBOX(Oneof, getThis()); + const char *name = upb_oneofdef_name(intern->oneofdef); + PHP_PROTO_RETVAL_STRINGL(name, strlen(name), 1); +} + +PHP_METHOD(Oneof, getField) { + long index; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == + FAILURE) { + zend_error(E_USER_ERROR, "Expect integer for index.\n"); + return; + } + + Oneof *intern = UNBOX(Oneof, getThis()); + int field_num = upb_oneofdef_numfields(intern->oneofdef); + if (index < 0 || index >= field_num) { + zend_error(E_USER_ERROR, "Cannot get element at %ld.\n", index); + return; + } + + upb_oneof_iter iter; + int i; + for(upb_oneof_begin(&iter, intern->oneofdef), i = 0; + !upb_oneof_done(&iter) && i < index; + upb_oneof_next(&iter), i++); + const upb_fielddef *field = upb_oneof_iter_field(&iter); + + PHP_PROTO_HASHTABLE_VALUE field_hashtable_value = get_def_obj(field); + if (field_hashtable_value == NULL) { +#if PHP_MAJOR_VERSION < 7 + MAKE_STD_ZVAL(field_hashtable_value); + ZVAL_OBJ(field_hashtable_value, field_descriptor_type->create_object( + field_descriptor_type TSRMLS_CC)); +#else + field_hashtable_value = + field_descriptor_type->create_object(field_descriptor_type TSRMLS_CC); +#endif + FieldDescriptor *field_php = + UNBOX_HASHTABLE_VALUE(FieldDescriptor, field_hashtable_value); + field_php->fielddef = field; + add_def_obj(field, field_hashtable_value); + } + +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(field_hashtable_value, 1, 0); +#else + ++GC_REFCOUNT(field_hashtable_value); + RETURN_OBJ(field_hashtable_value); +#endif +} + +PHP_METHOD(Oneof, getFieldCount) { + Oneof *intern = UNBOX(Oneof, getThis()); + RETURN_LONG(upb_oneofdef_numfields(intern->oneofdef)); +} + +// ----------------------------------------------------------------------------- // DescriptorPool // ----------------------------------------------------------------------------- static zend_function_entry descriptor_pool_methods[] = { PHP_ME(DescriptorPool, getGeneratedPool, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) - PHP_ME(DescriptorPool, internalAddGeneratedFile, NULL, ZEND_ACC_PUBLIC) + PHP_ME(DescriptorPool, getDescriptorByClassName, NULL, ZEND_ACC_PUBLIC) + PHP_ME(DescriptorPool, getEnumDescriptorByClassName, NULL, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static zend_function_entry internal_descriptor_pool_methods[] = { + PHP_ME(InternalDescriptorPool, getGeneratedPool, NULL, + ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(InternalDescriptorPool, internalAddGeneratedFile, NULL, ZEND_ACC_PUBLIC) ZEND_FE_END }; DEFINE_CLASS(DescriptorPool, descriptor_pool, + "Google\\Protobuf\\DescriptorPool"); +DEFINE_CLASS(InternalDescriptorPool, internal_descriptor_pool, "Google\\Protobuf\\Internal\\DescriptorPool"); -zval* generated_pool_php; // wrapper of generated pool -DescriptorPool *generated_pool; // The actual generated pool +// wrapper of generated pool +#if PHP_MAJOR_VERSION < 7 +zval* generated_pool_php; +zval* internal_generated_pool_php; +#else +zend_object *generated_pool_php; +zend_object *internal_generated_pool_php; +#endif +InternalDescriptorPool *generated_pool; // The actual generated pool -static void init_generated_pool_once(TSRMLS_D) { - if (generated_pool_php == NULL) { +void init_generated_pool_once(TSRMLS_D) { + if (generated_pool == NULL) { +#if PHP_MAJOR_VERSION < 7 MAKE_STD_ZVAL(generated_pool_php); - Z_TYPE_P(generated_pool_php) = IS_OBJECT; - generated_pool = ALLOC(DescriptorPool); - descriptor_pool_init_c_instance(generated_pool TSRMLS_CC); - Z_OBJ_HANDLE_P(generated_pool_php) = zend_objects_store_put( - generated_pool, NULL, - (zend_objects_free_object_storage_t)descriptor_pool_free, - NULL TSRMLS_CC); - Z_OBJ_HT_P(generated_pool_php) = zend_get_std_object_handlers(); + MAKE_STD_ZVAL(internal_generated_pool_php); + ZVAL_OBJ(internal_generated_pool_php, + internal_descriptor_pool_type->create_object( + internal_descriptor_pool_type TSRMLS_CC)); + generated_pool = UNBOX(InternalDescriptorPool, internal_generated_pool_php); + ZVAL_OBJ(generated_pool_php, descriptor_pool_type->create_object( + descriptor_pool_type TSRMLS_CC)); +#else + internal_generated_pool_php = internal_descriptor_pool_type->create_object( + internal_descriptor_pool_type TSRMLS_CC); + generated_pool = (InternalDescriptorPool *)((char *)internal_generated_pool_php - + XtOffsetOf(InternalDescriptorPool, std)); + generated_pool_php = + descriptor_pool_type->create_object(descriptor_pool_type TSRMLS_CC); +#endif } } -static void descriptor_pool_init_c_instance(DescriptorPool *pool TSRMLS_DC) { - zend_object_std_init(&pool->std, descriptor_pool_type TSRMLS_CC); +static void internal_descriptor_pool_init_c_instance( + InternalDescriptorPool *pool TSRMLS_DC) { pool->symtab = upb_symtab_new(); ALLOC_HASHTABLE(pool->pending_list); zend_hash_init(pool->pending_list, 1, NULL, ZVAL_PTR_DTOR, 0); } -static void descriptor_pool_free_c(DescriptorPool *pool TSRMLS_DC) { +static void internal_descriptor_pool_free_c( + InternalDescriptorPool *pool TSRMLS_DC) { upb_symtab_free(pool->symtab); zend_hash_destroy(pool->pending_list); FREE_HASHTABLE(pool->pending_list); } +static void descriptor_pool_init_c_instance(DescriptorPool *pool TSRMLS_DC) { + assert(generated_pool != NULL); + pool->intern = generated_pool; +} + +static void descriptor_pool_free_c(DescriptorPool *pool TSRMLS_DC) { +} + static void validate_enumdef(const upb_enumdef *enumdef) { // Verify that an entry exists with integer value 0. (This is the default // value.) @@ -247,60 +700,212 @@ static void validate_msgdef(const upb_msgdef* msgdef) { PHP_METHOD(DescriptorPool, getGeneratedPool) { init_generated_pool_once(TSRMLS_C); +#if PHP_MAJOR_VERSION < 7 RETURN_ZVAL(generated_pool_php, 1, 0); +#else + ++GC_REFCOUNT(generated_pool_php); + RETURN_OBJ(generated_pool_php); +#endif } -static void convert_to_class_name_inplace(char *class_name, - const char* fullname, - const char* package_name) { - size_t i; - bool first_char = false; - size_t pkg_name_len = package_name == NULL ? 0 : strlen(package_name); +PHP_METHOD(InternalDescriptorPool, getGeneratedPool) { + init_generated_pool_once(TSRMLS_C); +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(internal_generated_pool_php, 1, 0); +#else + ++GC_REFCOUNT(internal_generated_pool_php); + RETURN_OBJ(internal_generated_pool_php); +#endif +} + +static size_t classname_len_max(const char *fullname, + const char *package, + const char *php_namespace, + const char *prefix) { + size_t fullname_len = strlen(fullname); + size_t package_len = 0; + size_t prefix_len = 0; + size_t namespace_len = 0; + size_t length = fullname_len; + int i, segment, classname_start = 0; + + if (package != NULL) { + package_len = strlen(package); + } + if (prefix != NULL) { + prefix_len = strlen(prefix); + } + if (php_namespace != NULL) { + namespace_len = strlen(php_namespace); + } - // In php, class name cannot be Empty. - if (strcmp("google.protobuf.Empty", fullname) == 0) { - fullname = "google.protobuf.GPBEmpty"; + // Process package + if (package_len > 0) { + segment = 1; + for (i = 0; i < package_len; i++) { + if (package[i] == '.') { + segment++; + } + } + // In case of reserved name in package. + length += 3 * segment; + + classname_start = package_len + 1; } - if (pkg_name_len == 0) { - strcpy(class_name, fullname); + // Process class name + segment = 1; + for (i = classname_start; i < fullname_len; i++) { + if (fullname[i] == '.') { + segment++; + } + } + if (prefix_len == 0) { + length += 3 * segment; } else { - class_name[0] = '.'; - strcpy(&class_name[1], fullname); - for (i = 0; i <= pkg_name_len + 1; i++) { - // PHP package uses camel case. - if (!first_char && class_name[i] != '.') { - first_char = true; - class_name[i] += 'A' - 'a'; + length += prefix_len * segment; + } + + // The additional 2, one is for preceding '.' and the other is for trailing 0. + return length + namespace_len + 2; +} + +static bool is_reserved(const char *segment, int length) { + bool result; + char* lower = ALLOC_N(char, length + 1); + memset(lower, 0, length + 1); + memcpy(lower, segment, length); + int i = 0; + while(lower[i]) { + lower[i] = (char)tolower(lower[i]); + i++; + } + lower[length] = 0; + result = is_reserved_name(lower); + FREE(lower); + return result; +} + +static char* fill_prefix(const char *segment, int length, + const char *prefix_given, + const char *package_name, char *classname) { + size_t i; + + if (prefix_given != NULL && strcmp(prefix_given, "") != 0) { + size_t prefix_len = strlen(prefix_given); + memcpy(classname, prefix_given, strlen(prefix_given)); + classname += prefix_len; + } else { + if (is_reserved(segment, length)) { + if (package_name != NULL && + strcmp("google.protobuf", package_name) == 0) { + memcpy(classname, "GPB", 3); + classname += 3; + } else { + memcpy(classname, "PB", 2); + classname += 2; } - // php packages are divided by '\'. - if (class_name[i] == '.') { - first_char = false; - class_name[i] = '\\'; + } + } + return classname; +} + +static char* fill_segment(const char *segment, int length, + char *classname, bool use_camel) { + memcpy(classname, segment, length); + if (use_camel && (segment[0] < 'A' || segment[0] > 'Z')) { + classname[0] += 'A' - 'a'; + } + return classname + length; +} + +static char* fill_namespace(const char *package, const char *namespace_given, + char *classname) { + if (namespace_given != NULL) { + size_t namespace_len = strlen(namespace_given); + memcpy(classname, namespace_given, namespace_len); + classname += namespace_len; + *classname = '\\'; + classname++; + } else if (package != NULL) { + int i = 0, j, offset = 0; + size_t package_len = strlen(package); + while (i < package_len) { + j = i; + while (j < package_len && package[j] != '.') { + j++; } + classname = fill_prefix(package + i, j - i, "", package, classname); + classname = fill_segment(package + i, j - i, classname, true); + classname[0] = '\\'; + classname++; + i = j + 1; } } + return classname; +} + +static char* fill_classname(const char *fullname, + const char *package, + const char *namespace_given, + const char *prefix, char *classname) { + int classname_start = 0; + if (package != NULL) { + size_t package_len = strlen(package); + classname_start = package_len == 0 ? 0 : package_len + 1; + } + size_t fullname_len = strlen(fullname); + classname = fill_prefix(fullname + classname_start, + fullname_len - classname_start, + prefix, package, classname); + + int i = classname_start, j; + while (i < fullname_len) { + j = i; + while (j < fullname_len && fullname[j] != '.') { + j++; + } + classname = fill_segment(fullname + i, j - i, classname, false); + if (j != fullname_len) { + *classname = '_'; + classname++; + } + i = j + 1; + } + return classname; +} + +static char* fill_qualified_classname(const char *fullname, + const char *package, + const char *namespace_given, + const char *prefix, char *classname) { + classname = fill_namespace(package, namespace_given, classname); + return fill_classname(fullname, package, namespace_given, prefix, classname); +} + +static void classname_no_prefix(const char *fullname, const char *package_name, + char *class_name) { + size_t i = 0, j; + bool first_char = true, is_reserved = false; + size_t pkg_name_len = package_name == NULL ? 0 : strlen(package_name); + size_t message_name_start = package_name == NULL ? 0 : pkg_name_len + 1; + size_t message_len = (strlen(fullname) - message_name_start); // Submessage is concatenated with its containing messages by '_'. - for (i = pkg_name_len; i < strlen(class_name); i++) { - if (class_name[i] == '.') { - class_name[i] = '_'; + for (j = message_name_start; j < message_name_start + message_len; j++) { + if (fullname[j] == '.') { + class_name[i++] = '_'; + } else { + class_name[i++] = fullname[j]; } } } -PHP_METHOD(DescriptorPool, internalAddGeneratedFile) { - char *data = NULL; - int data_len; +void internal_add_generated_file(const char *data, PHP_PROTO_SIZE data_len, + InternalDescriptorPool *pool TSRMLS_DC) { upb_filedef **files; size_t i; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_len) == - FAILURE) { - return; - } - - DescriptorPool *pool = UNBOX(DescriptorPool, getThis()); CHECK_UPB(files = upb_loaddescriptor(data, data_len, &pool, &status), "Parse binary descriptors to internal descriptors failed"); @@ -320,11 +925,7 @@ PHP_METHOD(DescriptorPool, internalAddGeneratedFile) { switch (upb_def_type(def)) { #define CASE_TYPE(def_type, def_type_lower, desc_type, desc_type_lower) \ case UPB_DEF_##def_type: { \ - desc_type *desc; \ - zval *desc_php; \ - CREATE(desc_type, desc, desc_type_lower##_init_c_instance); \ - BOX(desc_type, desc_php, desc, desc_type_lower##_free); \ - Z_DELREF_P(desc_php); \ + CREATE_HASHTABLE_VALUE(desc, desc_php, desc_type, desc_type_lower##_type); \ const upb_##def_type_lower *def_type_lower = \ upb_downcast_##def_type_lower(def); \ desc->def_type_lower = def_type_lower; \ @@ -339,20 +940,27 @@ PHP_METHOD(DescriptorPool, internalAddGeneratedFile) { * bytes allocated, one for '.', one for trailing 0, and 3 for 'GPB' if \ * given message is google.protobuf.Empty.*/ \ const char *fullname = upb_##def_type_lower##_fullname(def_type_lower); \ - char *klass_name = ecalloc(sizeof(char), 5 + strlen(fullname)); \ - convert_to_class_name_inplace(klass_name, fullname, \ - upb_filedef_package(files[0])); \ - zend_class_entry **pce; \ - if (zend_lookup_class(klass_name, strlen(klass_name), &pce TSRMLS_CC) == \ + const char *package = upb_filedef_package(files[0]); \ + const char *php_namespace = upb_filedef_phpnamespace(files[0]); \ + const char *prefix_given = upb_filedef_phpprefix(files[0]); \ + size_t classname_len = classname_len_max(fullname, package, \ + php_namespace, prefix_given); \ + char *classname = ecalloc(sizeof(char), classname_len); \ + fill_qualified_classname(fullname, package, php_namespace, \ + prefix_given, classname); \ + PHP_PROTO_CE_DECLARE pce; \ + if (php_proto_zend_lookup_class(classname, strlen(classname), &pce) == \ FAILURE) { \ zend_error(E_ERROR, "Generated message class %s hasn't been defined", \ - klass_name); \ + classname); \ return; \ } else { \ - desc->klass = *pce; \ + desc->klass = PHP_PROTO_CE_UNREF(pce); \ } \ add_ce_obj(desc->klass, desc_php); \ - efree(klass_name); \ + add_proto_obj(upb_##def_type_lower##_fullname(desc->def_type_lower), \ + desc_php); \ + efree(classname); \ break; \ } @@ -369,7 +977,7 @@ PHP_METHOD(DescriptorPool, internalAddGeneratedFile) { const upb_def *def = upb_filedef_def(files[0], i); if (upb_def_type(def) == UPB_DEF_MSG) { const upb_msgdef *msgdef = upb_downcast_msgdef(def); - zval *desc_php = get_def_obj(msgdef); + PHP_PROTO_HASHTABLE_VALUE desc_php = get_def_obj(msgdef); build_class_from_descriptor(desc_php TSRMLS_CC); } } @@ -378,110 +986,91 @@ PHP_METHOD(DescriptorPool, internalAddGeneratedFile) { upb_gfree(files); } -// ----------------------------------------------------------------------------- -// Descriptor -// ----------------------------------------------------------------------------- +PHP_METHOD(InternalDescriptorPool, internalAddGeneratedFile) { + char *data = NULL; + PHP_PROTO_SIZE data_len; + upb_filedef **files; + size_t i; -static zend_function_entry descriptor_methods[] = { - ZEND_FE_END -}; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_len) == + FAILURE) { + return; + } -DEFINE_CLASS(Descriptor, descriptor, "Google\\Protobuf\\Internal\\Descriptor"); + InternalDescriptorPool *pool = UNBOX(InternalDescriptorPool, getThis()); + internal_add_generated_file(data, data_len, pool TSRMLS_CC); +} -static void descriptor_free_c(Descriptor *self TSRMLS_DC) { - 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); +PHP_METHOD(DescriptorPool, getDescriptorByClassName) { + DescriptorPool *public_pool = UNBOX(DescriptorPool, getThis()); + InternalDescriptorPool *pool = public_pool->intern; + + char *classname = NULL; + PHP_PROTO_SIZE classname_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, + &classname_len) == FAILURE) { + return; } -} -static void descriptor_init_c_instance(Descriptor *desc TSRMLS_DC) { - zend_object_std_init(&desc->std, descriptor_type TSRMLS_CC); - desc->msgdef = NULL; - desc->layout = NULL; - desc->klass = NULL; - desc->fill_handlers = NULL; - desc->fill_method = NULL; - desc->json_fill_method = NULL; - desc->pb_serialize_handlers = NULL; - desc->json_serialize_handlers = NULL; - desc->json_serialize_handlers_preserve = NULL; -} + PHP_PROTO_CE_DECLARE pce; + if (php_proto_zend_lookup_class(classname, classname_len, &pce) == + FAILURE) { + RETURN_NULL(); + } -// ----------------------------------------------------------------------------- -// EnumDescriptor -// ----------------------------------------------------------------------------- + PHP_PROTO_HASHTABLE_VALUE desc = get_ce_obj(PHP_PROTO_CE_UNREF(pce)); + if (desc == NULL) { + RETURN_NULL(); + } -static zend_function_entry enum_descriptor_methods[] = { - ZEND_FE_END -}; + zend_class_entry* instance_ce = HASHTABLE_VALUE_CE(desc); -DEFINE_CLASS(EnumDescriptor, enum_descriptor, - "Google\\Protobuf\\Internal\\EnumDescriptor"); + if (!instanceof_function(instance_ce, descriptor_type TSRMLS_CC)) { + RETURN_NULL(); + } -static void enum_descriptor_free_c(EnumDescriptor *self TSRMLS_DC) { +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(desc, 1, 0); +#else + ++GC_REFCOUNT(desc); + RETURN_OBJ(desc); +#endif } -static void enum_descriptor_init_c_instance(EnumDescriptor *self TSRMLS_DC) { - zend_object_std_init(&self->std, enum_descriptor_type TSRMLS_CC); - self->enumdef = NULL; - self->klass = NULL; -} +PHP_METHOD(DescriptorPool, getEnumDescriptorByClassName) { + DescriptorPool *public_pool = UNBOX(DescriptorPool, getThis()); + InternalDescriptorPool *pool = public_pool->intern; -// ----------------------------------------------------------------------------- -// FieldDescriptor -// ----------------------------------------------------------------------------- + char *classname = NULL; + PHP_PROTO_SIZE classname_len; -upb_fieldtype_t to_fieldtype(upb_descriptortype_t type) { - switch (type) { -#define CASE(descriptor_type, type) \ - case UPB_DESCRIPTOR_TYPE_##descriptor_type: \ - return UPB_TYPE_##type; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, + &classname_len) == FAILURE) { + return; + } - CASE(FLOAT, FLOAT); - CASE(DOUBLE, DOUBLE); - CASE(BOOL, BOOL); - CASE(STRING, STRING); - CASE(BYTES, BYTES); - CASE(MESSAGE, MESSAGE); - CASE(GROUP, MESSAGE); - CASE(ENUM, ENUM); - CASE(INT32, INT32); - CASE(INT64, INT64); - CASE(UINT32, UINT32); - CASE(UINT64, UINT64); - CASE(SINT32, INT32); - CASE(SINT64, INT64); - CASE(FIXED32, UINT32); - CASE(FIXED64, UINT64); - CASE(SFIXED32, INT32); - CASE(SFIXED64, INT64); + PHP_PROTO_CE_DECLARE pce; + if (php_proto_zend_lookup_class(classname, classname_len, &pce) == + FAILURE) { + RETURN_NULL(); + } -#undef CONVERT + PHP_PROTO_HASHTABLE_VALUE desc = get_ce_obj(PHP_PROTO_CE_UNREF(pce)); + if (desc == NULL) { + RETURN_NULL(); + } + zend_class_entry* instance_ce = HASHTABLE_VALUE_CE(desc); + + if (!instanceof_function(instance_ce, enum_descriptor_type TSRMLS_CC)) { + RETURN_NULL(); } - zend_error(E_ERROR, "Unknown field type."); - return 0; +#if PHP_MAJOR_VERSION < 7 + RETURN_ZVAL(desc, 1, 0); +#else + ++GC_REFCOUNT(desc); + RETURN_OBJ(desc); +#endif } |