Use zend_object_alloc

php_swoole.h

@@ -782,9 +782,22 @@ static sw_inline int sw_zend_register_class_alias(const char *name, size_t name_
 #endif
 }
 
+#if PHP_VERSION_ID < 70300
+/* Allocates object type and zeros it, but not the properties.
+ * Properties MUST be initialized using object_properties_init(). */
+static zend_always_inline void *zend_object_alloc(size_t obj_size, zend_class_entry *ce)
+{
+    void *obj = emalloc(obj_size + zend_object_properties_size(ce));
+    /* Subtraction of sizeof(zval) is necessary, because zend_object_properties_size() may be
+     * -sizeof(zval), if the object has no properties. */
+    memset(obj, 0, obj_size - sizeof(zval));
+    return obj;
+}
+#endif
+
 static sw_inline zend_object *sw_zend_create_object(zend_class_entry *ce, zend_object_handlers *handlers)
 {
-    zend_object* object = (zend_object *) ecalloc(1, sizeof(zend_object) + zend_object_properties_size(ce));
+    zend_object* object = (zend_object *) zend_object_alloc(sizeof(zend_object), ce);
     zend_object_std_init(object, ce);
     object_properties_init(object, ce);
     object->handlers = handlers;

swoole_atomic.cc

@@ -98,7 +98,7 @@ static void php_swoole_atomic_free_object(zend_object *object)
 
 static zend_object *php_swoole_atomic_create_object(zend_class_entry *ce)
 {
-    atomic_t *atomic = (atomic_t *) ecalloc(1, sizeof(atomic_t) + zend_object_properties_size(ce));
+    atomic_t *atomic = (atomic_t *) zend_object_alloc(sizeof(atomic_t), ce);
     zend_object_std_init(&atomic->std, ce);
     object_properties_init(&atomic->std, ce);
     atomic->std.handlers = &swoole_atomic_handlers;
@@ -140,7 +140,7 @@ static void php_swoole_atomic_long_free_object(zend_object *object)
 
 static zend_object *php_swoole_atomic_long_create_object(zend_class_entry *ce)
 {
-    atomic_long_t *atomic_long = (atomic_long_t *) ecalloc(1, sizeof(atomic_long_t) + zend_object_properties_size(ce));
+    atomic_long_t *atomic_long = (atomic_long_t *) zend_object_alloc(sizeof(atomic_long_t), ce);
     zend_object_std_init(&atomic_long->std, ce);
     object_properties_init(&atomic_long->std, ce);
     atomic_long->std.handlers = &swoole_atomic_long_handlers;

swoole_channel_coro.cc

@@ -124,7 +124,7 @@ static void php_swoole_channel_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_channel_coro_create_object(zend_class_entry *ce)
 {
-    channel_coro *chan_t = (channel_coro *) ecalloc(1, sizeof(channel_coro) + zend_object_properties_size(ce));
+    channel_coro *chan_t = (channel_coro *) zend_object_alloc(sizeof(channel_coro), ce);
     zend_object_std_init(&chan_t->std, ce);
     object_properties_init(&chan_t->std, ce);
     chan_t->std.handlers = &swoole_channel_coro_handlers;

swoole_client.cc

@@ -97,7 +97,7 @@ static void php_swoole_client_free_object(zend_object *object)
 
 static zend_object *php_swoole_client_create_object(zend_class_entry *ce)
 {
-    client_t *client = (client_t *) ecalloc(1, sizeof(client_t) + zend_object_properties_size(ce));
+    client_t *client = (client_t *) zend_object_alloc(sizeof(client_t), ce);
     zend_object_std_init(&client->std, ce);
     object_properties_init(&client->std, ce);
     client->std.handlers = &swoole_client_handlers;

swoole_client_coro.cc

@@ -157,7 +157,7 @@ static void php_swoole_client_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_client_coro_create_object(zend_class_entry *ce)
 {
-    client_coro *sock_t = (client_coro *) ecalloc(1, sizeof(client_coro) + zend_object_properties_size(ce));
+    client_coro *sock_t = (client_coro *) zend_object_alloc(sizeof(client_coro), ce);
     zend_object_std_init(&sock_t->std, ce);
     object_properties_init(&sock_t->std, ce);
     sock_t->std.handlers = &swoole_client_coro_handlers;

swoole_coroutine_scheduler.cc

@@ -73,7 +73,7 @@ static sw_inline scheduler_t* scheduler_get_object(zend_object *obj)
 
 static zend_object *scheduler_create_object(zend_class_entry *ce)
 {
-    scheduler_t *s = (scheduler_t *) ecalloc(1, sizeof(scheduler_t) + zend_object_properties_size(ce));
+    scheduler_t *s = (scheduler_t *) zend_object_alloc(sizeof(scheduler_t), ce);
     zend_object_std_init(&s->std, ce);
     object_properties_init(&s->std, ce);
     s->std.handlers = &swoole_coroutine_scheduler_handlers;

swoole_http2_client_coro.cc

@@ -233,7 +233,7 @@ static void php_swoole_http2_client_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_http2_client_coro_create_object(zend_class_entry *ce)
 {
-    http2_client_coro_t *request = (http2_client_coro_t *) ecalloc(1, sizeof(http2_client_coro_t) + zend_object_properties_size(ce));
+    http2_client_coro_t *request = (http2_client_coro_t *) zend_object_alloc(sizeof(http2_client_coro_t), ce);
     zend_object_std_init(&request->std, ce);
     object_properties_init(&request->std, ce);
     request->std.handlers = &swoole_http2_client_coro_handlers;

swoole_http_client_coro.cc

@@ -1720,7 +1720,7 @@ static void php_swoole_http_client_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_http_client_coro_create_object(zend_class_entry *ce)
 {
-    http_client_coro *hcc = (http_client_coro *) ecalloc(1, sizeof(http_client_coro) + zend_object_properties_size(ce));
+    http_client_coro *hcc = (http_client_coro *) zend_object_alloc(sizeof(http_client_coro), ce);
     zend_object_std_init(&hcc->std, ce);
     object_properties_init(&hcc->std, ce);
     hcc->std.handlers = &swoole_http_client_coro_handlers;

swoole_http_request.cc

@@ -269,7 +269,7 @@ static void php_swoole_http_request_free_object(zend_object *object)
 
 static zend_object *php_swoole_http_request_create_object(zend_class_entry *ce)
 {
-    http_request_t *request = (http_request_t *) ecalloc(1, sizeof(http_request_t) + zend_object_properties_size(ce));
+    http_request_t *request = (http_request_t *) zend_object_alloc(sizeof(http_request_t), ce);
     zend_object_std_init(&request->std, ce);
     object_properties_init(&request->std, ce);
     request->std.handlers = &swoole_http_request_handlers;

swoole_http_response.cc

@@ -164,7 +164,7 @@ static void php_swoole_http_response_free_object(zend_object *object)
 
 static zend_object *php_swoole_http_response_create_object(zend_class_entry *ce)
 {
-    http_response_t *response = (http_response_t *) ecalloc(1, sizeof(http_response_t) + zend_object_properties_size(ce));
+    http_response_t *response = (http_response_t *) zend_object_alloc(sizeof(http_response_t), ce);
     zend_object_std_init(&response->std, ce);
     object_properties_init(&response->std, ce);
     response->std.handlers = &swoole_http_response_handlers;

swoole_http_server_coro.cc

@@ -233,7 +233,7 @@ static const zend_function_entry swoole_http_server_coro_methods[] =
 
 static zend_object *php_swoole_http_server_coro_create_object(zend_class_entry *ce)
 {
-    http_server_coro_t *hsc = (http_server_coro_t *) ecalloc(1, sizeof(http_server_coro_t) + zend_object_properties_size(ce));
+    http_server_coro_t *hsc = (http_server_coro_t *) zend_object_alloc(sizeof(http_server_coro_t), ce);
     zend_object_std_init(&hsc->std, ce);
     object_properties_init(&hsc->std, ce);
     hsc->std.handlers = &swoole_http_server_coro_handlers;

swoole_lock.cc

@@ -57,7 +57,7 @@ static void php_swoole_lock_free_object(zend_object *object)
 
 static zend_object *php_swoole_lock_create_object(zend_class_entry *ce)
 {
-    lock_t *lock = (lock_t *) ecalloc(1, sizeof(lock_t) + zend_object_properties_size(ce));
+    lock_t *lock = (lock_t *) zend_object_alloc(sizeof(lock_t), ce);
     zend_object_std_init(&lock->std, ce);
     object_properties_init(&lock->std, ce);
     lock->std.handlers = &swoole_lock_handlers;

swoole_mysql_coro.cc

@@ -1824,7 +1824,7 @@ static void php_swoole_mysql_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_mysql_coro_create_object(zend_class_entry *ce)
 {
-    mysql_coro_t *zmc = (mysql_coro_t *) ecalloc(1, sizeof(mysql_coro_t) + zend_object_properties_size(ce));
+    mysql_coro_t *zmc = (mysql_coro_t *) zend_object_alloc(sizeof(mysql_coro_t), ce);
     zend_object_std_init(&zmc->std, ce);
     object_properties_init(&zmc->std, ce);
     zmc->std.handlers = &swoole_mysql_coro_handlers;
@@ -1853,7 +1853,7 @@ static void php_swoole_mysql_coro_statement_free_object(zend_object *object)
 static sw_inline zend_object* php_swoole_mysql_coro_statement_create_object(zend_class_entry *ce, mysql_statement *statement, zend_object *client)
 {
     zval zobject;
-    mysql_coro_statement_t *zms = (mysql_coro_statement_t *) ecalloc(1, sizeof(mysql_coro_statement_t) + zend_object_properties_size(ce));
+    mysql_coro_statement_t *zms = (mysql_coro_statement_t *) zend_object_alloc(sizeof(mysql_coro_statement_t), ce);
     zend_object_std_init(&zms->std, ce);
     object_properties_init(&zms->std, ce);
     zms->std.handlers = &swoole_mysql_coro_statement_handlers;

swoole_process.cc

@@ -91,7 +91,7 @@ static void php_swoole_process_free_object(zend_object *object)
 
 static zend_object *php_swoole_process_create_object(zend_class_entry *ce)
 {
-    process_t *process = (process_t *) ecalloc(1, sizeof(process_t) + zend_object_properties_size(ce));
+    process_t *process = (process_t *) zend_object_alloc(sizeof(process_t), ce);
     zend_object_std_init(&process->std, ce);
     object_properties_init(&process->std, ce);
     process->std.handlers = &swoole_process_handlers;

swoole_process_pool.cc

@@ -125,7 +125,7 @@ static void php_swoole_process_pool_free_object(zend_object *object)
 
 static zend_object *php_swoole_process_pool_create_object(zend_class_entry *ce)
 {
-    process_pool_t *process_pool = (process_pool_t *) ecalloc(1, sizeof(process_pool_t) + zend_object_properties_size(ce));
+    process_pool_t *process_pool = (process_pool_t *) zend_object_alloc(sizeof(process_pool_t), ce);
     zend_object_std_init(&process_pool->std, ce);
     object_properties_init(&process_pool->std, ce);
     process_pool->std.handlers = &swoole_process_pool_handlers;

swoole_redis_coro.cc

@@ -992,7 +992,7 @@ static void php_swoole_redis_coro_free_object(zend_object *object)
 
 static zend_object *php_swoole_redis_coro_create_object(zend_class_entry *ce)
 {
-    swRedisClient *redis = (swRedisClient *) ecalloc(1, sizeof(swRedisClient) + zend_object_properties_size(ce));
+    swRedisClient *redis = (swRedisClient *) zend_object_alloc(sizeof(swRedisClient), ce);
     zend_object_std_init(&redis->std, ce);
     object_properties_init(&redis->std, ce);
     redis->std.handlers = &swoole_redis_coro_handlers;

swoole_server.cc

@@ -261,7 +261,7 @@ static void php_swoole_server_free_object(zend_object *object)
 
 static zend_object *php_swoole_server_create_object(zend_class_entry *ce)
 {
-    server_t *server = (server_t *) ecalloc(1, sizeof(server_t) + zend_object_properties_size(ce));
+    server_t *server = (server_t *) zend_object_alloc(sizeof(server_t), ce);
     zend_object_std_init(&server->std, ce);
     object_properties_init(&server->std, ce);
     server->std.handlers = &swoole_server_handlers;
@@ -301,7 +301,7 @@ static void php_swoole_connection_iterator_free_object(zend_object *object)
 
 static zend_object *php_swoole_connection_iterator_create_object(zend_class_entry *ce)
 {
-    connection_iterator_t *connection = (connection_iterator_t *) ecalloc(1, sizeof(connection_iterator_t) + zend_object_properties_size(ce));
+    connection_iterator_t *connection = (connection_iterator_t *) zend_object_alloc(sizeof(connection_iterator_t), ce);
     zend_object_std_init(&connection->std, ce);
     object_properties_init(&connection->std, ce);
     connection->std.handlers = &swoole_connection_iterator_handlers;
@@ -357,7 +357,7 @@ static void php_swoole_server_task_free_object(zend_object *object)
 
 static zend_object *php_swoole_server_task_create_object(zend_class_entry *ce)
 {
-    server_task_t *server_task = (server_task_t *) ecalloc(1, sizeof(server_task_t) + zend_object_properties_size(ce));
+    server_task_t *server_task = (server_task_t *) zend_object_alloc(sizeof(server_task_t), ce);
     zend_object_std_init(&server_task->std, ce);
     object_properties_init(&server_task->std, ce);
     server_task->std.handlers = &swoole_server_task_handlers;

swoole_server_port.cc

@@ -120,7 +120,7 @@ static void php_swoole_server_port_free_object(zend_object *object)
 
 static zend_object *php_swoole_server_port_create_object(zend_class_entry *ce)
 {
-    server_port_t *server_port = (server_port_t *) ecalloc(1, sizeof(server_port_t) + zend_object_properties_size(ce));
+    server_port_t *server_port = (server_port_t *) zend_object_alloc(sizeof(server_port_t), ce);
     zend_object_std_init(&server_port->std, ce);
     object_properties_init(&server_port->std, ce);
     server_port->std.handlers = &swoole_server_port_handlers;

swoole_socket_coro.cc

@@ -216,7 +216,7 @@ static void php_swoole_socket_coro_free_object(zend_object *object)
 
 static zend_object* php_swoole_socket_coro_create_object(zend_class_entry *ce)
 {
-    socket_coro *sock = (socket_coro *) ecalloc(1, sizeof(socket_coro) + zend_object_properties_size(ce));
+    socket_coro *sock = (socket_coro *) zend_object_alloc(sizeof(socket_coro), ce);
     zend_object_std_init(&sock->std, ce);
     /* Even if you don't use properties yourself you should still call object_properties_init(),
      * because extending classes may use properties. (Generally a lot of the stuff you will do is

swoole_table.cc

@@ -163,7 +163,7 @@ static inline void php_swoole_table_free_object(zend_object *object)
 
 static inline zend_object *php_swoole_table_create_object(zend_class_entry *ce)
 {
-    table_t *table = (table_t *) ecalloc(1, sizeof(table_t) + zend_object_properties_size(ce));
+    table_t *table = (table_t *) zend_object_alloc(sizeof(table_t), ce);
     zend_object_std_init(&table->std, ce);
     object_properties_init(&table->std, ce);
     table->std.handlers = &swoole_table_handlers;
@@ -208,7 +208,7 @@ static inline void php_swoole_table_row_free_object(zend_object *object)
 
 static inline zend_object *php_swoole_table_row_create_object(zend_class_entry *ce)
 {
-    table_row_t *table_row = (table_row_t *) ecalloc(1, sizeof(table_row_t) + zend_object_properties_size(ce));
+    table_row_t *table_row = (table_row_t *) zend_object_alloc(sizeof(table_row_t), ce);
     zend_object_std_init(&table_row->std, ce);
     object_properties_init(&table_row->std, ce);
     table_row->std.handlers = &swoole_table_row_handlers;