From d2583007f57da83579814086d5c811b72852d5aa Mon Sep 17 00:00:00 2001 From: thinkerou Date: Wed, 27 Jul 2016 09:48:45 +0800 Subject: [PATCH 1/7] add macro to php7_wrapper for reduce duplicate code --- src/php/ext/grpc/call.c | 24 +++++-------------- src/php/ext/grpc/call_credentials.c | 26 +++++---------------- src/php/ext/grpc/call_credentials.h | 4 ++-- src/php/ext/grpc/channel.c | 24 +++++-------------- src/php/ext/grpc/channel_credentials.c | 26 +++++---------------- src/php/ext/grpc/channel_credentials.h | 7 +++--- src/php/ext/grpc/php7_wrapper.h | 18 +++++++++++++++ src/php/ext/grpc/server.c | 32 +++++++------------------- src/php/ext/grpc/server_credentials.c | 26 +++++---------------- src/php/ext/grpc/server_credentials.h | 4 ++-- src/php/ext/grpc/timeval.c | 17 ++++---------- 11 files changed, 67 insertions(+), 141 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index fc832dacc23f0..add6841039f9e 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -59,17 +59,14 @@ zend_class_entry *grpc_ce_call; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_call */ -void free_wrapped_grpc_call(void *object TSRMLS_DC) { - wrapped_grpc_call *call = (wrapped_grpc_call *)object; - if (call->owned && call->wrapped != NULL) { - grpc_call_destroy(call->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call) + if (p->owned && p->wrapped != NULL) { + grpc_call_destroy(p->wrapped); } - zend_object_std_dtor(&call->std TSRMLS_CC); - efree(call); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_call to be associated with an object * of a class specified by class_type */ @@ -94,15 +91,6 @@ zend_object_value create_wrapped_grpc_call(zend_class_entry *class_type static zend_object_handlers call_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_call */ -static void free_wrapped_grpc_call(zend_object *object) { - wrapped_grpc_call *call = wrapped_grpc_call_from_obj(object); - if (call->owned && call->wrapped != NULL) { - grpc_call_destroy(call->wrapped); - } - zend_object_std_dtor(&call->std); -} - /* Initializes an instance of wrapped_grpc_call to be associated with an * object of a class specified by class_type */ zend_object *create_wrapped_grpc_call(zend_class_entry *class_type) { diff --git a/src/php/ext/grpc/call_credentials.c b/src/php/ext/grpc/call_credentials.c index 29762afb29773..aa589b0387f85 100644 --- a/src/php/ext/grpc/call_credentials.c +++ b/src/php/ext/grpc/call_credentials.c @@ -53,18 +53,14 @@ zend_class_entry *grpc_ce_call_credentials; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_call_credentials */ -void free_wrapped_grpc_call_credentials(void *object TSRMLS_DC) { - wrapped_grpc_call_credentials *creds = - (wrapped_grpc_call_credentials *)object; - if (creds->wrapped != NULL) { - grpc_call_credentials_release(creds->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call_credentials) + if (p->wrapped != NULL) { + grpc_call_credentials_release(p->wrapped); } - zend_object_std_dtor(&creds->std TSRMLS_CC); - efree(creds); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_call_credentials to be * associated with an object of a class specified by class_type */ @@ -90,16 +86,6 @@ zend_object_value create_wrapped_grpc_call_credentials( static zend_object_handlers call_credentials_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_call_credentials */ -static void free_wrapped_grpc_call_credentials(zend_object *object) { - wrapped_grpc_call_credentials *creds = - wrapped_grpc_call_creds_from_obj(object); - if (creds->wrapped != NULL) { - grpc_call_credentials_release(creds->wrapped); - } - zend_object_std_dtor(&creds->std); -} - /* Initializes an instance of wrapped_grpc_call_credentials to be * associated with an object of a class specified by class_type */ zend_object *create_wrapped_grpc_call_credentials(zend_class_entry diff --git a/src/php/ext/grpc/call_credentials.h b/src/php/ext/grpc/call_credentials.h index 822d077ccb0d1..8014b75c7032e 100755 --- a/src/php/ext/grpc/call_credentials.h +++ b/src/php/ext/grpc/call_credentials.h @@ -63,7 +63,7 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_call_credentials) #else static inline wrapped_grpc_call_credentials -*wrapped_grpc_call_creds_from_obj(zend_object *obj) { +*wrapped_grpc_call_credentials_from_obj(zend_object *obj) { return (wrapped_grpc_call_credentials*)((char*)(obj) - XtOffsetOf(wrapped_grpc_call_credentials, @@ -71,7 +71,7 @@ static inline wrapped_grpc_call_credentials } #define Z_WRAPPED_GRPC_CALL_CREDS_P(zv) \ - wrapped_grpc_call_creds_from_obj(Z_OBJ_P((zv))) + wrapped_grpc_call_credentials_from_obj(Z_OBJ_P((zv))) #endif /* PHP_MAJOR_VERSION */ diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c index 18ebcabc26f2a..9c4b265e947fc 100644 --- a/src/php/ext/grpc/channel.c +++ b/src/php/ext/grpc/channel.c @@ -57,17 +57,14 @@ zend_class_entry *grpc_ce_channel; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_channel */ -void free_wrapped_grpc_channel(void *object TSRMLS_DC) { - wrapped_grpc_channel *channel = (wrapped_grpc_channel *)object; - if (channel->wrapped != NULL) { - grpc_channel_destroy(channel->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_channel) + if (p->wrapped != NULL) { + grpc_channel_destroy(p->wrapped); } - zend_object_std_dtor(&channel->std TSRMLS_CC); - efree(channel); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_channel to be associated with an * object of a class specified by class_type */ @@ -90,15 +87,6 @@ zend_object_value create_wrapped_grpc_channel(zend_class_entry *class_type static zend_object_handlers channel_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_channel */ -static void free_wrapped_grpc_channel(zend_object *object) { - wrapped_grpc_channel *channel = wrapped_grpc_channel_from_obj(object); - if (channel->wrapped != NULL) { - grpc_channel_destroy(channel->wrapped); - } - zend_object_std_dtor(&channel->std); -} - /* Initializes an instance of wrapped_grpc_channel to be associated with an * object of a class specified by class_type */ zend_object *create_wrapped_grpc_channel(zend_class_entry *class_type) { diff --git a/src/php/ext/grpc/channel_credentials.c b/src/php/ext/grpc/channel_credentials.c index 1c2ea5ba829ee..938134cd9c025 100644 --- a/src/php/ext/grpc/channel_credentials.c +++ b/src/php/ext/grpc/channel_credentials.c @@ -63,18 +63,14 @@ static grpc_ssl_roots_override_result get_ssl_roots_override( return GRPC_SSL_ROOTS_OVERRIDE_OK; } -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_channel_credentials */ -void free_wrapped_grpc_channel_credentials(void *object TSRMLS_DC) { - wrapped_grpc_channel_credentials *creds = - (wrapped_grpc_channel_credentials *)object; - if (creds->wrapped != NULL) { - grpc_channel_credentials_release(creds->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_channel_credentials) + if (p->wrapped != NULL) { + grpc_channel_credentials_release(p->wrapped); } - zend_object_std_dtor(&creds->std TSRMLS_CC); - efree(creds); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_channel_credentials to be * associated with an object of a class specified by class_type */ @@ -100,16 +96,6 @@ zend_object_value create_wrapped_grpc_channel_credentials( static zend_object_handlers channel_credentials_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_channel_credentials */ -static void free_wrapped_grpc_channel_credentials(zend_object *object) { - wrapped_grpc_channel_credentials *creds = - wrapped_grpc_channel_creds_from_obj(object); - if (creds->wrapped != NULL) { - grpc_channel_credentials_release(creds->wrapped); - } - zend_object_std_dtor(&creds->std); -} - /* Initializes an instance of wrapped_grpc_channel_credentials to be * associated with an object of a class specified by class_type */ zend_object *create_wrapped_grpc_channel_credentials(zend_class_entry diff --git a/src/php/ext/grpc/channel_credentials.h b/src/php/ext/grpc/channel_credentials.h index 21225db5fb914..39dc85283d531 100755 --- a/src/php/ext/grpc/channel_credentials.h +++ b/src/php/ext/grpc/channel_credentials.h @@ -63,15 +63,14 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_channel_credentials) #else static inline wrapped_grpc_channel_credentials -*wrapped_grpc_channel_creds_from_obj(zend_object *obj) { +*wrapped_grpc_channel_credentials_from_obj(zend_object *obj) { return (wrapped_grpc_channel_credentials *) - ((char*)(obj) - - XtOffsetOf(wrapped_grpc_channel_credentials, std)); + ((char*)(obj) - XtOffsetOf(wrapped_grpc_channel_credentials, std)); } #define Z_WRAPPED_GRPC_CHANNEL_CREDS_P(zv) \ - wrapped_grpc_channel_creds_from_obj(Z_OBJ_P((zv))) + wrapped_grpc_channel_credentials_from_obj(Z_OBJ_P((zv))) #endif /* PHP_MAJOR_VERSION */ diff --git a/src/php/ext/grpc/php7_wrapper.h b/src/php/ext/grpc/php7_wrapper.h index 58dffc38dc0af..868432eb33c3b 100644 --- a/src/php/ext/grpc/php7_wrapper.h +++ b/src/php/ext/grpc/php7_wrapper.h @@ -56,6 +56,14 @@ #define PHP_GRPC_WRAP_OBJECT_END(name) \ } name; +#define PHP_GRPC_FREE_WRAPPED_FUNC_START(klass) \ + void free_##klass(void *object TSRMLS_DC) { \ + klass *p = (klass *)object; +#define PHP_GRPC_FREE_WRAPPED_FUNC_END() \ + zend_object_std_dtor(&p->std TSRMLS_CC); \ + efree(p); \ + } + #else #define php_grpc_int size_t @@ -79,6 +87,16 @@ zend_object std; \ } name; +#define WRAPPED_OBJECT_FROM_OBJ(klass, obj) \ + klass##_from_obj(obj); + +#define PHP_GRPC_FREE_WRAPPED_FUNC_START(klass) \ + static void free_##klass(zend_object *object) { \ + klass *p = WRAPPED_OBJECT_FROM_OBJ(klass, object) +#define PHP_GRPC_FREE_WRAPPED_FUNC_END() \ + zend_object_std_dtor(&p->std); \ + } + #endif /* PHP_MAJOR_VERSION */ #endif /* PHP7_WRAPPER_GRPC_H */ diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c index 577b7070892f1..dc815f4d7c50a 100644 --- a/src/php/ext/grpc/server.c +++ b/src/php/ext/grpc/server.c @@ -58,21 +58,18 @@ zend_class_entry *grpc_ce_server; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_server */ -void free_wrapped_grpc_server(void *object TSRMLS_DC) { - wrapped_grpc_server *server = (wrapped_grpc_server *)object; - if (server->wrapped != NULL) { - grpc_server_shutdown_and_notify(server->wrapped, completion_queue, NULL); - grpc_server_cancel_all_calls(server->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server) + if (p->wrapped != NULL) { + grpc_server_shutdown_and_notify(p->wrapped, completion_queue, NULL); + grpc_server_cancel_all_calls(p->wrapped); grpc_completion_queue_pluck(completion_queue, NULL, gpr_inf_future(GPR_CLOCK_REALTIME), NULL); - grpc_server_destroy(server->wrapped); + grpc_server_destroy(p->wrapped); } - zend_object_std_dtor(&server->std TSRMLS_CC); - efree(server); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_call to be associated with an object * of a class specified by class_type */ @@ -97,19 +94,6 @@ zend_object_value create_wrapped_grpc_server(zend_class_entry *class_type static zend_object_handlers server_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_server */ -static void free_wrapped_grpc_server(zend_object *object) { - wrapped_grpc_server *server = wrapped_grpc_server_from_obj(object); - if (server->wrapped != NULL) { - grpc_server_shutdown_and_notify(server->wrapped, completion_queue, NULL); - grpc_server_cancel_all_calls(server->wrapped); - grpc_completion_queue_pluck(completion_queue, NULL, - gpr_inf_future(GPR_CLOCK_REALTIME), NULL); - grpc_server_destroy(server->wrapped); - } - zend_object_std_dtor(&server->std); -} - /* Initializes an instance of wrapped_grpc_call to be associated with an object * of a class specified by class_type */ zend_object *create_wrapped_grpc_server(zend_class_entry *class_type) { diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c index 46416f5b47aaf..b1471d06e225a 100644 --- a/src/php/ext/grpc/server_credentials.c +++ b/src/php/ext/grpc/server_credentials.c @@ -51,18 +51,14 @@ zend_class_entry *grpc_ce_server_credentials; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instace of wrapped_grpc_server_credentials */ -void free_wrapped_grpc_server_credentials(void *object TSRMLS_DC) { - wrapped_grpc_server_credentials *creds = - (wrapped_grpc_server_credentials *)object; - if (creds->wrapped != NULL) { - grpc_server_credentials_release(creds->wrapped); +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server_credentials) + if (p->wrapped != NULL) { + grpc_server_credentials_release(p->wrapped); } - zend_object_std_dtor(&creds->std TSRMLS_CC); - efree(creds); -} +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instace of wrapped_grpc_server_credentials to be associated * with an object of a class specified by class_type */ @@ -88,16 +84,6 @@ zend_object_value create_wrapped_grpc_server_credentials( static zend_object_handlers server_credentials_ce_handlers; -/* Frees and destroys an instace of wrapped_grpc_server_credentials */ -static void free_wrapped_grpc_server_credentials(zend_object *object) { - wrapped_grpc_server_credentials *creds = - wrapped_grpc_server_creds_from_obj(object); - if (creds->wrapped != NULL) { - grpc_server_credentials_release(creds->wrapped); - } - zend_object_std_dtor(&creds->std); -} - /* Initializes an instace of wrapped_grpc_server_credentials to be associated * with an object of a class specified by class_type */ zend_object *create_wrapped_grpc_server_credentials(zend_class_entry diff --git a/src/php/ext/grpc/server_credentials.h b/src/php/ext/grpc/server_credentials.h index 2a90aa69a29bc..9551ec6c24f3a 100755 --- a/src/php/ext/grpc/server_credentials.h +++ b/src/php/ext/grpc/server_credentials.h @@ -63,13 +63,13 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_server_credentials) #else static inline wrapped_grpc_server_credentials -*wrapped_grpc_server_creds_from_obj(zend_object *obj) { +*wrapped_grpc_server_credentials_from_obj(zend_object *obj) { return (wrapped_grpc_server_credentials*) ((char*)(obj) - XtOffsetOf(wrapped_grpc_server_credentials, std)); } #define Z_WRAPPED_GRPC_SERVER_CREDS_P(zv) \ - wrapped_grpc_server_creds_from_obj(Z_OBJ_P((zv))) + wrapped_grpc_server_credentials_from_obj(Z_OBJ_P((zv))) #endif /* PHP_MAJOR_VERSION */ diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index 7d1ee2178aefe..e19bfe15656da 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -52,14 +52,11 @@ zend_class_entry *grpc_ce_timeval; -#if PHP_MAJOR_VERSION < 7 - /* Frees and destroys an instance of wrapped_grpc_call */ -void free_wrapped_grpc_timeval(void *object TSRMLS_DC) { - wrapped_grpc_timeval *timeval = (wrapped_grpc_timeval *)object; - zend_object_std_dtor(&timeval->std TSRMLS_CC); - efree(timeval); -} +PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_timeval) +PHP_GRPC_FREE_WRAPPED_FUNC_END() + +#if PHP_MAJOR_VERSION < 7 /* Initializes an instance of wrapped_grpc_timeval to be associated with an * object of a class specified by class_type */ @@ -82,12 +79,6 @@ zend_object_value create_wrapped_grpc_timeval(zend_class_entry *class_type static zend_object_handlers timeval_ce_handlers; -/* Frees and destroys an instance of wrapped_grpc_call */ -static void free_wrapped_grpc_timeval(zend_object *object) { - wrapped_grpc_timeval *timeval = wrapped_grpc_timeval_from_obj(object); - zend_object_std_dtor(&timeval->std); -} - /* Initializes an instance of wrapped_grpc_timeval to be associated with an * object of a class specified by class_type */ zend_object *create_wrapped_grpc_timeval(zend_class_entry *class_type) { From 4f8df873b00a2778535fe71a8cb360d3dfd677b6 Mon Sep 17 00:00:00 2001 From: thinkerou Date: Wed, 27 Jul 2016 18:45:37 +0800 Subject: [PATCH 2/7] add php_grpc_zend_object macro and rename klass --- src/php/ext/grpc/call.c | 35 ++++++++++---------------- src/php/ext/grpc/call_credentials.c | 34 +++++++++---------------- src/php/ext/grpc/channel.c | 33 ++++++++++-------------- src/php/ext/grpc/channel_credentials.c | 34 +++++++++---------------- src/php/ext/grpc/php7_wrapper.h | 18 +++++++------ src/php/ext/grpc/server.c | 35 ++++++++++---------------- src/php/ext/grpc/server_credentials.c | 34 +++++++++---------------- src/php/ext/grpc/timeval.c | 33 ++++++++++-------------- 8 files changed, 98 insertions(+), 158 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index add6841039f9e..706c7d8c3ae90 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -58,6 +58,9 @@ #include "byte_buffer.h" zend_class_entry *grpc_ce_call; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers call_ce_handlers; +#endif /* Frees and destroys an instance of wrapped_grpc_call */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call) @@ -66,44 +69,32 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_call to be associated with an object * of a class specified by class_type */ -zend_object_value create_wrapped_grpc_call(zend_class_entry *class_type - TSRMLS_DC) { - zend_object_value retval; +php_grpc_zend_object create_wrapped_grpc_call(zend_class_entry *class_type + TSRMLS_DC) { wrapped_grpc_call *intern; - +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_call *)emalloc(sizeof(wrapped_grpc_call)); memset(intern, 0, sizeof(wrapped_grpc_call)); - +#else + intern = ecalloc(1, sizeof(wrapped_grpc_call) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_call, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers call_ce_handlers; - -/* Initializes an instance of wrapped_grpc_call to be associated with an - * object of a class specified by class_type */ -zend_object *create_wrapped_grpc_call(zend_class_entry *class_type) { - wrapped_grpc_call *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_call) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &call_ce_handlers; return &intern->std; -} - #endif +} /* Creates and returns a PHP array object with the data in a * grpc_metadata_array. Returns NULL on failure */ diff --git a/src/php/ext/grpc/call_credentials.c b/src/php/ext/grpc/call_credentials.c index aa589b0387f85..0c55745524eb2 100644 --- a/src/php/ext/grpc/call_credentials.c +++ b/src/php/ext/grpc/call_credentials.c @@ -52,6 +52,9 @@ #include zend_class_entry *grpc_ce_call_credentials; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers call_credentials_ce_handlers; +#endif /* Frees and destroys an instance of wrapped_grpc_call_credentials */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call_credentials) @@ -60,46 +63,33 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_call_credentials) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_call_credentials to be * associated with an object of a class specified by class_type */ -zend_object_value create_wrapped_grpc_call_credentials( +php_grpc_zend_object create_wrapped_grpc_call_credentials( zend_class_entry *class_type TSRMLS_DC) { - zend_object_value retval; wrapped_grpc_call_credentials *intern; - +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_call_credentials *)emalloc( sizeof(wrapped_grpc_call_credentials)); memset(intern, 0, sizeof(wrapped_grpc_call_credentials)); - +#else + intern = ecalloc(1, sizeof(wrapped_grpc_call_credentials) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_call_credentials, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers call_credentials_ce_handlers; - -/* Initializes an instance of wrapped_grpc_call_credentials to be - * associated with an object of a class specified by class_type */ -zend_object *create_wrapped_grpc_call_credentials(zend_class_entry - *class_type) { - wrapped_grpc_call_credentials *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_call_credentials) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &call_credentials_ce_handlers; return &intern->std; -} - #endif +} zval *grpc_php_wrap_call_credentials(grpc_call_credentials *wrapped TSRMLS_DC) { diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c index 9c4b265e947fc..69264842f0c32 100644 --- a/src/php/ext/grpc/channel.c +++ b/src/php/ext/grpc/channel.c @@ -56,6 +56,9 @@ #include "timeval.h" zend_class_entry *grpc_ce_channel; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers channel_ce_handlers; +#endif /* Frees and destroys an instance of wrapped_grpc_channel */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_channel) @@ -64,42 +67,32 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_channel) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_channel to be associated with an * object of a class specified by class_type */ -zend_object_value create_wrapped_grpc_channel(zend_class_entry *class_type - TSRMLS_DC) { - zend_object_value retval; +php_grpc_zend_object create_wrapped_grpc_channel(zend_class_entry *class_type + TSRMLS_DC) { wrapped_grpc_channel *intern; +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_channel *)emalloc(sizeof(wrapped_grpc_channel)); memset(intern, 0, sizeof(wrapped_grpc_channel)); +#else + intern = ecalloc(1, sizeof(wrapped_grpc_channel) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_channel, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers channel_ce_handlers; - -/* Initializes an instance of wrapped_grpc_channel to be associated with an - * object of a class specified by class_type */ -zend_object *create_wrapped_grpc_channel(zend_class_entry *class_type) { - wrapped_grpc_channel *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_channel) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &channel_ce_handlers; return &intern->std; -} - #endif +} void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args TSRMLS_DC) { diff --git a/src/php/ext/grpc/channel_credentials.c b/src/php/ext/grpc/channel_credentials.c index 938134cd9c025..cef435cc6ea0f 100644 --- a/src/php/ext/grpc/channel_credentials.c +++ b/src/php/ext/grpc/channel_credentials.c @@ -52,6 +52,9 @@ #include zend_class_entry *grpc_ce_channel_credentials; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers channel_credentials_ce_handlers; +#endif static char *default_pem_root_certs = NULL; static grpc_ssl_roots_override_result get_ssl_roots_override( @@ -70,46 +73,33 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_channel_credentials) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_channel_credentials to be * associated with an object of a class specified by class_type */ -zend_object_value create_wrapped_grpc_channel_credentials( +php_grpc_zend_object create_wrapped_grpc_channel_credentials( zend_class_entry *class_type TSRMLS_DC) { - zend_object_value retval; wrapped_grpc_channel_credentials *intern; - +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_channel_credentials *)emalloc( sizeof(wrapped_grpc_channel_credentials)); memset(intern, 0, sizeof(wrapped_grpc_channel_credentials)); - +#else + intern = ecalloc(1, sizeof(wrapped_grpc_channel_credentials) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_channel_credentials, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers channel_credentials_ce_handlers; - -/* Initializes an instance of wrapped_grpc_channel_credentials to be - * associated with an object of a class specified by class_type */ -zend_object *create_wrapped_grpc_channel_credentials(zend_class_entry - *class_type) { - wrapped_grpc_channel_credentials *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_channel_credentials) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &channel_credentials_ce_handlers; return &intern->std; -} - #endif +} zval *grpc_php_wrap_channel_credentials(grpc_channel_credentials *wrapped TSRMLS_DC) { diff --git a/src/php/ext/grpc/php7_wrapper.h b/src/php/ext/grpc/php7_wrapper.h index 868432eb33c3b..7d7470f8a9181 100644 --- a/src/php/ext/grpc/php7_wrapper.h +++ b/src/php/ext/grpc/php7_wrapper.h @@ -40,6 +40,7 @@ #define php_grpc_int int #define php_grpc_long long #define php_grpc_ulong ulong +#define php_grpc_zend_object zend_object_value #define php_grpc_add_property_string(arg, name, context, b) \ add_property_string(arg, name, context, b) #define php_grpc_add_property_stringl(res, name, str, len, b) \ @@ -56,9 +57,9 @@ #define PHP_GRPC_WRAP_OBJECT_END(name) \ } name; -#define PHP_GRPC_FREE_WRAPPED_FUNC_START(klass) \ - void free_##klass(void *object TSRMLS_DC) { \ - klass *p = (klass *)object; +#define PHP_GRPC_FREE_WRAPPED_FUNC_START(class_object) \ + void free_##class_object(void *object TSRMLS_DC) { \ + class_object *p = (class_object *)object; #define PHP_GRPC_FREE_WRAPPED_FUNC_END() \ zend_object_std_dtor(&p->std TSRMLS_CC); \ efree(p); \ @@ -69,6 +70,7 @@ #define php_grpc_int size_t #define php_grpc_long zend_long #define php_grpc_ulong zend_ulong +#define php_grpc_zend_object zend_object* #define php_grpc_add_property_string(arg, name, context, b) \ add_property_string(arg, name, context) #define php_grpc_add_property_stringl(res, name, str, len, b) \ @@ -87,12 +89,12 @@ zend_object std; \ } name; -#define WRAPPED_OBJECT_FROM_OBJ(klass, obj) \ - klass##_from_obj(obj); +#define WRAPPED_OBJECT_FROM_OBJ(class_object, obj) \ + class_object##_from_obj(obj); -#define PHP_GRPC_FREE_WRAPPED_FUNC_START(klass) \ - static void free_##klass(zend_object *object) { \ - klass *p = WRAPPED_OBJECT_FROM_OBJ(klass, object) +#define PHP_GRPC_FREE_WRAPPED_FUNC_START(class_object) \ + static void free_##class_object(zend_object *object) { \ + class_object *p = WRAPPED_OBJECT_FROM_OBJ(class_object, object) #define PHP_GRPC_FREE_WRAPPED_FUNC_END() \ zend_object_std_dtor(&p->std); \ } diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c index dc815f4d7c50a..d8ebd4472d69e 100644 --- a/src/php/ext/grpc/server.c +++ b/src/php/ext/grpc/server.c @@ -57,6 +57,9 @@ #include "timeval.h" zend_class_entry *grpc_ce_server; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers server_ce_handlers; +#endif /* Frees and destroys an instance of wrapped_grpc_server */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server) @@ -69,44 +72,32 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_call to be associated with an object * of a class specified by class_type */ -zend_object_value create_wrapped_grpc_server(zend_class_entry *class_type - TSRMLS_DC) { - zend_object_value retval; +php_grpc_zend_object create_wrapped_grpc_server(zend_class_entry *class_type + TSRMLS_DC) { wrapped_grpc_server *intern; - +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_server *)emalloc(sizeof(wrapped_grpc_server)); memset(intern, 0, sizeof(wrapped_grpc_server)); - +#else + intern = ecalloc(1, sizeof(wrapped_grpc_server) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_server, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers server_ce_handlers; - -/* Initializes an instance of wrapped_grpc_call to be associated with an object - * of a class specified by class_type */ -zend_object *create_wrapped_grpc_server(zend_class_entry *class_type) { - wrapped_grpc_server *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_server) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &server_ce_handlers; return &intern->std; -} - #endif +} /** * Constructs a new instance of the Server class diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c index b1471d06e225a..921436a1bba41 100644 --- a/src/php/ext/grpc/server_credentials.c +++ b/src/php/ext/grpc/server_credentials.c @@ -50,6 +50,9 @@ #include zend_class_entry *grpc_ce_server_credentials; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers server_credentials_ce_handlers; +#endif /* Frees and destroys an instace of wrapped_grpc_server_credentials */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server_credentials) @@ -58,46 +61,33 @@ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_server_credentials) } PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instace of wrapped_grpc_server_credentials to be associated * with an object of a class specified by class_type */ -zend_object_value create_wrapped_grpc_server_credentials( +php_grpc_zend_object create_wrapped_grpc_server_credentials( zend_class_entry *class_type TSRMLS_DC) { - zend_object_value retval; wrapped_grpc_server_credentials *intern; - +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_server_credentials *)emalloc( sizeof(wrapped_grpc_server_credentials)); memset(intern, 0, sizeof(wrapped_grpc_server_credentials)); - +#else + intern = ecalloc(1, sizeof(wrapped_grpc_server_credentials) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_server_credentials, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers server_credentials_ce_handlers; - -/* Initializes an instace of wrapped_grpc_server_credentials to be associated - * with an object of a class specified by class_type */ -zend_object *create_wrapped_grpc_server_credentials(zend_class_entry - *class_type) { - wrapped_grpc_server_credentials *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_server_credentials) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &server_credentials_ce_handlers; return &intern->std; -} - #endif +} zval *grpc_php_wrap_server_credentials(grpc_server_credentials *wrapped TSRMLS_DC) { diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index e19bfe15656da..33d11f83ccee8 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -51,47 +51,40 @@ #include zend_class_entry *grpc_ce_timeval; +#if PHP_MAJOR_VERSION >= 7 +static zend_object_handlers timeval_ce_handlers; +#endif /* Frees and destroys an instance of wrapped_grpc_call */ PHP_GRPC_FREE_WRAPPED_FUNC_START(wrapped_grpc_timeval) PHP_GRPC_FREE_WRAPPED_FUNC_END() -#if PHP_MAJOR_VERSION < 7 - /* Initializes an instance of wrapped_grpc_timeval to be associated with an * object of a class specified by class_type */ -zend_object_value create_wrapped_grpc_timeval(zend_class_entry *class_type - TSRMLS_DC) { - zend_object_value retval; +php_grpc_zend_object create_wrapped_grpc_timeval(zend_class_entry *class_type + TSRMLS_DC) { wrapped_grpc_timeval *intern; +#if PHP_MAJOR_VERSION < 7 + zend_object_value retval; intern = (wrapped_grpc_timeval *)emalloc(sizeof(wrapped_grpc_timeval)); memset(intern, 0, sizeof(wrapped_grpc_timeval)); +#else + intern = ecalloc(1, sizeof(wrapped_grpc_timeval) + + zend_object_properties_size(class_type)); +#endif zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); +#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_timeval, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); return retval; -} - #else - -static zend_object_handlers timeval_ce_handlers; - -/* Initializes an instance of wrapped_grpc_timeval to be associated with an - * object of a class specified by class_type */ -zend_object *create_wrapped_grpc_timeval(zend_class_entry *class_type) { - wrapped_grpc_timeval *intern; - intern = ecalloc(1, sizeof(wrapped_grpc_timeval) + - zend_object_properties_size(class_type)); - zend_object_std_init(&intern->std, class_type); - object_properties_init(&intern->std, class_type); intern->std.handlers = &timeval_ce_handlers; return &intern->std; -} - #endif +} zval *grpc_php_wrap_timeval(gpr_timespec wrapped TSRMLS_DC) { zval *timeval_object; From eb9c54574662b5f9cc6812ef67d43fe654a3052e Mon Sep 17 00:00:00 2001 From: thinkerou Date: Thu, 28 Jul 2016 02:35:26 +0800 Subject: [PATCH 3/7] add some macro to reduce duplicate code --- src/php/ext/grpc/call.c | 382 +++++-------------------- src/php/ext/grpc/call_credentials.c | 11 +- src/php/ext/grpc/channel.c | 100 ++----- src/php/ext/grpc/channel_credentials.c | 11 +- src/php/ext/grpc/php7_wrapper.h | 93 ++++++ src/php/ext/grpc/server.c | 10 +- src/php/ext/grpc/server_credentials.c | 11 +- src/php/ext/grpc/timeval.c | 10 +- 8 files changed, 184 insertions(+), 444 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index 706c7d8c3ae90..46591d8738594 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -73,15 +73,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_call(zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_call *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_call *)emalloc(sizeof(wrapped_grpc_call)); - memset(intern, 0, sizeof(wrapped_grpc_call)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_call) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_call); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 @@ -111,11 +103,7 @@ zval *grpc_parse_metadata_array(grpc_metadata_array char *str_key; char *str_val; size_t key_len; -#if PHP_MAJOR_VERSION < 7 - zval **data = NULL; -#else - zval *data; -#endif + zval *data = NULL; array_hash = Z_ARRVAL_P(array); grpc_metadata *elem; @@ -126,14 +114,9 @@ zval *grpc_parse_metadata_array(grpc_metadata_array memcpy(str_key, elem->key, key_len); str_val = ecalloc(elem->value_length + 1, sizeof(char)); memcpy(str_val, elem->value, elem->value_length); -#if PHP_MAJOR_VERSION < 7 - if (zend_hash_find(array_hash, str_key, key_len, (void **)data) == + if (php_grpc_zend_hash_find(array_hash, str_key, key_len, (void **)&data) == SUCCESS) { - if (Z_TYPE_P(*data) != IS_ARRAY) { -#else - if ((data = zend_hash_str_find(array_hash, str_key, key_len)) != NULL) { if (Z_TYPE_P(data) != IS_ARRAY) { -#endif zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Metadata hash somehow contains wrong types.", 1 TSRMLS_CC); @@ -141,13 +124,8 @@ zval *grpc_parse_metadata_array(grpc_metadata_array efree(str_val); return NULL; } -#if PHP_MAJOR_VERSION < 7 - php_grpc_add_next_index_stringl(*data, str_val, elem->value_length, - false); -#else php_grpc_add_next_index_stringl(data, str_val, elem->value_length, false); -#endif } else { PHP_GRPC_MAKE_STD_ZVAL(inner_array); array_init(inner_array); @@ -164,96 +142,48 @@ zval *grpc_parse_metadata_array(grpc_metadata_array bool create_metadata_array(zval *array, grpc_metadata_array *metadata) { HashTable *array_hash; HashTable *inner_array_hash; -#if PHP_MAJOR_VERSION < 7 - zval **inner_array; - zval **value; - HashPosition array_pointer; - HashPosition inner_array_pointer; - char *key; - uint key_len; - ulong index; -#else - zval *inner_array; zval *value; - zend_string *key; -#endif + zval *inner_array; if (Z_TYPE_P(array) != IS_ARRAY) { return false; } grpc_metadata_array_init(metadata); array_hash = Z_ARRVAL_P(array); -#if PHP_MAJOR_VERSION < 7 - for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); - zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, - &array_pointer) == SUCCESS; - zend_hash_move_forward_ex(array_hash, &array_pointer)) { - if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, - &array_pointer) != HASH_KEY_IS_STRING) { - return false; - } - if (Z_TYPE_P(*inner_array) != IS_ARRAY) { - return false; - } - inner_array_hash = Z_ARRVAL_P(*inner_array); - metadata->capacity += zend_hash_num_elements(inner_array_hash); - } -#else - ZEND_HASH_FOREACH_STR_KEY_VAL(array_hash, key, inner_array) { - if (key == NULL) { + + char *key = NULL; + int key_type; + PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key, key_type, + inner_array) + if (key_type != HASH_KEY_IS_STRING) { return false; } if (Z_TYPE_P(inner_array) != IS_ARRAY) { return false; } - inner_array_hash = HASH_OF(inner_array); + inner_array_hash = Z_ARRVAL_P(inner_array); metadata->capacity += zend_hash_num_elements(inner_array_hash); - } ZEND_HASH_FOREACH_END(); -#endif + PHP_GRPC_HASH_FOREACH_END() metadata->metadata = gpr_malloc(metadata->capacity * sizeof(grpc_metadata)); -#if PHP_MAJOR_VERSION < 7 - for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); - zend_hash_get_current_data_ex(array_hash, (void**)&inner_array, - &array_pointer) == SUCCESS; - zend_hash_move_forward_ex(array_hash, &array_pointer)) { - if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, - &array_pointer) != HASH_KEY_IS_STRING) { + char *key1 = NULL; + int key_type1; + PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key1, key_type1, + inner_array) + if (key_type1 != HASH_KEY_IS_STRING) { return false; } - inner_array_hash = Z_ARRVAL_P(*inner_array); - for (zend_hash_internal_pointer_reset_ex(inner_array_hash, - &inner_array_pointer); - zend_hash_get_current_data_ex(inner_array_hash, (void**)&value, - &inner_array_pointer) == SUCCESS; - zend_hash_move_forward_ex(inner_array_hash, &inner_array_pointer)) { - if (Z_TYPE_P(*value) != IS_STRING) { - return false; - } - metadata->metadata[metadata->count].key = key; - metadata->metadata[metadata->count].value = Z_STRVAL_P(*value); - metadata->metadata[metadata->count].value_length = Z_STRLEN_P(*value); - metadata->count += 1; - } - } -#else - ZEND_HASH_FOREACH_STR_KEY_VAL(array_hash, key, inner_array) { - if (key == NULL) { - return false; - } - inner_array_hash = HASH_OF(inner_array); - - ZEND_HASH_FOREACH_VAL(inner_array_hash, value) { + inner_array_hash = Z_ARRVAL_P(inner_array); + PHP_GRPC_HASH_FOREACH_VAL_START(inner_array_hash, value) if (Z_TYPE_P(value) != IS_STRING) { return false; } - metadata->metadata[metadata->count].key = ZSTR_VAL(key); + metadata->metadata[metadata->count].key = key1; metadata->metadata[metadata->count].value = Z_STRVAL_P(value); metadata->metadata[metadata->count].value_length = Z_STRLEN_P(value); metadata->count += 1; - } ZEND_HASH_FOREACH_END(); - } ZEND_HASH_FOREACH_END(); -#endif + PHP_GRPC_HASH_FOREACH_END() + PHP_GRPC_HASH_FOREACH_END() return true; } @@ -321,23 +251,13 @@ PHP_METHOD(Call, startBatch) { PHP_GRPC_MAKE_STD_ZVAL(result); object_init(result); php_grpc_ulong index; -#if PHP_MAJOR_VERSION < 7 - zval **value; - zval **inner_value; - HashPosition array_pointer; - zval **message_value; - zval **message_flags; - char *key; - uint key_len; zval *recv_status; -#else + PHP_GRPC_MAKE_STD_ZVAL(recv_status); + object_init(recv_status); zval *value; zval *inner_value; zval *message_value; zval *message_flags; - zend_string *key; - zval recv_status; -#endif wrapped_grpc_call *call = Z_WRAPPED_GRPC_CALL_P(getThis()); grpc_op ops[8]; @@ -371,26 +291,23 @@ PHP_METHOD(Call, startBatch) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) { zend_throw_exception(spl_ce_InvalidArgumentException, - "start_batch expects an array", 1 TSRMLS_CC); - goto cleanup; + "start_batch expects an array", 1 TSRMLS_CC); goto cleanup; } -#if PHP_MAJOR_VERSION < 7 - array_hash = Z_ARRVAL_P(array); - for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); - zend_hash_get_current_data_ex(array_hash, (void**)&value, - &array_pointer) == SUCCESS; - zend_hash_move_forward_ex(array_hash, &array_pointer)) { - if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, - &array_pointer) != HASH_KEY_IS_LONG) { + + char *key = NULL; + int key_type; + PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(array_hash, key, key_type, index, + value) + if (key_type != HASH_KEY_IS_LONG) { zend_throw_exception(spl_ce_InvalidArgumentException, "batch keys must be integers", 1 TSRMLS_CC); goto cleanup; } switch(index) { case GRPC_OP_SEND_INITIAL_METADATA: - if (!create_metadata_array(*value, &metadata)) { + if (!create_metadata_array(value, &metadata)) { zend_throw_exception(spl_ce_InvalidArgumentException, "Bad metadata value given", 1 TSRMLS_CC); goto cleanup; @@ -401,41 +318,41 @@ PHP_METHOD(Call, startBatch) { metadata.metadata; break; case GRPC_OP_SEND_MESSAGE: - if (Z_TYPE_PP(value) != IS_ARRAY) { + if (Z_TYPE_P(value) != IS_ARRAY) { zend_throw_exception(spl_ce_InvalidArgumentException, "Expected an array for send message", 1 TSRMLS_CC); goto cleanup; } - message_hash = Z_ARRVAL_PP(value); - if (zend_hash_find(message_hash, "flags", sizeof("flags"), + message_hash = Z_ARRVAL_P(value); + if (php_grpc_zend_hash_find(message_hash, "flags", sizeof("flags"), (void **)&message_flags) == SUCCESS) { - if (Z_TYPE_PP(message_flags) != IS_LONG) { + if (Z_TYPE_P(message_flags) != IS_LONG) { zend_throw_exception(spl_ce_InvalidArgumentException, "Expected an int for message flags", 1 TSRMLS_CC); } - ops[op_num].flags = Z_LVAL_PP(message_flags) & GRPC_WRITE_USED_MASK; + ops[op_num].flags = Z_LVAL_P(message_flags) & GRPC_WRITE_USED_MASK; } - if (zend_hash_find(message_hash, "message", sizeof("message"), + if (php_grpc_zend_hash_find(message_hash, "message", sizeof("message"), (void **)&message_value) != SUCCESS || - Z_TYPE_PP(message_value) != IS_STRING) { + Z_TYPE_P(message_value) != IS_STRING) { zend_throw_exception(spl_ce_InvalidArgumentException, "Expected a string for send message", 1 TSRMLS_CC); goto cleanup; } ops[op_num].data.send_message = - string_to_byte_buffer(Z_STRVAL_PP(message_value), - Z_STRLEN_PP(message_value)); + string_to_byte_buffer(Z_STRVAL_P(message_value), + Z_STRLEN_P(message_value)); break; case GRPC_OP_SEND_CLOSE_FROM_CLIENT: break; case GRPC_OP_SEND_STATUS_FROM_SERVER: - status_hash = Z_ARRVAL_PP(value); - if (zend_hash_find(status_hash, "metadata", sizeof("metadata"), + status_hash = Z_ARRVAL_P(value); + if (php_grpc_zend_hash_find(status_hash, "metadata", sizeof("metadata"), (void **)&inner_value) == SUCCESS) { - if (!create_metadata_array(*inner_value, &trailing_metadata)) { + if (!create_metadata_array(inner_value, &trailing_metadata)) { zend_throw_exception(spl_ce_InvalidArgumentException, "Bad trailing metadata value given", 1 TSRMLS_CC); @@ -446,32 +363,32 @@ PHP_METHOD(Call, startBatch) { ops[op_num].data.send_status_from_server.trailing_metadata_count = trailing_metadata.count; } - if (zend_hash_find(status_hash, "code", sizeof("code"), + if (php_grpc_zend_hash_find(status_hash, "code", sizeof("code"), (void**)&inner_value) == SUCCESS) { - if (Z_TYPE_PP(inner_value) != IS_LONG) { + if (Z_TYPE_P(inner_value) != IS_LONG) { zend_throw_exception(spl_ce_InvalidArgumentException, "Status code must be an integer", 1 TSRMLS_CC); goto cleanup; } ops[op_num].data.send_status_from_server.status = - Z_LVAL_PP(inner_value); + Z_LVAL_P(inner_value); } else { zend_throw_exception(spl_ce_InvalidArgumentException, "Integer status code is required", 1 TSRMLS_CC); goto cleanup; } - if (zend_hash_find(status_hash, "details", sizeof("details"), + if (php_grpc_zend_hash_find(status_hash, "details", sizeof("details"), (void**)&inner_value) == SUCCESS) { - if (Z_TYPE_PP(inner_value) != IS_STRING) { + if (Z_TYPE_P(inner_value) != IS_STRING) { zend_throw_exception(spl_ce_InvalidArgumentException, "Status details must be a string", 1 TSRMLS_CC); goto cleanup; } ops[op_num].data.send_status_from_server.status_details = - Z_STRVAL_PP(inner_value); + Z_STRVAL_P(inner_value); } else { zend_throw_exception(spl_ce_InvalidArgumentException, "String status details is required", @@ -506,131 +423,7 @@ PHP_METHOD(Call, startBatch) { ops[op_num].flags = 0; ops[op_num].reserved = NULL; op_num++; - } - -#else - - array_hash = HASH_OF(array); - ZEND_HASH_FOREACH_KEY_VAL(array_hash, index, key, value) { - if (key) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "batch keys must be integers", 1); - goto cleanup; - } - - switch(index) { - case GRPC_OP_SEND_INITIAL_METADATA: - if (!create_metadata_array(value, &metadata)) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Bad metadata value given", 1); - goto cleanup; - } - ops[op_num].data.send_initial_metadata.count = metadata.count; - ops[op_num].data.send_initial_metadata.metadata = metadata.metadata; - break; - case GRPC_OP_SEND_MESSAGE: - if (Z_TYPE_P(value) != IS_ARRAY) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Expected an array for send message", 1); - goto cleanup; - } - message_hash = HASH_OF(value); - if ((message_flags = - zend_hash_str_find(message_hash, "flags", - sizeof("flags") - 1)) != NULL) { - if (Z_TYPE_P(message_flags) != IS_LONG) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Expected an int for message flags", 1); - } - ops[op_num].flags = Z_LVAL_P(message_flags) & GRPC_WRITE_USED_MASK; - } - if ((message_value = zend_hash_str_find(message_hash, "message", - sizeof("message") - 1)) - == NULL || Z_TYPE_P(message_value) != IS_STRING) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Expected a string for send message", 1); - goto cleanup; - } - ops[op_num].data.send_message = - string_to_byte_buffer(Z_STRVAL_P(message_value), - Z_STRLEN_P(message_value)); - break; - case GRPC_OP_SEND_CLOSE_FROM_CLIENT: - break; - case GRPC_OP_SEND_STATUS_FROM_SERVER: - status_hash = HASH_OF(value); - if ((inner_value = zend_hash_str_find(status_hash, "metadata", - sizeof("metadata") - 1)) - != NULL) { - if (!create_metadata_array(inner_value, &trailing_metadata)) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Bad trailing metadata value given", 1); - goto cleanup; - } - ops[op_num].data.send_status_from_server.trailing_metadata = - trailing_metadata.metadata; - ops[op_num].data.send_status_from_server.trailing_metadata_count = - trailing_metadata.count; - } - if ((inner_value = zend_hash_str_find(status_hash, "code", - sizeof("code") - 1)) != NULL) { - if (Z_TYPE_P(inner_value) != IS_LONG) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Status code must be an integer", 1); - goto cleanup; - } - ops[op_num].data.send_status_from_server.status = - Z_LVAL_P(inner_value); - } else { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Integer status code is required", 1); - goto cleanup; - } - if ((inner_value = zend_hash_str_find(status_hash, "details", - sizeof("details") - 1)) != NULL) { - if (Z_TYPE_P(inner_value) != IS_STRING) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "Status details must be a string", 1); - goto cleanup; - } - ops[op_num].data.send_status_from_server.status_details = - Z_STRVAL_P(inner_value); - } else { - zend_throw_exception(spl_ce_InvalidArgumentException, - "String status details is required", 1); - goto cleanup; - } - break; - case GRPC_OP_RECV_INITIAL_METADATA: - ops[op_num].data.recv_initial_metadata = &recv_metadata; - break; - case GRPC_OP_RECV_MESSAGE: - ops[op_num].data.recv_message = &message; - break; - case GRPC_OP_RECV_STATUS_ON_CLIENT: - ops[op_num].data.recv_status_on_client.trailing_metadata = - &recv_trailing_metadata; - ops[op_num].data.recv_status_on_client.status = &status; - ops[op_num].data.recv_status_on_client.status_details = - &status_details; - ops[op_num].data.recv_status_on_client.status_details_capacity = - &status_details_capacity; - break; - case GRPC_OP_RECV_CLOSE_ON_SERVER: - ops[op_num].data.recv_close_on_server.cancelled = &cancelled; - break; - default: - zend_throw_exception(spl_ce_InvalidArgumentException, - "Unrecognized key in batch", 1); - goto cleanup; - } - ops[op_num].op = (grpc_op_type)index; - ops[op_num].flags = 0; - ops[op_num].reserved = NULL; - op_num++; - } ZEND_HASH_FOREACH_END(); - -#endif + PHP_GRPC_HASH_FOREACH_END() error = grpc_call_start_batch(call->wrapped, ops, op_num, call->wrapped, NULL); @@ -642,7 +435,9 @@ PHP_METHOD(Call, startBatch) { } grpc_completion_queue_pluck(completion_queue, call->wrapped, gpr_inf_future(GPR_CLOCK_REALTIME), NULL); -#if PHP_MAJOR_VERSION < 7 +#if PHP_MAJOR_VERSION >= 7 + zval recv_md; +#endif for (int i = 0; i < op_num; i++) { switch(ops[i].op) { case GRPC_OP_SEND_INITIAL_METADATA: @@ -658,73 +453,37 @@ PHP_METHOD(Call, startBatch) { add_property_bool(result, "send_status", true); break; case GRPC_OP_RECV_INITIAL_METADATA: +#if PHP_MAJOR_VERSION < 7 array = grpc_parse_metadata_array(&recv_metadata TSRMLS_CC); add_property_zval(result, "metadata", array); - Z_DELREF_P(array); - break; - case GRPC_OP_RECV_MESSAGE: - byte_buffer_to_string(message, &message_str, &message_len); - if (message_str == NULL) { - add_property_null(result, "message"); - } else { - add_property_stringl(result, "message", message_str, message_len, - false); - } - break; - case GRPC_OP_RECV_STATUS_ON_CLIENT: - MAKE_STD_ZVAL(recv_status); - object_init(recv_status); - array = grpc_parse_metadata_array(&recv_trailing_metadata TSRMLS_CC); - add_property_zval(recv_status, "metadata", array); - Z_DELREF_P(array); - add_property_long(recv_status, "code", status); - add_property_string(recv_status, "details", status_details, true); - add_property_zval(result, "status", recv_status); - Z_DELREF_P(recv_status); - break; - case GRPC_OP_RECV_CLOSE_ON_SERVER: - add_property_bool(result, "cancelled", cancelled); - break; - default: - break; - } - } #else - zval recv_md; - for (int i = 0; i < op_num; i++) { - switch(ops[i].op) { - case GRPC_OP_SEND_INITIAL_METADATA: - add_property_bool(result, "send_metadata", true); - break; - case GRPC_OP_SEND_MESSAGE: - add_property_bool(result, "send_message", true); - break; - case GRPC_OP_SEND_CLOSE_FROM_CLIENT: - add_property_bool(result, "send_close", true); - break; - case GRPC_OP_SEND_STATUS_FROM_SERVER: - add_property_bool(result, "send_status", true); - break; - case GRPC_OP_RECV_INITIAL_METADATA: recv_md = *grpc_parse_metadata_array(&recv_metadata); add_property_zval(result, "metadata", &recv_md); +#endif + PHP_GRPC_DELREF(array); break; case GRPC_OP_RECV_MESSAGE: byte_buffer_to_string(message, &message_str, &message_len); if (message_str == NULL) { add_property_null(result, "message"); } else { - add_property_stringl(result, "message", message_str, - message_len); + php_grpc_add_property_stringl(result, "message", message_str, + message_len, false); } break; case GRPC_OP_RECV_STATUS_ON_CLIENT: - object_init(&recv_status); +#if PHP_MAJOR_VERSION < 7 + array = grpc_parse_metadata_array(&recv_trailing_metadata TSRMLS_CC); + add_property_zval(recv_status, "metadata", array); +#else recv_md = *grpc_parse_metadata_array(&recv_trailing_metadata); - add_property_zval(&recv_status, "metadata", &recv_md); - add_property_long(&recv_status, "code", status); - add_property_string(&recv_status, "details", status_details); - add_property_zval(result, "status", &recv_status); + add_property_zval(recv_status, "metadata", &recv_md); +#endif + PHP_GRPC_DELREF(array); + add_property_long(recv_status, "code", status); + php_grpc_add_property_string(recv_status, "details", status_details, true); + add_property_zval(result, "status", recv_status); + PHP_GRPC_DELREF(recv_status); break; case GRPC_OP_RECV_CLOSE_ON_SERVER: add_property_bool(result, "cancelled", cancelled); @@ -733,7 +492,6 @@ PHP_METHOD(Call, startBatch) { break; } } -#endif cleanup: grpc_metadata_array_destroy(&metadata); diff --git a/src/php/ext/grpc/call_credentials.c b/src/php/ext/grpc/call_credentials.c index 0c55745524eb2..b7d33d723948b 100644 --- a/src/php/ext/grpc/call_credentials.c +++ b/src/php/ext/grpc/call_credentials.c @@ -67,16 +67,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * associated with an object of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_call_credentials( zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_call_credentials *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_call_credentials *)emalloc( - sizeof(wrapped_grpc_call_credentials)); - memset(intern, 0, sizeof(wrapped_grpc_call_credentials)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_call_credentials) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_call_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c index 69264842f0c32..325e8f495ecae 100644 --- a/src/php/ext/grpc/channel.c +++ b/src/php/ext/grpc/channel.c @@ -71,15 +71,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * object of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_channel(zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_channel *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_channel *)emalloc(sizeof(wrapped_grpc_channel)); - memset(intern, 0, sizeof(wrapped_grpc_channel)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_channel) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_channel); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 @@ -98,16 +90,6 @@ void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args TSRMLS_DC) { HashTable *array_hash; int args_index; -#if PHP_MAJOR_VERSION < 7 - HashPosition array_pointer; - zval **data; - char *key; - uint key_len; - ulong index; -#else - zval *data; - zend_string *key; -#endif array_hash = Z_ARRVAL_P(args_array); if (!array_hash) { zend_throw_exception(spl_ce_InvalidArgumentException, @@ -118,41 +100,17 @@ void php_grpc_read_args_array(zval *args_array, args->args = ecalloc(args->num_args, sizeof(grpc_arg)); args_index = 0; -#if PHP_MAJOR_VERSION < 7 - for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer); - zend_hash_get_current_data_ex(array_hash, (void **)&data, - &array_pointer) == SUCCESS; - zend_hash_move_forward_ex(array_hash, &array_pointer)) { - if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0, - &array_pointer) != HASH_KEY_IS_STRING) { + char *key = NULL; + zval *data; + int key_type; + + PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key, key_type, data) + if (key_type != HASH_KEY_IS_STRING) { zend_throw_exception(spl_ce_InvalidArgumentException, "args keys must be strings", 1 TSRMLS_CC); return; } args->args[args_index].key = key; - switch (Z_TYPE_P(*data)) { - case IS_LONG: - args->args[args_index].value.integer = (int)Z_LVAL_P(*data); - args->args[args_index].type = GRPC_ARG_INTEGER; - break; - case IS_STRING: - args->args[args_index].value.string = Z_STRVAL_P(*data); - args->args[args_index].type = GRPC_ARG_STRING; - break; - default: - zend_throw_exception(spl_ce_InvalidArgumentException, - "args values must be int or string", 1 TSRMLS_CC); - return; - } - args_index++; - } -#else - ZEND_HASH_FOREACH_STR_KEY_VAL(array_hash, key, data) { - if (key == NULL) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "args keys must be strings", 1); - } - args->args[args_index].key = ZSTR_VAL(key); switch (Z_TYPE_P(data)) { case IS_LONG: args->args[args_index].value.integer = (int)Z_LVAL_P(data); @@ -164,12 +122,11 @@ void php_grpc_read_args_array(zval *args_array, break; default: zend_throw_exception(spl_ce_InvalidArgumentException, - "args values must be int or string", 1); + "args values must be int or string", 1 TSRMLS_CC); return; } args_index++; - } ZEND_HASH_FOREACH_END(); -#endif + PHP_GRPC_HASH_FOREACH_END() } /** @@ -181,11 +138,7 @@ void php_grpc_read_args_array(zval *args_array, */ PHP_METHOD(Channel, __construct) { wrapped_grpc_channel *channel = Z_WRAPPED_GRPC_CHANNEL_P(getThis()); -#if PHP_MAJOR_VERSION < 7 - zval **creds_obj = NULL; -#else zval *creds_obj = NULL; -#endif char *target; php_grpc_int target_length; zval *args_array = NULL; @@ -200,43 +153,23 @@ PHP_METHOD(Channel, __construct) { "Channel expects a string and an array", 1 TSRMLS_CC); return; } -#if PHP_MAJOR_VERSION < 7 array_hash = Z_ARRVAL_P(args_array); - if (zend_hash_find(array_hash, "credentials", sizeof("credentials"), + if (php_grpc_zend_hash_find(array_hash, "credentials", sizeof("credentials"), (void **)&creds_obj) == SUCCESS) { - if (Z_TYPE_P(*creds_obj) == IS_NULL) { - creds = NULL; - zend_hash_del(array_hash, "credentials", 12); - } else if (zend_get_class_entry(*creds_obj TSRMLS_CC) != - grpc_ce_channel_credentials) { - zend_throw_exception(spl_ce_InvalidArgumentException, - "credentials must be a ChannelCredentials object", - 1 TSRMLS_CC); - return; - } else { - creds = (wrapped_grpc_channel_credentials *)zend_object_store_get_object( - *creds_obj TSRMLS_CC); - zend_hash_del(array_hash, "credentials", 12); - } - } -#else - array_hash = HASH_OF(args_array); - if ((creds_obj = zend_hash_str_find(array_hash, "credentials", - sizeof("credentials") - 1)) != NULL) { if (Z_TYPE_P(creds_obj) == IS_NULL) { creds = NULL; - zend_hash_str_del(array_hash, "credentials", sizeof("credentials") - 1); - } else if (Z_OBJ_P(creds_obj)->ce != grpc_ce_channel_credentials) { + php_grpc_zend_hash_del(array_hash, "credentials", sizeof("credentials")); + } else if (PHP_GRPC_GET_CLASS_ENTRY(creds_obj) != + grpc_ce_channel_credentials) { zend_throw_exception(spl_ce_InvalidArgumentException, "credentials must be a ChannelCredentials object", - 1); + 1 TSRMLS_CC); return; } else { creds = Z_WRAPPED_GRPC_CHANNEL_CREDS_P(creds_obj); - zend_hash_str_del(array_hash, "credentials", sizeof("credentials") - 1); + php_grpc_zend_hash_del(array_hash, "credentials", sizeof("credentials")); } } -#endif php_grpc_read_args_array(args_array, &args TSRMLS_CC); if (creds == NULL) { channel->wrapped = grpc_insecure_channel_create(target, &args, NULL); @@ -292,8 +225,7 @@ PHP_METHOD(Channel, watchConnectivityState) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lO", &last_state, &deadline_obj, grpc_ce_timeval) == FAILURE) { zend_throw_exception(spl_ce_InvalidArgumentException, - "watchConnectivityState expects 1 long 1 timeval", - 1 TSRMLS_CC); + "watchConnectivityState expects 1 long 1 timeval", 1 TSRMLS_CC); return; } diff --git a/src/php/ext/grpc/channel_credentials.c b/src/php/ext/grpc/channel_credentials.c index cef435cc6ea0f..32f24e5751fe0 100644 --- a/src/php/ext/grpc/channel_credentials.c +++ b/src/php/ext/grpc/channel_credentials.c @@ -77,16 +77,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * associated with an object of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_channel_credentials( zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_channel_credentials *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_channel_credentials *)emalloc( - sizeof(wrapped_grpc_channel_credentials)); - memset(intern, 0, sizeof(wrapped_grpc_channel_credentials)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_channel_credentials) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_channel_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 diff --git a/src/php/ext/grpc/php7_wrapper.h b/src/php/ext/grpc/php7_wrapper.h index 7d7470f8a9181..ba7f163676d44 100644 --- a/src/php/ext/grpc/php7_wrapper.h +++ b/src/php/ext/grpc/php7_wrapper.h @@ -50,6 +50,7 @@ #define PHP_GRPC_RETURN_STRING(val, dup) RETURN_STRING(val, dup) #define PHP_GRPC_MAKE_STD_ZVAL(pzv) MAKE_STD_ZVAL(pzv) +#define PHP_GRPC_DELREF(zv) Z_DELREF_P(zv) #define PHP_GRPC_WRAP_OBJECT_START(name) \ typedef struct name { \ @@ -65,6 +66,58 @@ efree(p); \ } +#define PHP_GRPC_ALLOC_CLASS_OBJECT(class_object) \ + class_object *intern; \ + zend_object_value retval; \ + intern = (class_object *)emalloc(sizeof(class_object)); \ + memset(intern, 0, sizeof(class_object)); + +#define PHP_GRPC_HASH_FOREACH_VAL_START(ht, data) \ + zval **tmp_data = NULL; \ + for (zend_hash_internal_pointer_reset(ht); \ + zend_hash_get_current_data(ht, (void**)&tmp_data) == SUCCESS; \ + zend_hash_move_forward(ht)) { \ + data = *tmp_data; + +#define PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(ht, key, key_type, data) \ + zval **tmp##key = NULL; \ + ulong index##key; \ + uint len##key; \ + for (zend_hash_internal_pointer_reset(ht); \ + zend_hash_get_current_data(ht, (void**)&tmp##key) == SUCCESS; \ + zend_hash_move_forward(ht)) { \ + key_type = zend_hash_get_current_key_ex(ht, &key, &len##key, &index##key,\ + 0, NULL); \ + data = *tmp##key; + +#define PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(ht, key, key_type, index,\ + data) \ + zval **tmp##key = NULL; \ + uint len##key; \ + for (zend_hash_internal_pointer_reset(ht); \ + zend_hash_get_current_data(ht, (void**)&tmp##key) == SUCCESS; \ + zend_hash_move_forward(ht)) { \ + key_type = zend_hash_get_current_key_ex(ht, &key, &len##key, &index,\ + 0, NULL); \ + data = *tmp##key; + +#define PHP_GRPC_HASH_FOREACH_END() } + +static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, void **value) { + zval **data = NULL; + if (zend_hash_find(ht, key, len, (void **)&data) == SUCCESS) { + *value = *data; + return SUCCESS; + } else { + *value = NULL; + return FAILURE; + } +} + +#define php_grpc_zend_hash_del zend_hash_del + +#define PHP_GRPC_GET_CLASS_ENTRY(object) zend_get_class_entry(object TSRMLS_CC) + #else #define php_grpc_int size_t @@ -82,6 +135,7 @@ #define PHP_GRPC_MAKE_STD_ZVAL(pzv) \ zval _stack_zval_##pzv; \ pzv = &(_stack_zval_##pzv) +#define PHP_GRPC_DELREF(zv) #define PHP_GRPC_WRAP_OBJECT_START(name) \ typedef struct name { @@ -99,6 +153,45 @@ zend_object_std_dtor(&p->std); \ } +#define PHP_GRPC_ALLOC_CLASS_OBJECT(class_object) \ + class_object *intern; \ + intern = ecalloc(1, sizeof(class_object) + \ + zend_object_properties_size(class_type)); + +#define PHP_GRPC_HASH_FOREACH_VAL_START(ht, data) \ + ZEND_HASH_FOREACH_VAL(ht, data) { + +#define PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(ht, key, key_type, data) \ + zend_string *(zs_##key); \ + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, (zs_##key), data) { \ + if ((zs_##key) == NULL) {key = NULL; key_type = HASH_KEY_IS_LONG;} \ + else {key = (zs_##key)->val; key_type = HASH_KEY_IS_STRING;} + +#define PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(ht, key, key_type, index, \ + data) \ + zend_string *(zs_##key); \ + ZEND_HASH_FOREACH_KEY_VAL(ht, index, zs_##key, data) { \ + if ((zs_##key) == NULL) {key = NULL; key_type = HASH_KEY_IS_LONG;} \ + else {key = (zs_##key)->val; key_type = HASH_KEY_IS_STRING;} + +#define PHP_GRPC_HASH_FOREACH_END() } ZEND_HASH_FOREACH_END(); + +static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, void **value) { + zval *value_tmp = zend_hash_str_find(ht, key, len -1); + if (value_tmp == NULL) { + return FAILURE; + } else { + *value = (void *)value_tmp; + return SUCCESS; + } +} + +static inline int php_grpc_zend_hash_del(HashTable *ht, char *key, int len) { + return zend_hash_str_del(ht, key, len - 1); +} + +#define PHP_GRPC_GET_CLASS_ENTRY(object) Z_OBJ_P(object)->ce + #endif /* PHP_MAJOR_VERSION */ #endif /* PHP7_WRAPPER_GRPC_H */ diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c index d8ebd4472d69e..2fc785eb31fd7 100644 --- a/src/php/ext/grpc/server.c +++ b/src/php/ext/grpc/server.c @@ -76,15 +76,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_server(zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_server *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_server *)emalloc(sizeof(wrapped_grpc_server)); - memset(intern, 0, sizeof(wrapped_grpc_server)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_server) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_server); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c index 921436a1bba41..4c147e09912b5 100644 --- a/src/php/ext/grpc/server_credentials.c +++ b/src/php/ext/grpc/server_credentials.c @@ -65,16 +65,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * with an object of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_server_credentials( zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_server_credentials *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_server_credentials *)emalloc( - sizeof(wrapped_grpc_server_credentials)); - memset(intern, 0, sizeof(wrapped_grpc_server_credentials)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_server_credentials) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_server_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index 33d11f83ccee8..d0f75bef82c15 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -63,15 +63,7 @@ PHP_GRPC_FREE_WRAPPED_FUNC_END() * object of a class specified by class_type */ php_grpc_zend_object create_wrapped_grpc_timeval(zend_class_entry *class_type TSRMLS_DC) { - wrapped_grpc_timeval *intern; -#if PHP_MAJOR_VERSION < 7 - zend_object_value retval; - intern = (wrapped_grpc_timeval *)emalloc(sizeof(wrapped_grpc_timeval)); - memset(intern, 0, sizeof(wrapped_grpc_timeval)); -#else - intern = ecalloc(1, sizeof(wrapped_grpc_timeval) + - zend_object_properties_size(class_type)); -#endif + PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_timeval); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); #if PHP_MAJOR_VERSION < 7 From dacb2e3a5c5b07b66aa2d999b2d2df682e4a9b1d Mon Sep 17 00:00:00 2001 From: thinkerou Date: Thu, 28 Jul 2016 08:25:41 +0800 Subject: [PATCH 4/7] fix unused var --- src/php/ext/grpc/call.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index 46591d8738594..10fc3feb63d34 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -150,11 +150,11 @@ bool create_metadata_array(zval *array, grpc_metadata_array *metadata) { grpc_metadata_array_init(metadata); array_hash = Z_ARRVAL_P(array); - char *key = NULL; + char *key; int key_type; PHP_GRPC_HASH_FOREACH_STR_KEY_VAL_START(array_hash, key, key_type, inner_array) - if (key_type != HASH_KEY_IS_STRING) { + if (key_type != HASH_KEY_IS_STRING || key == NULL) { return false; } if (Z_TYPE_P(inner_array) != IS_ARRAY) { @@ -291,7 +291,8 @@ PHP_METHOD(Call, startBatch) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) { zend_throw_exception(spl_ce_InvalidArgumentException, - "start_batch expects an array", 1 TSRMLS_CC); goto cleanup; + "start_batch expects an array", 1 TSRMLS_CC); + goto cleanup; } array_hash = Z_ARRVAL_P(array); @@ -300,7 +301,7 @@ PHP_METHOD(Call, startBatch) { int key_type; PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(array_hash, key, key_type, index, value) - if (key_type != HASH_KEY_IS_LONG) { + if (key_type != HASH_KEY_IS_LONG || key != NULL) { zend_throw_exception(spl_ce_InvalidArgumentException, "batch keys must be integers", 1 TSRMLS_CC); goto cleanup; From a24a0dd784570d88282a61c6fdd1a4870b8554d8 Mon Sep 17 00:00:00 2001 From: thinkerou Date: Thu, 28 Jul 2016 09:51:08 +0800 Subject: [PATCH 5/7] add PHP_GRPC_FREE_CLASS_OBJECT macro --- src/php/ext/grpc/call.c | 11 +---------- src/php/ext/grpc/call_credentials.c | 12 ++---------- src/php/ext/grpc/channel.c | 11 +---------- src/php/ext/grpc/channel_credentials.c | 12 ++---------- src/php/ext/grpc/php7_wrapper.h | 11 +++++++++++ src/php/ext/grpc/server.c | 11 +---------- src/php/ext/grpc/server_credentials.c | 12 ++---------- src/php/ext/grpc/timeval.c | 5 +++-- 8 files changed, 23 insertions(+), 62 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index 10fc3feb63d34..840ac71364fe0 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -76,16 +76,7 @@ php_grpc_zend_object create_wrapped_grpc_call(zend_class_entry *class_type PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_call); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_call, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &call_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_call, call_ce_handlers); } /* Creates and returns a PHP array object with the data in a diff --git a/src/php/ext/grpc/call_credentials.c b/src/php/ext/grpc/call_credentials.c index b7d33d723948b..34a88af47f0cd 100644 --- a/src/php/ext/grpc/call_credentials.c +++ b/src/php/ext/grpc/call_credentials.c @@ -70,16 +70,8 @@ php_grpc_zend_object create_wrapped_grpc_call_credentials( PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_call_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_call_credentials, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &call_credentials_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_call_credentials, + call_credentials_ce_handlers); } zval *grpc_php_wrap_call_credentials(grpc_call_credentials diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c index 325e8f495ecae..1d3f68af7c2de 100644 --- a/src/php/ext/grpc/channel.c +++ b/src/php/ext/grpc/channel.c @@ -74,16 +74,7 @@ php_grpc_zend_object create_wrapped_grpc_channel(zend_class_entry *class_type PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_channel); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_channel, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &channel_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_channel, channel_ce_handlers); } void php_grpc_read_args_array(zval *args_array, diff --git a/src/php/ext/grpc/channel_credentials.c b/src/php/ext/grpc/channel_credentials.c index 32f24e5751fe0..7ef95cc5e2ba7 100644 --- a/src/php/ext/grpc/channel_credentials.c +++ b/src/php/ext/grpc/channel_credentials.c @@ -80,16 +80,8 @@ php_grpc_zend_object create_wrapped_grpc_channel_credentials( PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_channel_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_channel_credentials, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &channel_credentials_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_channel_credentials, + channel_credentials_ce_handlers); } zval *grpc_php_wrap_channel_credentials(grpc_channel_credentials diff --git a/src/php/ext/grpc/php7_wrapper.h b/src/php/ext/grpc/php7_wrapper.h index ba7f163676d44..44d6cd8dd73f1 100644 --- a/src/php/ext/grpc/php7_wrapper.h +++ b/src/php/ext/grpc/php7_wrapper.h @@ -72,6 +72,13 @@ intern = (class_object *)emalloc(sizeof(class_object)); \ memset(intern, 0, sizeof(class_object)); +#define PHP_GRPC_FREE_CLASS_OBJECT(class_object, handler) \ + retval.handle = zend_objects_store_put( \ + intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, \ + free_##class_object, NULL TSRMLS_CC); \ + retval.handlers = zend_get_std_object_handlers(); \ + return retval; + #define PHP_GRPC_HASH_FOREACH_VAL_START(ht, data) \ zval **tmp_data = NULL; \ for (zend_hash_internal_pointer_reset(ht); \ @@ -158,6 +165,10 @@ static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, voi intern = ecalloc(1, sizeof(class_object) + \ zend_object_properties_size(class_type)); +#define PHP_GRPC_FREE_CLASS_OBJECT(class_object, handler) \ + intern->std.handlers = &handler; \ + return &intern->std; + #define PHP_GRPC_HASH_FOREACH_VAL_START(ht, data) \ ZEND_HASH_FOREACH_VAL(ht, data) { diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c index 2fc785eb31fd7..452ccca3e1054 100644 --- a/src/php/ext/grpc/server.c +++ b/src/php/ext/grpc/server.c @@ -79,16 +79,7 @@ php_grpc_zend_object create_wrapped_grpc_server(zend_class_entry *class_type PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_server); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_server, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &server_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_server, server_ce_handlers); } /** diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c index 4c147e09912b5..61041b4cb37cb 100644 --- a/src/php/ext/grpc/server_credentials.c +++ b/src/php/ext/grpc/server_credentials.c @@ -68,16 +68,8 @@ php_grpc_zend_object create_wrapped_grpc_server_credentials( PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_server_credentials); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_server_credentials, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &server_credentials_ce_handlers; - return &intern->std; -#endif + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_server_credentials, + server_credentials_ce_handlers); } zval *grpc_php_wrap_server_credentials(grpc_server_credentials diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index d0f75bef82c15..0d739f1608358 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -66,7 +66,8 @@ php_grpc_zend_object create_wrapped_grpc_timeval(zend_class_entry *class_type PHP_GRPC_ALLOC_CLASS_OBJECT(wrapped_grpc_timeval); zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); -#if PHP_MAJOR_VERSION < 7 + PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_timeval, timeval_ce_handlers); +/*#if PHP_MAJOR_VERSION < 7 retval.handle = zend_objects_store_put( intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, free_wrapped_grpc_timeval, NULL TSRMLS_CC); @@ -75,7 +76,7 @@ php_grpc_zend_object create_wrapped_grpc_timeval(zend_class_entry *class_type #else intern->std.handlers = &timeval_ce_handlers; return &intern->std; -#endif +#endif*/ } zval *grpc_php_wrap_timeval(gpr_timespec wrapped TSRMLS_DC) { From 3e03e1651ec8c8b4ab23b986f0ad17ded48f9a32 Mon Sep 17 00:00:00 2001 From: thinkerou Date: Thu, 28 Jul 2016 10:18:27 +0800 Subject: [PATCH 6/7] delete commented-code for missing --- src/php/ext/grpc/timeval.c | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index 0d739f1608358..28d360f09fb8b 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -67,16 +67,6 @@ php_grpc_zend_object create_wrapped_grpc_timeval(zend_class_entry *class_type zend_object_std_init(&intern->std, class_type TSRMLS_CC); object_properties_init(&intern->std, class_type); PHP_GRPC_FREE_CLASS_OBJECT(wrapped_grpc_timeval, timeval_ce_handlers); -/*#if PHP_MAJOR_VERSION < 7 - retval.handle = zend_objects_store_put( - intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, - free_wrapped_grpc_timeval, NULL TSRMLS_CC); - retval.handlers = zend_get_std_object_handlers(); - return retval; -#else - intern->std.handlers = &timeval_ce_handlers; - return &intern->std; -#endif*/ } zval *grpc_php_wrap_timeval(gpr_timespec wrapped TSRMLS_DC) { From 6972af492da588a39e64cc13a04ad9a7f0a05097 Mon Sep 17 00:00:00 2001 From: thinkerou Date: Thu, 28 Jul 2016 22:46:07 +0800 Subject: [PATCH 7/7] add macro PHP_GRPC_INIT_HANDLER --- src/php/ext/grpc/call.c | 20 ++++++-------------- src/php/ext/grpc/call_credentials.c | 11 ++--------- src/php/ext/grpc/call_credentials.h | 6 ++---- src/php/ext/grpc/channel.c | 8 +------- src/php/ext/grpc/channel_credentials.c | 11 ++--------- src/php/ext/grpc/channel_credentials.h | 5 ++--- src/php/ext/grpc/php7_wrapper.h | 11 ++++++++++- src/php/ext/grpc/server.c | 9 ++------- src/php/ext/grpc/server.h | 3 +-- src/php/ext/grpc/server_credentials.c | 13 +++---------- src/php/ext/grpc/server_credentials.h | 4 ++-- src/php/ext/grpc/timeval.c | 8 +------- 12 files changed, 34 insertions(+), 75 deletions(-) diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c index 840ac71364fe0..429dbf52d0b7c 100644 --- a/src/php/ext/grpc/call.c +++ b/src/php/ext/grpc/call.c @@ -105,8 +105,8 @@ zval *grpc_parse_metadata_array(grpc_metadata_array memcpy(str_key, elem->key, key_len); str_val = ecalloc(elem->value_length + 1, sizeof(char)); memcpy(str_val, elem->value, elem->value_length); - if (php_grpc_zend_hash_find(array_hash, str_key, key_len, (void **)&data) == - SUCCESS) { + if (php_grpc_zend_hash_find(array_hash, str_key, key_len, (void **)&data) + == SUCCESS) { if (Z_TYPE_P(data) != IS_ARRAY) { zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Metadata hash somehow contains wrong types.", @@ -271,7 +271,6 @@ PHP_METHOD(Call, startBatch) { char *message_str; size_t message_len; - grpc_metadata_array_init(&metadata); grpc_metadata_array_init(&trailing_metadata); grpc_metadata_array_init(&recv_metadata); @@ -291,7 +290,7 @@ PHP_METHOD(Call, startBatch) { char *key = NULL; int key_type; PHP_GRPC_HASH_FOREACH_LONG_KEY_VAL_START(array_hash, key, key_type, index, - value) + value) if (key_type != HASH_KEY_IS_LONG || key != NULL) { zend_throw_exception(spl_ce_InvalidArgumentException, "batch keys must be integers", 1 TSRMLS_CC); @@ -304,10 +303,8 @@ PHP_METHOD(Call, startBatch) { "Bad metadata value given", 1 TSRMLS_CC); goto cleanup; } - ops[op_num].data.send_initial_metadata.count = - metadata.count; - ops[op_num].data.send_initial_metadata.metadata = - metadata.metadata; + ops[op_num].data.send_initial_metadata.count = metadata.count; + ops[op_num].data.send_initial_metadata.metadata = metadata.metadata; break; case GRPC_OP_SEND_MESSAGE: if (Z_TYPE_P(value) != IS_ARRAY) { @@ -562,10 +559,5 @@ void grpc_init_call(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods); ce.create_object = create_wrapped_grpc_call; grpc_ce_call = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&call_ce_handlers, zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - call_ce_handlers.offset = XtOffsetOf(wrapped_grpc_call, std); - call_ce_handlers.free_obj = free_wrapped_grpc_call; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_call, call_ce_handlers); } diff --git a/src/php/ext/grpc/call_credentials.c b/src/php/ext/grpc/call_credentials.c index 34a88af47f0cd..6921a5df17ba8 100644 --- a/src/php/ext/grpc/call_credentials.c +++ b/src/php/ext/grpc/call_credentials.c @@ -235,13 +235,6 @@ void grpc_init_call_credentials(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\CallCredentials", call_credentials_methods); ce.create_object = create_wrapped_grpc_call_credentials; grpc_ce_call_credentials = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&call_credentials_ce_handlers, - zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - call_credentials_ce_handlers.offset = - XtOffsetOf(wrapped_grpc_call_credentials, std); - call_credentials_ce_handlers.free_obj = - free_wrapped_grpc_call_credentials; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_call_credentials, + call_credentials_ce_handlers); } diff --git a/src/php/ext/grpc/call_credentials.h b/src/php/ext/grpc/call_credentials.h index 8014b75c7032e..c1d85c0fb2839 100755 --- a/src/php/ext/grpc/call_credentials.h +++ b/src/php/ext/grpc/call_credentials.h @@ -64,10 +64,8 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_call_credentials) static inline wrapped_grpc_call_credentials *wrapped_grpc_call_credentials_from_obj(zend_object *obj) { - return - (wrapped_grpc_call_credentials*)((char*)(obj) - - XtOffsetOf(wrapped_grpc_call_credentials, - std)); + return (wrapped_grpc_call_credentials*)( + (char*)(obj) - XtOffsetOf(wrapped_grpc_call_credentials, std)); } #define Z_WRAPPED_GRPC_CALL_CREDS_P(zv) \ diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c index 1d3f68af7c2de..e96ead582f4dd 100644 --- a/src/php/ext/grpc/channel.c +++ b/src/php/ext/grpc/channel.c @@ -256,11 +256,5 @@ void grpc_init_channel(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\Channel", channel_methods); ce.create_object = create_wrapped_grpc_channel; grpc_ce_channel = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&channel_ce_handlers, zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - channel_ce_handlers.offset = - XtOffsetOf(wrapped_grpc_channel, std); - channel_ce_handlers.free_obj = free_wrapped_grpc_channel; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_channel, channel_ce_handlers); } diff --git a/src/php/ext/grpc/channel_credentials.c b/src/php/ext/grpc/channel_credentials.c index 7ef95cc5e2ba7..0b356aa25fc83 100644 --- a/src/php/ext/grpc/channel_credentials.c +++ b/src/php/ext/grpc/channel_credentials.c @@ -226,13 +226,6 @@ void grpc_init_channel_credentials(TSRMLS_D) { grpc_set_ssl_roots_override_callback(get_ssl_roots_override); ce.create_object = create_wrapped_grpc_channel_credentials; grpc_ce_channel_credentials = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&channel_credentials_ce_handlers, - zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - channel_credentials_ce_handlers.offset = - XtOffsetOf(wrapped_grpc_channel_credentials, std); - channel_credentials_ce_handlers.free_obj = - free_wrapped_grpc_channel_credentials; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_channel_credentials, + channel_credentials_ce_handlers); } diff --git a/src/php/ext/grpc/channel_credentials.h b/src/php/ext/grpc/channel_credentials.h index 39dc85283d531..b043d91fa6972 100755 --- a/src/php/ext/grpc/channel_credentials.h +++ b/src/php/ext/grpc/channel_credentials.h @@ -64,9 +64,8 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_channel_credentials) static inline wrapped_grpc_channel_credentials *wrapped_grpc_channel_credentials_from_obj(zend_object *obj) { - return - (wrapped_grpc_channel_credentials *) - ((char*)(obj) - XtOffsetOf(wrapped_grpc_channel_credentials, std)); + return (wrapped_grpc_channel_credentials *)( + (char*)(obj) - XtOffsetOf(wrapped_grpc_channel_credentials, std)); } #define Z_WRAPPED_GRPC_CHANNEL_CREDS_P(zv) \ diff --git a/src/php/ext/grpc/php7_wrapper.h b/src/php/ext/grpc/php7_wrapper.h index 44d6cd8dd73f1..f2976c26cd906 100644 --- a/src/php/ext/grpc/php7_wrapper.h +++ b/src/php/ext/grpc/php7_wrapper.h @@ -125,6 +125,8 @@ static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, voi #define PHP_GRPC_GET_CLASS_ENTRY(object) zend_get_class_entry(object TSRMLS_CC) +#define PHP_GRPC_INIT_HANDLER(class_object, handler_name) + #else #define php_grpc_int size_t @@ -187,7 +189,8 @@ static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, voi #define PHP_GRPC_HASH_FOREACH_END() } ZEND_HASH_FOREACH_END(); -static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, void **value) { +static inline int php_grpc_zend_hash_find(HashTable *ht, char *key, int len, + void **value) { zval *value_tmp = zend_hash_str_find(ht, key, len -1); if (value_tmp == NULL) { return FAILURE; @@ -203,6 +206,12 @@ static inline int php_grpc_zend_hash_del(HashTable *ht, char *key, int len) { #define PHP_GRPC_GET_CLASS_ENTRY(object) Z_OBJ_P(object)->ce +#define PHP_GRPC_INIT_HANDLER(class_object, handler_name) \ + memcpy(&handler_name, zend_get_std_object_handlers(), \ + sizeof(zend_object_handlers)); \ + handler_name.offset = XtOffsetOf(class_object, std); \ + handler_name.free_obj = free_##class_object + #endif /* PHP_MAJOR_VERSION */ #endif /* PHP7_WRAPPER_GRPC_H */ diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c index 452ccca3e1054..fc20c42b169eb 100644 --- a/src/php/ext/grpc/server.c +++ b/src/php/ext/grpc/server.c @@ -233,7 +233,7 @@ static zend_function_entry server_methods[] = { PHP_ME(Server, addHttp2Port, NULL, ZEND_ACC_PUBLIC) PHP_ME(Server, addSecureHttp2Port, NULL, ZEND_ACC_PUBLIC) PHP_ME(Server, start, NULL, ZEND_ACC_PUBLIC) - PHP_FE_END + PHP_FE_END }; void grpc_init_server(TSRMLS_D) { @@ -241,10 +241,5 @@ void grpc_init_server(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\Server", server_methods); ce.create_object = create_wrapped_grpc_server; grpc_ce_server = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&server_ce_handlers, zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - server_ce_handlers.offset = XtOffsetOf(wrapped_grpc_server, std); - server_ce_handlers.free_obj = free_wrapped_grpc_server; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_server, server_ce_handlers); } diff --git a/src/php/ext/grpc/server.h b/src/php/ext/grpc/server.h index 02ef1f797573b..a635bc11df938 100755 --- a/src/php/ext/grpc/server.h +++ b/src/php/ext/grpc/server.h @@ -66,8 +66,7 @@ static inline wrapped_grpc_server XtOffsetOf(wrapped_grpc_server, std)); } -#define Z_WRAPPED_GRPC_SERVER_P(zv) \ - wrapped_grpc_server_from_obj(Z_OBJ_P((zv))) +#define Z_WRAPPED_GRPC_SERVER_P(zv) wrapped_grpc_server_from_obj(Z_OBJ_P((zv))) #endif /* PHP_MAJOR_VERSION */ diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c index 61041b4cb37cb..b05896af4afc4 100644 --- a/src/php/ext/grpc/server_credentials.c +++ b/src/php/ext/grpc/server_credentials.c @@ -122,7 +122,7 @@ PHP_METHOD(ServerCredentials, createSsl) { static zend_function_entry server_credentials_methods[] = { PHP_ME(ServerCredentials, createSsl, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) - PHP_FE_END + PHP_FE_END }; void grpc_init_server_credentials(TSRMLS_D) { @@ -130,13 +130,6 @@ void grpc_init_server_credentials(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\ServerCredentials", server_credentials_methods); ce.create_object = create_wrapped_grpc_server_credentials; grpc_ce_server_credentials = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&server_credentials_ce_handlers, - zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - server_credentials_ce_handlers.offset = - XtOffsetOf(wrapped_grpc_server_credentials, std); - server_credentials_ce_handlers.free_obj = - free_wrapped_grpc_server_credentials; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_server_credentials, + server_credentials_ce_handlers); } diff --git a/src/php/ext/grpc/server_credentials.h b/src/php/ext/grpc/server_credentials.h index 9551ec6c24f3a..6781a614b17e6 100755 --- a/src/php/ext/grpc/server_credentials.h +++ b/src/php/ext/grpc/server_credentials.h @@ -64,8 +64,8 @@ PHP_GRPC_WRAP_OBJECT_END(wrapped_grpc_server_credentials) static inline wrapped_grpc_server_credentials *wrapped_grpc_server_credentials_from_obj(zend_object *obj) { - return (wrapped_grpc_server_credentials*) - ((char*)(obj) - XtOffsetOf(wrapped_grpc_server_credentials, std)); + return (wrapped_grpc_server_credentials*)( + (char*)(obj) - XtOffsetOf(wrapped_grpc_server_credentials, std)); } #define Z_WRAPPED_GRPC_SERVER_CREDS_P(zv) \ diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c index 28d360f09fb8b..e145d9677267c 100644 --- a/src/php/ext/grpc/timeval.c +++ b/src/php/ext/grpc/timeval.c @@ -278,13 +278,7 @@ void grpc_init_timeval(TSRMLS_D) { INIT_CLASS_ENTRY(ce, "Grpc\\Timeval", timeval_methods); ce.create_object = create_wrapped_grpc_timeval; grpc_ce_timeval = zend_register_internal_class(&ce TSRMLS_CC); -#if PHP_MAJOR_VERSION >= 7 - memcpy(&timeval_ce_handlers, zend_get_std_object_handlers(), - sizeof(zend_object_handlers)); - timeval_ce_handlers.offset = - XtOffsetOf(wrapped_grpc_timeval, std); - timeval_ce_handlers.free_obj = free_wrapped_grpc_timeval; -#endif + PHP_GRPC_INIT_HANDLER(wrapped_grpc_timeval, timeval_ce_handlers); } void grpc_shutdown_timeval(TSRMLS_D) {}