summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--php-pecl-rdkafka4.spec14
-rw-r--r--rdkafka-php8.patch7683
2 files changed, 7695 insertions, 2 deletions
diff --git a/php-pecl-rdkafka4.spec b/php-pecl-rdkafka4.spec
index 5f7b6de..2845f50 100644
--- a/php-pecl-rdkafka4.spec
+++ b/php-pecl-rdkafka4.spec
@@ -21,14 +21,17 @@
Summary: Kafka client based on librdkafka
Name: %{?sub_prefix}php-pecl-%{pecl_name}4
Version: 4.1.0
-Release: 1%{?dist}%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')}
+Release: 2%{?dist}%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')}
License: MIT
URL: https://pecl.php.net/package/%{pecl_name}
Source0: https://pecl.php.net/get/%{pecl_name}-%{version}.tgz
+Patch0: %{pecl_name}-php8.patch
+
BuildRequires: %{?dtsprefix}gcc
+BuildRequires: make
BuildRequires: librdkafka1php-devel
-BuildRequires: %{?scl_prefix}php-devel > 5.6
+BuildRequires: %{?scl_prefix}php-devel >= 5.6
BuildRequires: %{?scl_prefix}php-pear
Requires: %{?scl_prefix}php(zend-abi) = %{php_zend_api}
@@ -84,6 +87,10 @@ sed -e 's/role="test"/role="src"/' \
-i package.xml
cd NTS
+%if "%{php_version}" > "8.0"
+%patch0 -p1 -b .up
+%endif
+
# Sanity check, really often broken
extver=$(sed -n '/#define PHP_RDKAFKA_VERSION/{s/.* "//;s/".*$//;p}' php_rdkafka.h)
if test "x${extver}" != "x%{version}"; then
@@ -198,6 +205,9 @@ cd ../ZTS
%changelog
+* Mon Dec 7 2020 Remi Collet <remi@remirepo.net> - 4.1.0-2
+- add upstream patches for PHP 8
+
* Mon Dec 7 2020 Remi Collet <remi@remirepo.net> - 4.1.0-1
- update to 4.1.0
diff --git a/rdkafka-php8.patch b/rdkafka-php8.patch
new file mode 100644
index 0000000..dcb7e0e
--- /dev/null
+++ b/rdkafka-php8.patch
@@ -0,0 +1,7683 @@
+From a1cf352a1688097dbe2a755a05c05ee9e29ea7c4 Mon Sep 17 00:00:00 2001
+From: Arnaud Le Blanc <arnaud.lb@gmail.com>
+Date: Mon, 7 Dec 2020 10:59:39 +0100
+Subject: [PATCH] Drop TSRMLS (#401)
+
+Co-authored-by: nick <nickjobszh@gmail.com>
+---
+ conf.c | 148 +++++++++++-----------
+ conf.h | 8 +-
+ fun.c | 8 +-
+ kafka_consumer.c | 166 ++++++++++++-------------
+ kafka_consumer.h | 2 +-
+ kafka_error_exception.c | 56 ++++-----
+ kafka_error_exception.h | 4 +-
+ message.c | 54 ++++----
+ message.h | 6 +-
+ metadata.c | 56 ++++-----
+ metadata.h | 4 +-
+ metadata_broker.c | 30 ++---
+ metadata_broker.h | 4 +-
+ metadata_collection.c | 46 +++----
+ metadata_collection.h | 6 +-
+ metadata_partition.c | 40 +++---
+ metadata_partition.h | 4 +-
+ metadata_topic.c | 38 +++---
+ metadata_topic.h | 4 +-
+ php_rdkafka_priv.h | 30 ++---
+ queue.c | 26 ++--
+ queue.h | 4 +-
+ rdkafka.c | 176 +++++++++++++--------------
+ tests/conf_setDefaultTopicConf8.phpt | 38 ++++++
+ topic.c | 124 +++++++++----------
+ topic.h | 4 +-
+ topic_partition.c | 70 +++++------
+ topic_partition.h | 10 +-
+ 28 files changed, 602 insertions(+), 564 deletions(-)
+ create mode 100644 tests/conf_setDefaultTopicConf8.phpt
+
+diff --git a/conf.c b/conf.c
+index 2e4fe99..69d1863 100644
+--- a/conf.c
++++ b/conf.c
+@@ -38,7 +38,7 @@ zend_class_entry * ce_kafka_topic_conf;
+
+ static zend_object_handlers handlers;
+
+-static void kafka_conf_callback_dtor(kafka_conf_callback *cb TSRMLS_DC) /* {{{ */
++static void kafka_conf_callback_dtor(kafka_conf_callback *cb) /* {{{ */
+ {
+ if (cb) {
+ zval_ptr_dtor(&cb->fci.function_name);
+@@ -46,25 +46,25 @@ static void kafka_conf_callback_dtor(kafka_conf_callback *cb TSRMLS_DC) /* {{{ *
+ }
+ } /* }}} */
+
+-void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs TSRMLS_DC) /* {{{ */
++void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs) /* {{{ */
+ {
+- kafka_conf_callback_dtor(cbs->error TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->error);
+ cbs->error = NULL;
+- kafka_conf_callback_dtor(cbs->rebalance TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->rebalance);
+ cbs->rebalance = NULL;
+- kafka_conf_callback_dtor(cbs->dr_msg TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->dr_msg);
+ cbs->dr_msg = NULL;
+- kafka_conf_callback_dtor(cbs->stats TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->stats);
+ cbs->stats = NULL;
+- kafka_conf_callback_dtor(cbs->consume TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->consume);
+ cbs->consume = NULL;
+- kafka_conf_callback_dtor(cbs->offset_commit TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->offset_commit);
+ cbs->offset_commit = NULL;
+- kafka_conf_callback_dtor(cbs->log TSRMLS_CC);
++ kafka_conf_callback_dtor(cbs->log);
+ cbs->log = NULL;
+ } /* }}} */
+
+-static void kafka_conf_callback_copy(kafka_conf_callback **to, kafka_conf_callback *from TSRMLS_DC) /* {{{ */
++static void kafka_conf_callback_copy(kafka_conf_callback **to, kafka_conf_callback *from) /* {{{ */
+ {
+ if (from) {
+ *to = emalloc(sizeof(**to));
+@@ -77,18 +77,18 @@ static void kafka_conf_callback_copy(kafka_conf_callback **to, kafka_conf_callba
+ }
+ } /* }}} */
+
+-void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from TSRMLS_DC) /* {{{ */
++void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from) /* {{{ */
+ {
+- kafka_conf_callback_copy(&to->error, from->error TSRMLS_CC);
+- kafka_conf_callback_copy(&to->rebalance, from->rebalance TSRMLS_CC);
+- kafka_conf_callback_copy(&to->dr_msg, from->dr_msg TSRMLS_CC);
+- kafka_conf_callback_copy(&to->stats, from->stats TSRMLS_CC);
+- kafka_conf_callback_copy(&to->consume, from->consume TSRMLS_CC);
+- kafka_conf_callback_copy(&to->offset_commit, from->offset_commit TSRMLS_CC);
+- kafka_conf_callback_copy(&to->log, from->log TSRMLS_CC);
++ kafka_conf_callback_copy(&to->error, from->error);
++ kafka_conf_callback_copy(&to->rebalance, from->rebalance);
++ kafka_conf_callback_copy(&to->dr_msg, from->dr_msg);
++ kafka_conf_callback_copy(&to->stats, from->stats);
++ kafka_conf_callback_copy(&to->consume, from->consume);
++ kafka_conf_callback_copy(&to->offset_commit, from->offset_commit);
++ kafka_conf_callback_copy(&to->log, from->log);
+ } /* }}} */
+
+-static void kafka_conf_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_conf_free(zend_object *object) /* {{{ */
+ {
+ kafka_conf_object *intern = get_custom_object(kafka_conf_object, object);
+
+@@ -97,7 +97,7 @@ static void kafka_conf_free(zend_object *object TSRMLS_DC) /* {{{ */
+ if (intern->u.conf) {
+ rd_kafka_conf_destroy(intern->u.conf);
+ }
+- kafka_conf_callbacks_dtor(&intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_dtor(&intern->cbs);
+ break;
+ case KAFKA_TOPIC_CONF:
+ if (intern->u.topic_conf) {
+@@ -106,19 +106,19 @@ static void kafka_conf_free(zend_object *object TSRMLS_DC) /* {{{ */
+ break;
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_conf_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_conf_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ kafka_conf_object *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_conf_free, NULL);
+@@ -128,12 +128,12 @@ static zend_object_value kafka_conf_new(zend_class_entry *class_type TSRMLS_DC)
+ }
+ /* }}} */
+
+-kafka_conf_object * get_kafka_conf_object(zval *zconf TSRMLS_DC)
++kafka_conf_object * get_kafka_conf_object(zval *zconf)
+ {
+ kafka_conf_object *oconf = get_custom_object_zval(kafka_conf_object, zconf);
+
+ if (!oconf->type) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Conf::__construct() has not been called" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Conf::__construct() has not been called");
+ return NULL;
+ }
+
+@@ -162,7 +162,7 @@ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, voi
+ ZVAL_LONG(P_ZEVAL(args[1]), err);
+ RDKAFKA_ZVAL_STRING(P_ZEVAL(args[2]), reason);
+
+- rdkafka_call_function(&cbs->error->fci, &cbs->error->fcc, NULL, 3, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->error->fci, &cbs->error->fcc, NULL, 3, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -187,9 +187,9 @@ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
+ MAKE_STD_ZEVAL(args[1]);
+
+ KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- kafka_message_new(P_ZEVAL(args[1]), msg TSRMLS_CC);
++ kafka_message_new(P_ZEVAL(args[1]), msg);
+
+- rdkafka_call_function(&cbs->dr_msg->fci, &cbs->dr_msg->fcc, NULL, 2, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->dr_msg->fci, &cbs->dr_msg->fcc, NULL, 2, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -217,7 +217,7 @@ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void
+ RDKAFKA_ZVAL_STRING(P_ZEVAL(args[1]), json);
+ ZVAL_LONG(P_ZEVAL(args[2]), json_len);
+
+- rdkafka_call_function(&cbs->stats->fci, &cbs->stats->fcc, NULL, 3, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->stats->fci, &cbs->stats->fcc, NULL, 3, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -240,7 +240,7 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+ err = rd_kafka_assign(rk, NULL);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -253,9 +253,9 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+
+ KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+ ZVAL_LONG(P_ZEVAL(args[1]), err);
+- kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions TSRMLS_CC);
++ kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions);
+
+- rdkafka_call_function(&cbs->rebalance->fci, &cbs->rebalance->fcc, NULL, 3, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->rebalance->fci, &cbs->rebalance->fcc, NULL, 3, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -279,11 +279,11 @@ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ MAKE_STD_ZEVAL(args[0]);
+ MAKE_STD_ZEVAL(args[1]);
+
+- kafka_message_new(P_ZEVAL(args[0]), msg TSRMLS_CC);
++ kafka_message_new(P_ZEVAL(args[0]), msg);
+ KAFKA_ZVAL_ZVAL(P_ZEVAL(args[1]), &cbs->zrk, 1, 0);
+
+
+- rdkafka_call_function(&cbs->consume->fci, &cbs->consume->fcc, NULL, 2, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->consume->fci, &cbs->consume->fcc, NULL, 2, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -309,9 +309,9 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+
+ KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+ ZVAL_LONG(P_ZEVAL(args[1]), err);
+- kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions TSRMLS_CC);
++ kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions);
+
+- rdkafka_call_function(&cbs->offset_commit->fci, &cbs->offset_commit->fcc, NULL, 3, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->offset_commit->fci, &cbs->offset_commit->fcc, NULL, 3, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -339,7 +339,7 @@ static void kafka_conf_log_cb(const rd_kafka_t *rk, int level, const char *facil
+ RDKAFKA_ZVAL_STRING(P_ZEVAL(args[2]), facility);
+ RDKAFKA_ZVAL_STRING(P_ZEVAL(args[3]), message);
+
+- rdkafka_call_function(&cbs->log->fci, &cbs->log->fcc, NULL, 4, args TSRMLS_CC);
++ rdkafka_call_function(&cbs->log->fci, &cbs->log->fcc, NULL, 4, args);
+
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
+@@ -357,10 +357,10 @@ PHP_METHOD(RdKafka__Conf, __construct)
+ kafka_conf_object *intern;
+ zend_error_handling error_handling;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+@@ -368,7 +368,7 @@ PHP_METHOD(RdKafka__Conf, __construct)
+ intern->type = KAFKA_CONF;
+ intern->u.conf = rd_kafka_conf_new();
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -385,11 +385,11 @@ PHP_METHOD(RdKafka__Conf, dump)
+ kafka_conf_object *intern;
+ size_t i;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -435,11 +435,11 @@ PHP_METHOD(RdKafka__Conf, set)
+ rd_kafka_conf_res_t ret = 0;
+ char errstr[512];
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &value, &value_len) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name, &name_len, &value, &value_len) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -457,10 +457,10 @@ PHP_METHOD(RdKafka__Conf, set)
+
+ switch (ret) {
+ case RD_KAFKA_CONF_UNKNOWN:
+- zend_throw_exception(ce_kafka_exception, errstr, RD_KAFKA_CONF_UNKNOWN TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, errstr, RD_KAFKA_CONF_UNKNOWN);
+ return;
+ case RD_KAFKA_CONF_INVALID:
+- zend_throw_exception(ce_kafka_exception, errstr, RD_KAFKA_CONF_INVALID TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, errstr, RD_KAFKA_CONF_INVALID);
+ return;
+ case RD_KAFKA_CONF_OK:
+ break;
+@@ -481,16 +481,16 @@ PHP_METHOD(RdKafka__Conf, setDefaultTopicConf)
+ kafka_conf_object *topic_conf_intern;
+ rd_kafka_topic_conf_t *topic_conf;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &ztopic_conf, ce_kafka_topic_conf) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &ztopic_conf, ce_kafka_topic_conf) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topic_conf_intern = get_kafka_conf_object(ztopic_conf TSRMLS_CC);
++ topic_conf_intern = get_kafka_conf_object(ztopic_conf);
+ if (!topic_conf_intern) {
+ return;
+ }
+@@ -514,11 +514,11 @@ PHP_METHOD(RdKafka__Conf, setErrorCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -551,11 +551,11 @@ PHP_METHOD(RdKafka__Conf, setDrMsgCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -588,11 +588,11 @@ PHP_METHOD(RdKafka__Conf, setStatsCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -625,11 +625,11 @@ PHP_METHOD(RdKafka__Conf, setRebalanceCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -662,11 +662,11 @@ PHP_METHOD(RdKafka__Conf, setConsumeCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -699,11 +699,11 @@ PHP_METHOD(RdKafka__Conf, setOffsetCommitCb)
+ zend_fcall_info_cache fcc;
+ kafka_conf_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -737,11 +737,11 @@ PHP_METHOD(RdKafka__Conf, setLogCb)
+ kafka_conf_object *conf;
+ char errstr[512];
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &fci, &fcc) == FAILURE) {
+ return;
+ }
+
+- conf = get_kafka_conf_object(getThis() TSRMLS_CC);
++ conf = get_kafka_conf_object(getThis());
+ if (!conf) {
+ return;
+ }
+@@ -768,10 +768,10 @@ PHP_METHOD(RdKafka__TopicConf, __construct)
+ kafka_conf_object *intern;
+ zend_error_handling error_handling;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+@@ -779,7 +779,7 @@ PHP_METHOD(RdKafka__TopicConf, __construct)
+ intern->type = KAFKA_TOPIC_CONF;
+ intern->u.topic_conf = rd_kafka_topic_conf_new();
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -795,11 +795,11 @@ PHP_METHOD(RdKafka__TopicConf, setPartitioner)
+ zend_long id;
+ int32_t (*partitioner) (const rd_kafka_topic_t * rkt, const void * keydata, size_t keylen, int32_t partition_cnt, void * rkt_opaque, void * msg_opaque);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &id) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &id) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_conf_object(getThis() TSRMLS_CC);
++ intern = get_kafka_conf_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -823,7 +823,7 @@ PHP_METHOD(RdKafka__TopicConf, setPartitioner)
+ break;
+ #endif
+ default:
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Invalid partitioner given" TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Invalid partitioner given");
+ return;
+ }
+
+@@ -854,7 +854,7 @@ static const zend_function_entry kafka_conf_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_conf_minit(TSRMLS_D)
++void kafka_conf_minit()
+ {
+ zend_class_entry tmpce;
+
+@@ -863,10 +863,10 @@ void kafka_conf_minit(TSRMLS_D)
+ set_object_handler_offset(&handlers, XtOffsetOf(kafka_conf_object, std));
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "Conf", kafka_conf_fe);
+- ce_kafka_conf = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce_kafka_conf = zend_register_internal_class(&tmpce);
+ ce_kafka_conf->create_object = kafka_conf_new;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "TopicConf", kafka_topic_conf_fe);
+- ce_kafka_topic_conf = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce_kafka_topic_conf = zend_register_internal_class(&tmpce);
+ ce_kafka_topic_conf->create_object = kafka_conf_new;
+ }
+diff --git a/conf.h b/conf.h
+index 3ec6bcf..4bf13b2 100644
+--- a/conf.h
++++ b/conf.h
+@@ -63,11 +63,11 @@ typedef struct _kafka_conf_object {
+ #endif
+ } kafka_conf_object;
+
+-kafka_conf_object * get_kafka_conf_object(zval *zconf TSRMLS_DC);
+-void kafka_conf_minit(TSRMLS_D);
++kafka_conf_object * get_kafka_conf_object(zval *zconf);
++void kafka_conf_minit();
+
+-void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs TSRMLS_DC);
+-void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from TSRMLS_DC);
++void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs);
++void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from);
+
+ extern zend_class_entry * ce_kafka_conf;
+ extern zend_class_entry * ce_kafka_topic_conf;
+diff --git a/fun.c b/fun.c
+index b5231ce..ee21814 100644
+--- a/fun.c
++++ b/fun.c
+@@ -106,7 +106,7 @@ PHP_FUNCTION(rd_kafka_err2str)
+ zend_long err;
+ const char *errstr;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &err) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &err) == FAILURE) {
+ return;
+ }
+
+@@ -122,7 +122,7 @@ PHP_FUNCTION(rd_kafka_err2str)
+ * Returns `errno` */
+ PHP_FUNCTION(rd_kafka_errno)
+ {
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+@@ -136,7 +136,7 @@ PHP_FUNCTION(rd_kafka_errno2err)
+ {
+ zend_long errnox;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &errnox) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &errnox) == FAILURE) {
+ return;
+ }
+
+@@ -164,7 +164,7 @@ PHP_FUNCTION(rd_kafka_offset_tail)
+ {
+ zend_long cnt;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &cnt) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &cnt) == FAILURE) {
+ return;
+ }
+
+diff --git a/kafka_consumer.c b/kafka_consumer.c
+index 5ee209a..8b6c4c2 100644
+--- a/kafka_consumer.c
++++ b/kafka_consumer.c
+@@ -46,11 +46,11 @@ typedef struct _object_intern {
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void kafka_consumer_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_consumer_free(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+ rd_kafka_resp_err_t err;
+- kafka_conf_callbacks_dtor(&intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_dtor(&intern->cbs);
+
+ if (intern->rk) {
+ err = rd_kafka_consumer_close(intern->rk);
+@@ -63,21 +63,21 @@ static void kafka_consumer_free(zend_object *object TSRMLS_DC) /* {{{ */
+ intern->rk = NULL;
+ }
+
+- kafka_conf_callbacks_dtor(&intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_dtor(&intern->cbs);
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_consumer_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_consumer_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_consumer_free, NULL);
+@@ -87,12 +87,12 @@ static zend_object_value kafka_consumer_new(zend_class_entry *class_type TSRMLS_
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zconsumer TSRMLS_DC) /* {{{ */
++static object_intern * get_object(zval *zconsumer) /* {{{ */
+ {
+ object_intern *oconsumer = get_custom_object_zval(object_intern, zconsumer);
+
+ if (!oconsumer->rk) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\KafkaConsumer::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\KafkaConsumer::__construct() has not been called");
+ return NULL;
+ }
+
+@@ -134,19 +134,19 @@ PHP_METHOD(RdKafka__KafkaConsumer, __construct)
+ kafka_conf_object *conf_intern;
+ rd_kafka_conf_t *conf = NULL;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zconf, ce_kafka_conf) == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zconf, ce_kafka_conf) == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+ intern = get_custom_object_zval(object_intern, getThis());
+
+- conf_intern = get_kafka_conf_object(zconf TSRMLS_CC);
++ conf_intern = get_kafka_conf_object(zconf);
+ if (conf_intern) {
+ conf = rd_kafka_conf_dup(conf_intern->u.conf);
+- kafka_conf_callbacks_copy(&intern->cbs, &conf_intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_copy(&intern->cbs, &conf_intern->cbs);
+ intern->cbs.zrk = *getThis();
+ rd_kafka_conf_set_opaque(conf, &intern->cbs);
+ }
+@@ -155,15 +155,15 @@ PHP_METHOD(RdKafka__KafkaConsumer, __construct)
+ if (conf) {
+ rd_kafka_conf_destroy(conf);
+ }
+- zend_throw_exception(ce_kafka_exception, "\"group.id\" must be configured", 0 TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "\"group.id\" must be configured", 0);
+ return;
+ }
+
+ rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf, errstr, sizeof(errstr));
+
+ if (rk == NULL) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
+- zend_throw_exception(ce_kafka_exception, errstr, 0 TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
++ zend_throw_exception(ce_kafka_exception, errstr, 0);
+ return;
+ }
+
+@@ -175,7 +175,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, __construct)
+
+ rd_kafka_poll_set_consumer(rk);
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -193,17 +193,17 @@ PHP_METHOD(RdKafka__KafkaConsumer, assign)
+ rd_kafka_resp_err_t err;
+ object_intern *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|h!", &htopars) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "|h!", &htopars) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (htopars) {
+- topics = array_arg_to_kafka_topic_partition_list(1, htopars TSRMLS_CC);
++ topics = array_arg_to_kafka_topic_partition_list(1, htopars);
+ if (!topics) {
+ return;
+ }
+@@ -218,7 +218,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, assign)
+ }
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -236,11 +236,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, getAssignment)
+ rd_kafka_topic_partition_list_t *topics;
+ object_intern *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -248,11 +248,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, getAssignment)
+ err = rd_kafka_assignment(intern->rk, &topics);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+- kafka_topic_partition_list_to_array(return_value, topics TSRMLS_CC);
++ kafka_topic_partition_list_to_array(return_value, topics);
+ rd_kafka_topic_partition_list_destroy(topics);
+ }
+ /* }}} */
+@@ -273,11 +273,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, subscribe)
+ rd_kafka_resp_err_t err;
+ zeval *zv;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "h", &htopics) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &htopics) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -296,7 +296,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, subscribe)
+ rd_kafka_topic_partition_list_destroy(topics);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -315,11 +315,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, getSubscription)
+ object_intern *intern;
+ int i;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -327,7 +327,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, getSubscription)
+ err = rd_kafka_subscription(intern->rk, &topics);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -352,11 +352,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, unsubscribe)
+ object_intern *intern;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -364,7 +364,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, unsubscribe)
+ err = rd_kafka_unsubscribe(intern->rk);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -383,11 +383,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, consume)
+ zend_long timeout_ms;
+ rd_kafka_message_t *rkmessage, rkmessage_tmp = {0};
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -399,7 +399,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, consume)
+ rkmessage = &rkmessage_tmp;
+ }
+
+- kafka_message_new(return_value, rkmessage TSRMLS_CC);
++ kafka_message_new(return_value, rkmessage);
+
+ if (rkmessage != &rkmessage_tmp) {
+ rd_kafka_message_destroy(rkmessage);
+@@ -414,44 +414,44 @@ static void consumer_commit(int async, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
+ rd_kafka_topic_partition_list_t *offsets = NULL;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!", &zarg) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z!", &zarg) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (zarg) {
+- if (Z_TYPE_P(zarg) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zarg), ce_kafka_message TSRMLS_CC)) {
++ if (Z_TYPE_P(zarg) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zarg), ce_kafka_message)) {
+ zval *zerr;
+ zval *ztopic;
+ zval *zpartition;
+ zval *zoffset;
+ rd_kafka_topic_partition_t *rktpar;
+
+- zerr = rdkafka_read_property(NULL, zarg, ZEND_STRL("err"), 0 TSRMLS_CC);
++ zerr = rdkafka_read_property(NULL, zarg, ZEND_STRL("err"), 0);
+ if (zerr && Z_TYPE_P(zerr) != IS_NULL && (Z_TYPE_P(zerr) != IS_LONG || Z_LVAL_P(zerr) != RD_KAFKA_RESP_ERR_NO_ERROR)) {
+- zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message has an error", RD_KAFKA_RESP_ERR__INVALID_ARG TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message has an error", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- ztopic = rdkafka_read_property(NULL, zarg, ZEND_STRL("topic_name"), 0 TSRMLS_CC);
++ ztopic = rdkafka_read_property(NULL, zarg, ZEND_STRL("topic_name"), 0);
+ if (!ztopic || Z_TYPE_P(ztopic) != IS_STRING) {
+- zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's topic_name is not a string", RD_KAFKA_RESP_ERR__INVALID_ARG TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's topic_name is not a string", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- zpartition = rdkafka_read_property(NULL, zarg, ZEND_STRL("partition"), 0 TSRMLS_CC);
++ zpartition = rdkafka_read_property(NULL, zarg, ZEND_STRL("partition"), 0);
+ if (!zpartition || Z_TYPE_P(zpartition) != IS_LONG) {
+- zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's partition is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's partition is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- zoffset = rdkafka_read_property(NULL, zarg, ZEND_STRL("offset"), 0 TSRMLS_CC);
++ zoffset = rdkafka_read_property(NULL, zarg, ZEND_STRL("offset"), 0);
+ if (!zoffset || Z_TYPE_P(zoffset) != IS_LONG) {
+- zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's offset is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's offset is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+@@ -463,14 +463,14 @@ static void consumer_commit(int async, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
+
+ } else if (Z_TYPE_P(zarg) == IS_ARRAY) {
+ HashTable *ary = Z_ARRVAL_P(zarg);
+- offsets = array_arg_to_kafka_topic_partition_list(1, ary TSRMLS_CC);
++ offsets = array_arg_to_kafka_topic_partition_list(1, ary);
+ if (!offsets) {
+ return;
+ }
+ } else if (Z_TYPE_P(zarg) != IS_NULL) {
+ php_error(E_ERROR,
+ "RdKafka\\KafkaConsumer::%s() expects parameter %d to be %s, %s given",
+- get_active_function_name(TSRMLS_C),
++ get_active_function_name(),
+ 1,
+ "an instance of RdKafka\\Message or an array of RdKafka\\TopicPartition",
+ zend_zval_type_name(zarg));
+@@ -485,7 +485,7 @@ static void consumer_commit(int async, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
+ }
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -527,7 +527,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, close)
+ {
+ object_intern *intern;
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -555,17 +555,17 @@ PHP_METHOD(RdKafka__KafkaConsumer, getMetadata)
+ const rd_kafka_metadata_t *metadata;
+ kafka_topic_object *only_orkt = NULL;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "bO!l", &all_topics, &only_zrkt, ce_kafka_topic, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "bO!l", &all_topics, &only_zrkt, ce_kafka_topic, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (only_zrkt) {
+- only_orkt = get_kafka_topic_object(only_zrkt TSRMLS_CC);
++ only_orkt = get_kafka_topic_object(only_zrkt);
+ if (!only_orkt) {
+ return;
+ }
+@@ -574,11 +574,11 @@ PHP_METHOD(RdKafka__KafkaConsumer, getMetadata)
+ err = rd_kafka_metadata(intern->rk, all_topics, only_orkt ? only_orkt->rkt : NULL, &metadata, timeout_ms);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+- kafka_metadata_init(return_value, metadata TSRMLS_CC);
++ kafka_metadata_init(return_value, metadata);
+ }
+ /* }}} */
+
+@@ -601,17 +601,17 @@ PHP_METHOD(RdKafka__KafkaConsumer, newTopic)
+ rd_kafka_topic_conf_t *conf = NULL;
+ kafka_conf_object *conf_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|O!", &topic, &topic_len, &zconf, ce_kafka_topic_conf) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|O!", &topic, &topic_len, &zconf, ce_kafka_topic_conf) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (zconf) {
+- conf_intern = get_kafka_conf_object(zconf TSRMLS_CC);
++ conf_intern = get_kafka_conf_object(zconf);
+ if (conf_intern) {
+ conf = rd_kafka_topic_conf_dup(conf_intern->u.topic_conf);
+ }
+@@ -652,16 +652,16 @@ PHP_METHOD(RdKafka__KafkaConsumer, getCommittedOffsets)
+ rd_kafka_resp_err_t err;
+ rd_kafka_topic_partition_list_t *topics;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hl", &htopars, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "hl", &htopars, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topics = array_arg_to_kafka_topic_partition_list(1, htopars TSRMLS_CC);
++ topics = array_arg_to_kafka_topic_partition_list(1, htopars);
+ if (!topics) {
+ return;
+ }
+@@ -670,10 +670,10 @@ PHP_METHOD(RdKafka__KafkaConsumer, getCommittedOffsets)
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ rd_kafka_topic_partition_list_destroy(topics);
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+- kafka_topic_partition_list_to_array(return_value, topics TSRMLS_CC);
++ kafka_topic_partition_list_to_array(return_value, topics);
+ rd_kafka_topic_partition_list_destroy(topics);
+ }
+ /* }}} */
+@@ -694,16 +694,16 @@ PHP_METHOD(RdKafka__KafkaConsumer, getOffsetPositions)
+ rd_kafka_resp_err_t err;
+ rd_kafka_topic_partition_list_t *topics;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "h", &htopars) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &htopars) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topics = array_arg_to_kafka_topic_partition_list(1, htopars TSRMLS_CC);
++ topics = array_arg_to_kafka_topic_partition_list(1, htopars);
+ if (!topics) {
+ return;
+ }
+@@ -712,10 +712,10 @@ PHP_METHOD(RdKafka__KafkaConsumer, getOffsetPositions)
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ rd_kafka_topic_partition_list_destroy(topics);
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+- kafka_topic_partition_list_to_array(return_value, topics TSRMLS_CC);
++ kafka_topic_partition_list_to_array(return_value, topics);
+ rd_kafka_topic_partition_list_destroy(topics);
+ }
+ /* }}} */
+@@ -734,16 +734,16 @@ PHP_METHOD(RdKafka__KafkaConsumer, offsetsForTimes)
+ zend_long timeout_ms;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hl", &htopars, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "hl", &htopars, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topicPartitions = array_arg_to_kafka_topic_partition_list(1, htopars TSRMLS_CC);
++ topicPartitions = array_arg_to_kafka_topic_partition_list(1, htopars);
+ if (!topicPartitions) {
+ return;
+ }
+@@ -752,10 +752,10 @@ PHP_METHOD(RdKafka__KafkaConsumer, offsetsForTimes)
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ rd_kafka_topic_partition_list_destroy(topicPartitions);
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+- kafka_topic_partition_list_to_array(return_value, topicPartitions TSRMLS_CC);
++ kafka_topic_partition_list_to_array(return_value, topicPartitions);
+ rd_kafka_topic_partition_list_destroy(topicPartitions);
+ }
+ /* }}} */
+@@ -781,14 +781,14 @@ PHP_METHOD(RdKafka__KafkaConsumer, queryWatermarkOffsets)
+ zval *lowResult, *highResult;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slzzl", &topic, &topic_length, &partition, &lowResult, &highResult, &timeout) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "slzzl", &topic, &topic_length, &partition, &lowResult, &highResult, &timeout) == FAILURE) {
+ return;
+ }
+
+ ZEVAL_DEREF(lowResult);
+ ZEVAL_DEREF(highResult);
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -796,7 +796,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, queryWatermarkOffsets)
+ err = rd_kafka_query_watermark_offsets(intern->rk, topic, partition, &low, &high, timeout);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -825,19 +825,19 @@ static const zend_function_entry fe[] = { /* {{{ */
+ PHP_FE_END
+ }; /* }}} */
+
+-void kafka_kafka_consumer_minit(TSRMLS_D) /* {{{ */
++void kafka_kafka_consumer_minit() /* {{{ */
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "KafkaConsumer", fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = kafka_consumer_new;
+
+ handlers = kafka_default_object_handlers;
+ set_object_handler_free_obj(&handlers, kafka_consumer_free);
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+
+- zend_declare_property_null(ce, ZEND_STRL("error_cb"), ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_null(ce, ZEND_STRL("rebalance_cb"), ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_null(ce, ZEND_STRL("dr_msg_cb"), ZEND_ACC_PRIVATE TSRMLS_CC);
++ zend_declare_property_null(ce, ZEND_STRL("error_cb"), ZEND_ACC_PRIVATE);
++ zend_declare_property_null(ce, ZEND_STRL("rebalance_cb"), ZEND_ACC_PRIVATE);
++ zend_declare_property_null(ce, ZEND_STRL("dr_msg_cb"), ZEND_ACC_PRIVATE);
+ } /* }}} */
+diff --git a/kafka_consumer.h b/kafka_consumer.h
+index 6e86784..0ac97f3 100644
+--- a/kafka_consumer.h
++++ b/kafka_consumer.h
+@@ -16,4 +16,4 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_kafka_consumer_minit(TSRMLS_D);
++void kafka_kafka_consumer_minit();
+diff --git a/kafka_error_exception.c b/kafka_error_exception.c
+index ee1f8b5..ea3bdba 100644
+--- a/kafka_error_exception.c
++++ b/kafka_error_exception.c
+@@ -30,16 +30,16 @@
+
+ zend_class_entry * ce_kafka_error;
+
+-void create_kafka_error(zval *return_value, const rd_kafka_error_t *error TSRMLS_DC) /* {{{ */
++void create_kafka_error(zval *return_value, const rd_kafka_error_t *error) /* {{{ */
+ {
+ object_init_ex(return_value, ce_kafka_error);
+
+- zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("message"), rd_kafka_error_name(error) TSRMLS_CC);
+- zend_update_property_long(ce_kafka_error, return_value, ZEND_STRL("code"), rd_kafka_error_code(error) TSRMLS_CC);
+- zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("error_string"), rd_kafka_error_string(error) TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isFatal"), rd_kafka_error_is_fatal(error) TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isRetriable"), rd_kafka_error_is_retriable(error) TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("transactionRequiresAbort"), rd_kafka_error_txn_requires_abort(error) TSRMLS_CC);
++ zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("message"), rd_kafka_error_name(error));
++ zend_update_property_long(ce_kafka_error, return_value, ZEND_STRL("code"), rd_kafka_error_code(error));
++ zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("error_string"), rd_kafka_error_string(error));
++ zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isFatal"), rd_kafka_error_is_fatal(error));
++ zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isRetriable"), rd_kafka_error_is_retriable(error));
++ zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("transactionRequiresAbort"), rd_kafka_error_txn_requires_abort(error));
+
+ Z_ADDREF_P(return_value);
+ }
+@@ -62,16 +62,16 @@ PHP_METHOD(RdKafka__KafkaErrorException, __construct)
+ zend_bool isFatal = 0, isRetriable = 0, transactionRequiresAbort = 0;
+ zend_long code = 0;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|sbbb", &message, &message_length, &code, &error_string, &error_string_length, &isFatal, &isRetriable, &transactionRequiresAbort) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|sbbb", &message, &message_length, &code, &error_string, &error_string_length, &isFatal, &isRetriable, &transactionRequiresAbort) == FAILURE) {
+ return;
+ }
+
+- zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("message"), message TSRMLS_CC);
+- zend_update_property_long(ce_kafka_error, getThis(), ZEND_STRL("code"), code TSRMLS_CC);
+- zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("error_string"), error_string TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), isFatal TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), isRetriable TSRMLS_CC);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), transactionRequiresAbort TSRMLS_CC);
++ zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("message"), message);
++ zend_update_property_long(ce_kafka_error, getThis(), ZEND_STRL("code"), code);
++ zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("error_string"), error_string);
++ zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), isFatal);
++ zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), isRetriable);
++ zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), transactionRequiresAbort);
+ }
+ /* }}} */
+
+@@ -85,11 +85,11 @@ PHP_METHOD(RdKafka__KafkaErrorException, getErrorString)
+ {
+ zval *res;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("error_string"), 0 TSRMLS_CC);
++ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("error_string"), 0);
+
+ if (!res || Z_TYPE_P(res) != IS_STRING) {
+ return;
+@@ -115,11 +115,11 @@ PHP_METHOD(RdKafka__KafkaErrorException, isFatal)
+ {
+ zval *res;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), 0 TSRMLS_CC);
++ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), 0);
+
+ #if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+@@ -144,11 +144,11 @@ PHP_METHOD(RdKafka__KafkaErrorException, isRetriable)
+ {
+ zval *res;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), 0 TSRMLS_CC);
++ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), 0);
+
+ #if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+@@ -173,11 +173,11 @@ PHP_METHOD(RdKafka__KafkaErrorException, transactionRequiresAbort)
+ {
+ zval *res;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), 0 TSRMLS_CC);
++ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), 0);
+
+ #if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+@@ -201,15 +201,15 @@ static const zend_function_entry kafka_error_fe[] = { /* {{{ */
+ PHP_FE_END
+ }; /* }}} */
+
+-void kafka_error_minit(TSRMLS_D) /* {{{ */
++void kafka_error_minit() /* {{{ */
+ {
+ zend_class_entry ce;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaErrorException", kafka_error_fe);
+- ce_kafka_error = rdkafka_register_internal_class_ex(&ce, ce_kafka_exception TSRMLS_CC);
++ ce_kafka_error = rdkafka_register_internal_class_ex(&ce, ce_kafka_exception);
+
+- zend_declare_property_null(ce_kafka_error, ZEND_STRL("error_string"), ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_bool(ce_kafka_error, ZEND_STRL("isFatal"), 0, ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_bool(ce_kafka_error, ZEND_STRL("isRetriable"), 0, ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_bool(ce_kafka_error, ZEND_STRL("transactionRequiresAbort"), 0, ZEND_ACC_PRIVATE TSRMLS_CC);
++ zend_declare_property_null(ce_kafka_error, ZEND_STRL("error_string"), ZEND_ACC_PRIVATE);
++ zend_declare_property_bool(ce_kafka_error, ZEND_STRL("isFatal"), 0, ZEND_ACC_PRIVATE);
++ zend_declare_property_bool(ce_kafka_error, ZEND_STRL("isRetriable"), 0, ZEND_ACC_PRIVATE);
++ zend_declare_property_bool(ce_kafka_error, ZEND_STRL("transactionRequiresAbort"), 0, ZEND_ACC_PRIVATE);
+ } /* }}} */
+diff --git a/kafka_error_exception.h b/kafka_error_exception.h
+index 71ad2f3..12068a6 100644
+--- a/kafka_error_exception.h
++++ b/kafka_error_exception.h
+@@ -20,6 +20,6 @@
+ #include "zeval.h"
+ #include "librdkafka/rdkafka.h"
+ extern zend_class_entry * ce_kafka_error;
+-void kafka_error_minit(TSRMLS_D);
+-void create_kafka_error(zval *return_value, const rd_kafka_error_t *error TSRMLS_DC);
++void kafka_error_minit();
++void create_kafka_error(zval *return_value, const rd_kafka_error_t *error);
+ #endif
+diff --git a/message.c b/message.c
+index f3911f9..c09bc26 100644
+--- a/message.c
++++ b/message.c
+@@ -32,7 +32,7 @@
+
+ zend_class_entry * ce_kafka_message;
+
+-void kafka_message_new(zval *return_value, const rd_kafka_message_t *message TSRMLS_DC)
++void kafka_message_new(zval *return_value, const rd_kafka_message_t *message)
+ {
+ object_init_ex(return_value, ce_kafka_message);
+
+@@ -51,21 +51,21 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message TSR
+ uint i;
+ #endif /* HAVE_RD_KAFKA_MESSAGE_HEADERS */
+
+- zend_update_property_long(NULL, return_value, ZEND_STRL("err"), message->err TSRMLS_CC);
++ zend_update_property_long(NULL, return_value, ZEND_STRL("err"), message->err);
+
+ if (message->rkt) {
+- zend_update_property_string(NULL, return_value, ZEND_STRL("topic_name"), rd_kafka_topic_name(message->rkt) TSRMLS_CC);
++ zend_update_property_string(NULL, return_value, ZEND_STRL("topic_name"), rd_kafka_topic_name(message->rkt));
+ }
+- zend_update_property_long(NULL, return_value, ZEND_STRL("partition"), message->partition TSRMLS_CC);
++ zend_update_property_long(NULL, return_value, ZEND_STRL("partition"), message->partition);
+ if (message->payload) {
+- zend_update_property_long(NULL, return_value, ZEND_STRL("timestamp"), timestamp TSRMLS_CC);
+- zend_update_property_stringl(NULL, return_value, ZEND_STRL("payload"), message->payload, message->len TSRMLS_CC);
+- zend_update_property_long(NULL, return_value, ZEND_STRL("len"), message->len TSRMLS_CC);
++ zend_update_property_long(NULL, return_value, ZEND_STRL("timestamp"), timestamp);
++ zend_update_property_stringl(NULL, return_value, ZEND_STRL("payload"), message->payload, message->len);
++ zend_update_property_long(NULL, return_value, ZEND_STRL("len"), message->len);
+ }
+ if (message->key) {
+- zend_update_property_stringl(NULL, return_value, ZEND_STRL("key"), message->key, message->key_len TSRMLS_CC);
++ zend_update_property_stringl(NULL, return_value, ZEND_STRL("key"), message->key, message->key_len);
+ }
+- zend_update_property_long(NULL, return_value, ZEND_STRL("offset"), message->offset TSRMLS_CC);
++ zend_update_property_long(NULL, return_value, ZEND_STRL("offset"), message->offset);
+
+ #ifdef HAVE_RD_KAFKA_MESSAGE_HEADERS
+ if (message->err == RD_KAFKA_RESP_ERR_NO_ERROR) {
+@@ -79,14 +79,14 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message TSR
+ }
+ rdkafka_add_assoc_stringl(&headers_array, header_name, (const char*)header_value, header_size);
+ }
+- zend_update_property(NULL, return_value, ZEND_STRL("headers"), &headers_array TSRMLS_CC);
++ zend_update_property(NULL, return_value, ZEND_STRL("headers"), &headers_array);
+ zval_ptr_dtor(&headers_array);
+ }
+ }
+ #endif
+ }
+
+-void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size TSRMLS_DC) /* {{{ */
++void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size) /* {{{ */
+ {
+ rd_kafka_message_t *msg;
+ zeval zmsg;
+@@ -97,7 +97,7 @@ void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messag
+ for (i = 0; i < size; i++) {
+ msg = messages[i];
+ MAKE_STD_ZEVAL(zmsg);
+- kafka_message_new(P_ZEVAL(zmsg), msg TSRMLS_CC);
++ kafka_message_new(P_ZEVAL(zmsg), msg);
+ add_next_index_zval(return_value, P_ZEVAL(zmsg));
+ }
+ } /* }}} */
+@@ -115,11 +115,11 @@ PHP_METHOD(RdKafka__Message, errstr)
+ zval *zpayload;
+ const char *errstr;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- zerr = rdkafka_read_property(NULL, getThis(), ZEND_STRL("err"), 0 TSRMLS_CC);
++ zerr = rdkafka_read_property(NULL, getThis(), ZEND_STRL("err"), 0);
+
+ if (!zerr || Z_TYPE_P(zerr) != IS_LONG) {
+ return;
+@@ -131,7 +131,7 @@ PHP_METHOD(RdKafka__Message, errstr)
+ RDKAFKA_RETURN_STRING(errstr);
+ }
+
+- zpayload = rdkafka_read_property(NULL, getThis(), ZEND_STRL("payload"), 0 TSRMLS_CC);
++ zpayload = rdkafka_read_property(NULL, getThis(), ZEND_STRL("payload"), 0);
+
+ if (zpayload && Z_TYPE_P(zpayload) == IS_STRING) {
+ RETURN_ZVAL(zpayload, 1, 0);
+@@ -144,21 +144,21 @@ static const zend_function_entry kafka_message_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_message_minit(TSRMLS_D) { /* {{{ */
++void kafka_message_minit() { /* {{{ */
+ zend_class_entry ce;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Message", kafka_message_fe);
+- ce_kafka_message = zend_register_internal_class(&ce TSRMLS_CC);
+-
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("err"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("topic_name"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("timestamp"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("partition"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("payload"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("len"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("key"), ZEND_ACC_PUBLIC TSRMLS_CC);
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("offset"), ZEND_ACC_PUBLIC TSRMLS_CC);
++ ce_kafka_message = zend_register_internal_class(&ce);
++
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("err"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("topic_name"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("timestamp"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("partition"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("payload"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("len"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("key"), ZEND_ACC_PUBLIC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("offset"), ZEND_ACC_PUBLIC);
+ #ifdef HAVE_RD_KAFKA_MESSAGE_HEADERS
+- zend_declare_property_null(ce_kafka_message, ZEND_STRL("headers"), ZEND_ACC_PUBLIC TSRMLS_CC);
++ zend_declare_property_null(ce_kafka_message, ZEND_STRL("headers"), ZEND_ACC_PUBLIC);
+ #endif
+ } /* }}} */
+diff --git a/message.h b/message.h
+index 28d75fb..5db24ce 100644
+--- a/message.h
++++ b/message.h
+@@ -16,8 +16,8 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_message_minit(TSRMLS_D);
+-void kafka_message_new(zval *return_value, const rd_kafka_message_t *message TSRMLS_DC);
+-void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size TSRMLS_DC);
++void kafka_message_minit();
++void kafka_message_new(zval *return_value, const rd_kafka_message_t *message);
++void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size);
+
+ extern zend_class_entry * ce_kafka_message;
+diff --git a/metadata.c b/metadata.c
+index e8baca7..86cdbf5 100644
+--- a/metadata.c
++++ b/metadata.c
+@@ -41,22 +41,22 @@ typedef struct _object_intern {
+ #endif
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void brokers_collection(zval *return_value, zval *parent, object_intern *intern TSRMLS_DC) { /* {{{ */
+- kafka_metadata_collection_init(return_value, parent, intern->metadata->brokers, intern->metadata->broker_cnt, sizeof(*intern->metadata->brokers), kafka_metadata_broker_ctor TSRMLS_CC);
++static void brokers_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++ kafka_metadata_collection_init(return_value, parent, intern->metadata->brokers, intern->metadata->broker_cnt, sizeof(*intern->metadata->brokers), kafka_metadata_broker_ctor);
+ }
+ /* }}} */
+
+-static void topics_collection(zval *return_value, zval *parent, object_intern *intern TSRMLS_DC) { /* {{{ */
+- kafka_metadata_collection_init(return_value, parent, intern->metadata->topics, intern->metadata->topic_cnt, sizeof(*intern->metadata->topics), kafka_metadata_topic_ctor TSRMLS_CC);
++static void topics_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++ kafka_metadata_collection_init(return_value, parent, intern->metadata->topics, intern->metadata->topic_cnt, sizeof(*intern->metadata->topics), kafka_metadata_topic_ctor);
+ }
+ /* }}} */
+
+-static void kafka_metadata_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_metadata_free(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -64,19 +64,19 @@ static void kafka_metadata_free(zend_object *object TSRMLS_DC) /* {{{ */
+ rd_kafka_metadata_destroy(intern->metadata);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_metadata_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_metadata_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_metadata_free, NULL);
+@@ -86,19 +86,19 @@ static zend_object_value kafka_metadata_new(zend_class_entry *class_type TSRMLS_
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zmetadata TSRMLS_DC)
++static object_intern * get_object(zval *zmetadata)
+ {
+ object_intern *ometadata = get_custom_object_zval(object_intern, zmetadata);
+
+ if (!ometadata->metadata) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Metadata::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata::__construct() has not been called");
+ return NULL;
+ }
+
+ return ometadata;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -109,17 +109,17 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+
+ MAKE_STD_ZEVAL(brokers);
+- brokers_collection(P_ZEVAL(brokers), object, intern TSRMLS_CC);
++ brokers_collection(P_ZEVAL(brokers), object, intern);
+ add_assoc_zval(&ary, "brokers", P_ZEVAL(brokers));
+
+ MAKE_STD_ZEVAL(topics);
+- topics_collection(P_ZEVAL(topics), object, intern TSRMLS_CC);
++ topics_collection(P_ZEVAL(topics), object, intern);
+ add_assoc_zval(&ary, "topics", P_ZEVAL(topics));
+
+ add_assoc_long(&ary, "orig_broker_id", intern->metadata->orig_broker_id);
+@@ -143,7 +143,7 @@ PHP_METHOD(RdKafka__Metadata, getOrigBrokerId)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -166,7 +166,7 @@ PHP_METHOD(RdKafka__Metadata, getOrigBrokerName)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -189,12 +189,12 @@ PHP_METHOD(RdKafka__Metadata, getBrokers)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- brokers_collection(return_value, getThis(), intern TSRMLS_CC);
++ brokers_collection(return_value, getThis(), intern);
+ }
+ /* }}} */
+
+@@ -212,12 +212,12 @@ PHP_METHOD(RdKafka__Metadata, getTopics)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topics_collection(return_value, getThis(), intern TSRMLS_CC);
++ topics_collection(return_value, getThis(), intern);
+ }
+ /* }}} */
+
+@@ -229,12 +229,12 @@ static const zend_function_entry kafka_metadata_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_minit(TSRMLS_D)
++void kafka_metadata_minit()
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "Metadata", kafka_metadata_fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = kafka_metadata_new;
+
+ handlers = kafka_default_object_handlers;
+@@ -242,13 +242,13 @@ void kafka_metadata_minit(TSRMLS_D)
+ set_object_handler_free_obj(&handlers, kafka_metadata_free);
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+
+- kafka_metadata_topic_minit(TSRMLS_C);
+- kafka_metadata_broker_minit(TSRMLS_C);
+- kafka_metadata_partition_minit(TSRMLS_C);
+- kafka_metadata_collection_minit(TSRMLS_C);
++ kafka_metadata_topic_minit();
++ kafka_metadata_broker_minit();
++ kafka_metadata_partition_minit();
++ kafka_metadata_collection_minit();
+ }
+
+-void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata TSRMLS_DC)
++void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata)
+ {
+ object_intern *intern;
+
+diff --git a/metadata.h b/metadata.h
+index 074816f..b68592b 100644
+--- a/metadata.h
++++ b/metadata.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_minit(TSRMLS_D);
+-void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata TSRMLS_DC);
++void kafka_metadata_minit();
++void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata);
+diff --git a/metadata_broker.c b/metadata_broker.c
+index 89655a5..540b278 100644
+--- a/metadata_broker.c
++++ b/metadata_broker.c
+@@ -40,12 +40,12 @@ typedef struct _object_intern {
+ #endif
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
++static void free_object(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -53,19 +53,19 @@ static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
+ zval_dtor(&intern->zmetadata);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+
+@@ -76,19 +76,19 @@ static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zmt TSRMLS_DC)
++static object_intern * get_object(zval *zmt)
+ {
+ object_intern *omt = get_custom_object_zval(object_intern, zmt);
+
+ if (!omt->metadata_broker) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Metadata\\Broker::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Broker::__construct() has not been called");
+ return NULL;
+ }
+
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -97,7 +97,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -124,7 +124,7 @@ PHP_METHOD(RdKafka__Metadata__Broker, getId)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -147,7 +147,7 @@ PHP_METHOD(RdKafka__Metadata__Broker, getHost)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -170,7 +170,7 @@ PHP_METHOD(RdKafka__Metadata__Broker, getPort)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -186,12 +186,12 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_broker_minit(TSRMLS_D)
++void kafka_metadata_broker_minit()
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "Metadata\\Broker", fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = create_object;
+
+ handlers = kafka_default_object_handlers;
+@@ -200,7 +200,7 @@ void kafka_metadata_broker_minit(TSRMLS_D)
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+ }
+
+-void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *data TSRMLS_DC)
++void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *data)
+ {
+ rd_kafka_metadata_broker_t *metadata_broker = (rd_kafka_metadata_broker_t*)data;
+ object_intern *intern;
+diff --git a/metadata_broker.h b/metadata_broker.h
+index 0cf4e4b..c860495 100644
+--- a/metadata_broker.h
++++ b/metadata_broker.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_broker_minit(TSRMLS_D);
+-void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *metadata_broker TSRMLS_DC);
++void kafka_metadata_broker_minit();
++void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *metadata_broker);
+diff --git a/metadata_collection.c b/metadata_collection.c
+index 62867bc..8b19083 100644
+--- a/metadata_collection.c
++++ b/metadata_collection.c
+@@ -45,12 +45,12 @@ typedef struct _object_intern {
+ #endif
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ static zend_class_entry *ce;
+ static zend_object_handlers handlers;
+
+-static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
++static void free_object(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -58,19 +58,19 @@ static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
+ zval_dtor(&intern->zmetadata);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+@@ -80,19 +80,19 @@ static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zmti TSRMLS_DC)
++static object_intern * get_object(zval *zmti)
+ {
+ object_intern *omti = get_custom_object_zval(object_intern, zmti);
+
+ if (!omti->items) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Metadata\\Collection::__construct() has not been called" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Collection::__construct() has not been called");
+ return NULL;
+ }
+
+ return omti;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -103,14 +103,14 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+
+ for (i = 0; i < intern->item_cnt; i++) {
+ MAKE_STD_ZEVAL(item);
+- intern->ctor(P_ZEVAL(item), &intern->zmetadata, (char *)intern->items + i * intern->item_size TSRMLS_CC);
++ intern->ctor(P_ZEVAL(item), &intern->zmetadata, (char *)intern->items + i * intern->item_size);
+ add_next_index_zval(&ary, P_ZEVAL(item));
+ }
+
+@@ -132,7 +132,7 @@ PHP_METHOD(RdKafka__Metadata__Collection, count)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -155,7 +155,7 @@ PHP_METHOD(RdKafka__Metadata__Collection, rewind)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -178,17 +178,17 @@ PHP_METHOD(RdKafka__Metadata__Collection, current)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (intern->position >= intern->item_cnt) {
+- zend_throw_exception(ce_kafka_exception, "Called current() on invalid iterator", 0 TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Called current() on invalid iterator", 0);
+ return;
+ }
+
+- intern->ctor(return_value, &intern->zmetadata, (char *)intern->items + intern->position * intern->item_size TSRMLS_CC);
++ intern->ctor(return_value, &intern->zmetadata, (char *)intern->items + intern->position * intern->item_size);
+ }
+ /* }}} */
+
+@@ -206,13 +206,13 @@ PHP_METHOD(RdKafka__Metadata__Collection, key)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (intern->position >= intern->item_cnt) {
+- zend_throw_exception(ce_kafka_exception, "Called key() on invalid iterator", 0 TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, "Called key() on invalid iterator", 0);
+ return;
+ }
+
+@@ -234,7 +234,7 @@ PHP_METHOD(RdKafka__Metadata__Collection, next)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -257,7 +257,7 @@ PHP_METHOD(RdKafka__Metadata__Collection, valid)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -276,14 +276,14 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_collection_minit(TSRMLS_D)
++void kafka_metadata_collection_minit()
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka\\Metadata", "Collection", fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = create_object;
+- zend_class_implements(ce TSRMLS_CC, 2, spl_ce_Countable, spl_ce_Iterator);
++ zend_class_implements(ce, 2, spl_ce_Countable, spl_ce_Iterator);
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+@@ -291,7 +291,7 @@ void kafka_metadata_collection_minit(TSRMLS_D)
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+ }
+
+-void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor TSRMLS_DC)
++void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor)
+ {
+ object_intern *intern;
+
+diff --git a/metadata_collection.h b/metadata_collection.h
+index 55539bb..13c6123 100644
+--- a/metadata_collection.h
++++ b/metadata_collection.h
+@@ -16,7 +16,7 @@
+ +----------------------------------------------------------------------+
+ */
+
+-typedef void (*kafka_metadata_collection_ctor_t)(zval *renurn_value, zval *zmetadata, const void *object TSRMLS_DC);
++typedef void (*kafka_metadata_collection_ctor_t)(zval *renurn_value, zval *zmetadata, const void *object);
+
+-void kafka_metadata_collection_minit(TSRMLS_D);
+-void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor TSRMLS_DC);
++void kafka_metadata_collection_minit();
++void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor);
+diff --git a/metadata_partition.c b/metadata_partition.c
+index 17f5f3a..70b7430 100644
+--- a/metadata_partition.c
++++ b/metadata_partition.c
+@@ -40,12 +40,12 @@ typedef struct _object_intern {
+ #endif
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
++static void free_object(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -53,19 +53,19 @@ static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
+ zval_dtor(&intern->zmetadata);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+@@ -75,19 +75,19 @@ static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zmt TSRMLS_DC)
++static object_intern * get_object(zval *zmt)
+ {
+ object_intern *omt = get_custom_object_zval(object_intern, zmt);
+
+ if (!omt->metadata_partition) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Metadata\\Partition::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Partition::__construct() has not been called");
+ return NULL;
+ }
+
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -96,7 +96,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -125,7 +125,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getId)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -148,7 +148,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getErr)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -171,7 +171,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getLeader)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -180,7 +180,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getLeader)
+ }
+ /* }}} */
+
+-void int32_ctor(zval *return_value, zval *zmetadata, const void *data TSRMLS_DC) {
++void int32_ctor(zval *return_value, zval *zmetadata, const void *data) {
+ ZVAL_LONG(return_value, *(int32_t*)data);
+ }
+
+@@ -198,12 +198,12 @@ PHP_METHOD(RdKafka__Metadata__Partition, getReplicas)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->replicas, intern->metadata_partition->replica_cnt, sizeof(*intern->metadata_partition->replicas), int32_ctor TSRMLS_CC);
++ kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->replicas, intern->metadata_partition->replica_cnt, sizeof(*intern->metadata_partition->replicas), int32_ctor);
+ }
+ /* }}} */
+
+@@ -221,12 +221,12 @@ PHP_METHOD(RdKafka__Metadata__Partition, getIsrs)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->isrs, intern->metadata_partition->isr_cnt, sizeof(*intern->metadata_partition->isrs), int32_ctor TSRMLS_CC);
++ kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->isrs, intern->metadata_partition->isr_cnt, sizeof(*intern->metadata_partition->isrs), int32_ctor);
+ }
+ /* }}} */
+
+@@ -239,12 +239,12 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_partition_minit(TSRMLS_D)
++void kafka_metadata_partition_minit()
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "Metadata\\Partition", fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = create_object;
+
+ handlers = kafka_default_object_handlers;
+@@ -253,7 +253,7 @@ void kafka_metadata_partition_minit(TSRMLS_D)
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+ }
+
+-void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *data TSRMLS_DC)
++void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *data)
+ {
+ rd_kafka_metadata_partition_t *metadata_partition = (rd_kafka_metadata_partition_t*)data;
+ object_intern *intern;
+diff --git a/metadata_partition.h b/metadata_partition.h
+index a3da72c..9d9b4dc 100644
+--- a/metadata_partition.h
++++ b/metadata_partition.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_partition_minit(TSRMLS_D);
+-void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *metadata_partition TSRMLS_DC);
++void kafka_metadata_partition_minit();
++void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *metadata_partition);
+diff --git a/metadata_topic.c b/metadata_topic.c
+index 6784316..8a54757 100644
+--- a/metadata_topic.c
++++ b/metadata_topic.c
+@@ -42,17 +42,17 @@ typedef struct _object_intern {
+ #endif
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void partitions_collection(zval *return_value, zval *parent, object_intern *intern TSRMLS_DC) { /* {{{ */
+- kafka_metadata_collection_init(return_value, parent, intern->metadata_topic->partitions, intern->metadata_topic->partition_cnt, sizeof(*intern->metadata_topic->partitions), kafka_metadata_partition_ctor TSRMLS_CC);
++static void partitions_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++ kafka_metadata_collection_init(return_value, parent, intern->metadata_topic->partitions, intern->metadata_topic->partition_cnt, sizeof(*intern->metadata_topic->partitions), kafka_metadata_partition_ctor);
+ }
+ /* }}} */
+
+-static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
++static void free_object(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -60,19 +60,19 @@ static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
+ zval_dtor(&intern->zmetadata);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+@@ -82,19 +82,19 @@ static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *zmt TSRMLS_DC)
++static object_intern * get_object(zval *zmt)
+ {
+ object_intern *omt = get_custom_object_zval(object_intern, zmt);
+
+ if (!omt->metadata_topic) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Metadata\\Topic::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Topic::__construct() has not been called");
+ return NULL;
+ }
+
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -104,7 +104,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -112,7 +112,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+ rdkafka_add_assoc_string(&ary, "topic", intern->metadata_topic->topic);
+
+ MAKE_STD_ZEVAL(partitions);
+- partitions_collection(P_ZEVAL(partitions), object, intern TSRMLS_CC);
++ partitions_collection(P_ZEVAL(partitions), object, intern);
+ add_assoc_zval(&ary, "partitions", P_ZEVAL(partitions));
+
+ add_assoc_long(&ary, "err", intern->metadata_topic->err);
+@@ -135,7 +135,7 @@ PHP_METHOD(RdKafka__Metadata__Topic, getTopic)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -158,7 +158,7 @@ PHP_METHOD(RdKafka__Metadata__Topic, getErr)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -182,12 +182,12 @@ PHP_METHOD(RdKafka__Metadata__Topic, getPartitions)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- partitions_collection(return_value, getThis(), intern TSRMLS_CC);
++ partitions_collection(return_value, getThis(), intern);
+ }
+ /* }}} */
+
+@@ -198,12 +198,12 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_topic_minit(TSRMLS_D)
++void kafka_metadata_topic_minit()
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka\\Metadata", "Topic", fe);
+- ce = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce = zend_register_internal_class(&tmpce);
+ ce->create_object = create_object;
+
+ handlers = kafka_default_object_handlers;
+@@ -212,7 +212,7 @@ void kafka_metadata_topic_minit(TSRMLS_D)
+ set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
+ }
+
+-void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *data TSRMLS_DC)
++void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *data)
+ {
+ rd_kafka_metadata_topic_t *metadata_topic = (rd_kafka_metadata_topic_t*)data;
+ object_intern *intern;
+diff --git a/metadata_topic.h b/metadata_topic.h
+index 128fec0..6c5522a 100644
+--- a/metadata_topic.h
++++ b/metadata_topic.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_topic_minit(TSRMLS_D);
+-void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *metadata_topic TSRMLS_DC);
++void kafka_metadata_topic_minit();
++void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *metadata_topic);
+diff --git a/php_rdkafka_priv.h b/php_rdkafka_priv.h
+index 434e0e9..d00a8eb 100644
+--- a/php_rdkafka_priv.h
++++ b/php_rdkafka_priv.h
+@@ -51,7 +51,7 @@ static inline zend_object * is_zend_object(zend_object * object) {
+
+ #define free_custom_object(object) /* no-op */
+
+-static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce TSRMLS_DC)
++static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce)
+ {
+ return zend_register_internal_class_ex(class_entry, parent_ce);
+ }
+@@ -65,7 +65,7 @@ static inline void set_object_handler_offset(zend_object_handlers * handlers, si
+ handlers->offset = offset;
+ }
+
+-static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval *retval, uint32_t param_count, zval params[] TSRMLS_DC)
++static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval *retval, uint32_t param_count, zval params[])
+ {
+ int local_retval;
+ zval local_retval_zv;
+@@ -81,17 +81,17 @@ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_c
+ fci->params = params;
+ fci->param_count = param_count;
+
+- zend_call_function(fci, fci_cache TSRMLS_CC);
++ zend_call_function(fci, fci_cache);
+
+ if (local_retval) {
+ zval_ptr_dtor(retval);
+ }
+ }
+
+-static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent TSRMLS_DC)
++static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent)
+ {
+ zval rv;
+- return zend_read_property(scope, object, name, name_length, silent, &rv TSRMLS_CC);
++ return zend_read_property(scope, object, name, name_length, silent, &rv);
+ }
+
+ static inline zval *rdkafka_hash_get_current_data_ex(HashTable *ht, HashPosition *pos)
+@@ -125,8 +125,8 @@ typedef long zend_long;
+ typedef int arglen_t;
+
+ #define STORE_OBJECT(retval, intern, dtor, free, clone) do { \
+- void (*___free_object_storage)(zend_object *object TSRMLS_DC) = free; \
+- retval.handle = zend_objects_store_put(&intern->std, dtor, (zend_objects_free_object_storage_t)___free_object_storage, clone TSRMLS_CC); \
++ void (*___free_object_storage)(zend_object *object) = free; \
++ retval.handle = zend_objects_store_put(&intern->std, dtor, (zend_objects_free_object_storage_t)___free_object_storage, clone); \
+ } while (0)
+
+ #define SET_OBJECT_HANDLERS(retval, _handlers) do { \
+@@ -136,7 +136,7 @@ typedef int arglen_t;
+ #define alloc_object(intern, ce) ecalloc(1, sizeof(*intern))
+
+ #define get_custom_object_zval(type, zobject) \
+- ((type*)zend_object_store_get_object(zobject TSRMLS_CC))
++ ((type*)zend_object_store_get_object(zobject))
+
+ #define get_custom_object(type, object) \
+ ((type*)object)
+@@ -167,9 +167,9 @@ static inline void *zend_hash_index_add_ptr(HashTable *ht, zend_ulong h, void *p
+ return pDest;
+ }
+
+-static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce TSRMLS_DC)
++static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce)
+ {
+- return zend_register_internal_class_ex(class_entry, parent_ce, NULL TSRMLS_CC);
++ return zend_register_internal_class_ex(class_entry, parent_ce, NULL);
+ }
+
+ typedef void (*zend_object_free_obj_t)(zend_object *object);
+@@ -183,7 +183,7 @@ static inline void set_object_handler_offset(zend_object_handlers * handlers, si
+ /* no-op */
+ }
+
+-static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval **retval, uint32_t param_count, zval *params[] TSRMLS_DC)
++static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval **retval, uint32_t param_count, zval *params[])
+ {
+ uint32_t i;
+ int local_retval;
+@@ -206,7 +206,7 @@ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_c
+ fci->params = params_array;
+ fci->param_count = param_count;
+
+- zend_call_function(fci, fci_cache TSRMLS_CC);
++ zend_call_function(fci, fci_cache);
+
+ if (local_retval && *retval) {
+ zval_ptr_dtor(retval);
+@@ -215,9 +215,9 @@ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_c
+ efree(params_array);
+ }
+
+-static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent TSRMLS_DC)
++static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent)
+ {
+- return zend_read_property(scope, object, name, name_length, silent TSRMLS_CC);
++ return zend_read_property(scope, object, name, name_length, silent);
+ }
+
+ static inline zval **rdkafka_hash_get_current_data_ex(HashTable *ht, HashPosition *pos)
+@@ -252,7 +252,7 @@ static inline char **rdkafka_hash_get_current_key_ex(HashTable *ht, HashPosition
+ #define RDKAFKA_ZVAL_STRING(zv, str) ZVAL_STRING(zv, str, 1)
+ #endif
+
+-kafka_object * get_kafka_object(zval *zrk TSRMLS_DC);
++kafka_object * get_kafka_object(zval *zrk);
+ void add_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t partition);
+ void del_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t partition);
+ int is_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t partition);
+diff --git a/queue.c b/queue.c
+index 7d661d0..3b0c517 100644
+--- a/queue.c
++++ b/queue.c
+@@ -35,30 +35,30 @@ zend_class_entry * ce_kafka_queue;
+
+ static zend_object_handlers handlers;
+
+-static void kafka_queue_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_queue_free(zend_object *object) /* {{{ */
+ {
+ kafka_queue_object *intern = get_custom_object(kafka_queue_object, object);
+
+ if (intern->rkqu) {
+- kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (kafka_intern) {
+ zend_hash_index_del(&kafka_intern->queues, (zend_ulong)intern);
+ }
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_queue_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_queue_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ kafka_queue_object *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_queue_free, NULL);
+@@ -68,12 +68,12 @@ static zend_object_value kafka_queue_new(zend_class_entry *class_type TSRMLS_DC)
+ }
+ /* }}} */
+
+-kafka_queue_object * get_kafka_queue_object(zval *zrkqu TSRMLS_DC)
++kafka_queue_object * get_kafka_queue_object(zval *zrkqu)
+ {
+ kafka_queue_object *orkqu = get_custom_object_zval(kafka_queue_object, zrkqu);
+
+ if (!orkqu->rkqu) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Queue::__construct() has not been called" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Queue::__construct() has not been called");
+ return NULL;
+ }
+
+@@ -94,11 +94,11 @@ PHP_METHOD(RdKafka__Queue, consume)
+ rd_kafka_message_t *message;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_queue_object(getThis() TSRMLS_CC);
++ intern = get_kafka_queue_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -110,11 +110,11 @@ PHP_METHOD(RdKafka__Queue, consume)
+ if (err == RD_KAFKA_RESP_ERR__TIMED_OUT) {
+ return;
+ }
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+- kafka_message_new(return_value, message TSRMLS_CC);
++ kafka_message_new(return_value, message);
+
+ rd_kafka_message_destroy(message);
+ }
+@@ -129,7 +129,7 @@ static const zend_function_entry kafka_queue_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_queue_minit(TSRMLS_D) { /* {{{ */
++void kafka_queue_minit() { /* {{{ */
+
+ zend_class_entry ce;
+
+@@ -138,6 +138,6 @@ void kafka_queue_minit(TSRMLS_D) { /* {{{ */
+ set_object_handler_offset(&handlers, XtOffsetOf(kafka_queue_object, std));
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Queue", kafka_queue_fe);
+- ce_kafka_queue = zend_register_internal_class(&ce TSRMLS_CC);
++ ce_kafka_queue = zend_register_internal_class(&ce);
+ ce_kafka_queue->create_object = kafka_queue_new;
+ } /* }}} */
+diff --git a/queue.h b/queue.h
+index 8d8ab66..532621c 100644
+--- a/queue.h
++++ b/queue.h
+@@ -27,7 +27,7 @@ typedef struct _kafka_queue_object {
+ #endif
+ } kafka_queue_object;
+
+-void kafka_queue_minit(TSRMLS_D);
+-kafka_queue_object * get_kafka_queue_object(zval *zrkqu TSRMLS_DC);
++void kafka_queue_minit();
++kafka_queue_object * get_kafka_queue_object(zval *zrkqu);
+
+ extern zend_class_entry * ce_kafka_queue;
+diff --git a/rdkafka.c b/rdkafka.c
+index 2accdd9..2052708 100644
+--- a/rdkafka.c
++++ b/rdkafka.c
+@@ -70,17 +70,17 @@ static void stop_consuming_toppar_pp(toppar ** tp) {
+ rd_kafka_consume_stop((*tp)->rkt, (*tp)->partition);
+ }
+
+-static void stop_consuming(kafka_object * intern TSRMLS_DC) {
+- zend_hash_apply(&intern->consuming, (apply_func_t)stop_consuming_toppar_pp TSRMLS_CC);
++static void stop_consuming(kafka_object * intern) {
++ zend_hash_apply(&intern->consuming, (apply_func_t)stop_consuming_toppar_pp);
+ }
+
+-static void kafka_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_free(zend_object *object) /* {{{ */
+ {
+ kafka_object *intern = get_custom_object(kafka_object, object);
+
+ if (intern->rk) {
+ if (intern->type == RD_KAFKA_CONSUMER) {
+- stop_consuming(intern TSRMLS_CC);
++ stop_consuming(intern);
+ zend_hash_destroy(&intern->consuming);
+ zend_hash_destroy(&intern->queues);
+ }
+@@ -90,9 +90,9 @@ static void kafka_free(zend_object *object TSRMLS_DC) /* {{{ */
+ intern->rk = NULL;
+ }
+
+- kafka_conf_callbacks_dtor(&intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_dtor(&intern->cbs);
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+@@ -116,7 +116,7 @@ static void kafka_topic_object_pre_free(kafka_topic_object ** pp) {
+ zval_ptr_dtor(&intern->zrk);
+ }
+
+-static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf TSRMLS_DC) /* {{{ */
++static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf) /* {{{ */
+ {
+ char errstr[512];
+ rd_kafka_t *rk;
+@@ -128,10 +128,10 @@ static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf TSRMLS_
+ intern->type = type;
+
+ if (zconf) {
+- conf_intern = get_kafka_conf_object(zconf TSRMLS_CC);
++ conf_intern = get_kafka_conf_object(zconf);
+ if (conf_intern) {
+ conf = rd_kafka_conf_dup(conf_intern->u.conf);
+- kafka_conf_callbacks_copy(&intern->cbs, &conf_intern->cbs TSRMLS_CC);
++ kafka_conf_callbacks_copy(&intern->cbs, &conf_intern->cbs);
+ intern->cbs.zrk = *this_ptr;
+ rd_kafka_conf_set_opaque(conf, &intern->cbs);
+ }
+@@ -140,7 +140,7 @@ static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf TSRMLS_
+ rk = rd_kafka_new(type, conf, errstr, sizeof(errstr));
+
+ if (rk == NULL) {
+- zend_throw_exception(ce_kafka_exception, errstr, 0 TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, errstr, 0);
+ return;
+ }
+
+@@ -159,13 +159,13 @@ static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf TSRMLS_
+ }
+ /* }}} */
+
+-static zend_object_value kafka_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ kafka_object *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_free, NULL);
+@@ -175,12 +175,12 @@ static zend_object_value kafka_new(zend_class_entry *class_type TSRMLS_DC) /* {{
+ }
+ /* }}} */
+
+-kafka_object * get_kafka_object(zval *zrk TSRMLS_DC)
++kafka_object * get_kafka_object(zval *zrk)
+ {
+ kafka_object *ork = get_custom_object_zval(kafka_object, zrk);
+
+ if (!ork->rk) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Kafka::__construct() has not been called" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Kafka::__construct() has not been called");
+ return NULL;
+ }
+
+@@ -241,7 +241,7 @@ int is_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t p
+ /* {{{ private constructor */
+ PHP_METHOD(RdKafka, __construct)
+ {
+- zend_throw_exception(NULL, "Private constructor", 0 TSRMLS_CC);
++ zend_throw_exception(NULL, "Private constructor", 0);
+ return;
+ }
+ /* }}} */
+@@ -257,16 +257,16 @@ PHP_METHOD(RdKafka__Consumer, __construct)
+ zval *zconf = NULL;
+ zend_error_handling error_handling;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!", &zconf, ce_kafka_conf) == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "|O!", &zconf, ce_kafka_conf) == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+- kafka_init(getThis(), RD_KAFKA_CONSUMER, zconf TSRMLS_CC);
++ kafka_init(getThis(), RD_KAFKA_CONSUMER, zconf);
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -282,11 +282,11 @@ PHP_METHOD(RdKafka__Consumer, newQueue)
+ kafka_object *intern;
+ kafka_queue_object *queue_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -341,11 +341,11 @@ PHP_METHOD(RdKafka__Kafka, addBrokers)
+ arglen_t broker_list_len;
+ kafka_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &broker_list, &broker_list_len) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &broker_list, &broker_list_len) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -372,17 +372,17 @@ PHP_METHOD(RdKafka__Kafka, getMetadata)
+ const rd_kafka_metadata_t *metadata;
+ kafka_topic_object *only_orkt = NULL;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "bO!l", &all_topics, &only_zrkt, ce_kafka_topic, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "bO!l", &all_topics, &only_zrkt, ce_kafka_topic, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (only_zrkt) {
+- only_orkt = get_kafka_topic_object(only_zrkt TSRMLS_CC);
++ only_orkt = get_kafka_topic_object(only_zrkt);
+ if (!only_orkt) {
+ return;
+ }
+@@ -391,11 +391,11 @@ PHP_METHOD(RdKafka__Kafka, getMetadata)
+ err = rd_kafka_metadata(intern->rk, all_topics, only_orkt ? only_orkt->rkt : NULL, &metadata, timeout_ms);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+- kafka_metadata_init(return_value, metadata TSRMLS_CC);
++ kafka_metadata_init(return_value, metadata);
+ }
+ /* }}} */
+
+@@ -411,11 +411,11 @@ PHP_METHOD(RdKafka__Kafka, setLogLevel)
+ kafka_object *intern;
+ zend_long level;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &level) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &level) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -444,17 +444,17 @@ PHP_METHOD(RdKafka__Kafka, newTopic)
+ rd_kafka_topic_conf_t *conf = NULL;
+ kafka_conf_object *conf_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|O!", &topic, &topic_len, &zconf, ce_kafka_topic_conf) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|O!", &topic, &topic_len, &zconf, ce_kafka_topic_conf) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+ if (zconf) {
+- conf_intern = get_kafka_conf_object(zconf TSRMLS_CC);
++ conf_intern = get_kafka_conf_object(zconf);
+ if (conf_intern) {
+ conf = rd_kafka_topic_conf_dup(conf_intern->u.topic_conf);
+ }
+@@ -508,11 +508,11 @@ PHP_METHOD(RdKafka__Kafka, getOutQLen)
+ {
+ kafka_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -533,11 +533,11 @@ PHP_METHOD(RdKafka__Kafka, poll)
+ kafka_object *intern;
+ zend_long timeout;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -558,11 +558,11 @@ PHP_METHOD(RdKafka__Kafka, flush)
+ kafka_object *intern;
+ zend_long timeout;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -584,11 +584,11 @@ PHP_METHOD(RdKafka__Kafka, purge)
+ kafka_object *intern;
+ zend_long purge_flags;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &purge_flags) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &purge_flags) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -619,14 +619,14 @@ PHP_METHOD(RdKafka__Kafka, queryWatermarkOffsets)
+ zval *lowResult, *highResult;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slzzl", &topic, &topic_length, &partition, &lowResult, &highResult, &timeout) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "slzzl", &topic, &topic_length, &partition, &lowResult, &highResult, &timeout) == FAILURE) {
+ return;
+ }
+
+ ZEVAL_DEREF(lowResult);
+ ZEVAL_DEREF(highResult);
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -634,7 +634,7 @@ PHP_METHOD(RdKafka__Kafka, queryWatermarkOffsets)
+ err = rd_kafka_query_watermark_offsets(intern->rk, topic, partition, &low, &high, timeout);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -657,16 +657,16 @@ PHP_METHOD(RdKafka__Kafka, offsetsForTimes)
+ zend_long timeout_ms;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hl", &htopars, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "hl", &htopars, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- topicPartitions = array_arg_to_kafka_topic_partition_list(1, htopars TSRMLS_CC);
++ topicPartitions = array_arg_to_kafka_topic_partition_list(1, htopars);
+ if (!topicPartitions) {
+ return;
+ }
+@@ -675,10 +675,10 @@ PHP_METHOD(RdKafka__Kafka, offsetsForTimes)
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ rd_kafka_topic_partition_list_destroy(topicPartitions);
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+- kafka_topic_partition_list_to_array(return_value, topicPartitions TSRMLS_CC);
++ kafka_topic_partition_list_to_array(return_value, topicPartitions);
+ rd_kafka_topic_partition_list_destroy(topicPartitions);
+ }
+ /* }}} */
+@@ -697,11 +697,11 @@ PHP_METHOD(RdKafka__Kafka, setLogger)
+ zend_long id;
+ void (*logger) (const rd_kafka_t * rk, int level, const char *fac, const char *buf);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &id) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &id) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -719,7 +719,7 @@ PHP_METHOD(RdKafka__Kafka, setLogger)
+ logger = kafka_log_syslog_print;
+ break;
+ default:
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Invalid logger" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "Invalid logger");
+ return;
+ }
+
+@@ -757,16 +757,16 @@ PHP_METHOD(RdKafka__Producer, __construct)
+ zval *zconf = NULL;
+ zend_error_handling error_handling;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!", &zconf, ce_kafka_conf) == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "|O!", &zconf, ce_kafka_conf) == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+- kafka_init(getThis(), RD_KAFKA_PRODUCER, zconf TSRMLS_CC);
++ kafka_init(getThis(), RD_KAFKA_PRODUCER, zconf);
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -784,11 +784,11 @@ PHP_METHOD(RdKafka__Producer, initTransactions)
+ zend_long timeout_ms;
+ const rd_kafka_error_t *error;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -799,8 +799,8 @@ PHP_METHOD(RdKafka__Producer, initTransactions)
+ return;
+ }
+
+- create_kafka_error(return_value, error TSRMLS_CC);
+- zend_throw_exception_object(return_value TSRMLS_CC);
++ create_kafka_error(return_value, error);
++ zend_throw_exception_object(return_value);
+ }
+ /* }}} */
+
+@@ -815,7 +815,7 @@ PHP_METHOD(RdKafka__Producer, beginTransaction)
+ kafka_object *intern;
+ const rd_kafka_error_t *error;
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -826,8 +826,8 @@ PHP_METHOD(RdKafka__Producer, beginTransaction)
+ return;
+ }
+
+- create_kafka_error(return_value, error TSRMLS_CC);
+- zend_throw_exception_object(return_value TSRMLS_CC);
++ create_kafka_error(return_value, error);
++ zend_throw_exception_object(return_value);
+ }
+ /* }}} */
+
+@@ -844,11 +844,11 @@ PHP_METHOD(RdKafka__Producer, commitTransaction)
+ zend_long timeout_ms;
+ const rd_kafka_error_t *error;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -859,8 +859,8 @@ PHP_METHOD(RdKafka__Producer, commitTransaction)
+ return;
+ }
+
+- create_kafka_error(return_value, error TSRMLS_CC);
+- zend_throw_exception_object(return_value TSRMLS_CC);
++ create_kafka_error(return_value, error);
++ zend_throw_exception_object(return_value);
+ }
+ /* }}} */
+
+@@ -877,11 +877,11 @@ PHP_METHOD(RdKafka__Producer, abortTransaction)
+ zend_long timeout_ms;
+ const rd_kafka_error_t *error;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &timeout_ms) == FAILURE) {
+ return;
+ }
+
+- intern = get_kafka_object(getThis() TSRMLS_CC);
++ intern = get_kafka_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -892,8 +892,8 @@ PHP_METHOD(RdKafka__Producer, abortTransaction)
+ return;
+ }
+
+- create_kafka_error(return_value, error TSRMLS_CC);
+- zend_throw_exception_object(return_value TSRMLS_CC);
++ create_kafka_error(return_value, error);
++ zend_throw_exception_object(return_value);
+ }
+ /* }}} */
+
+@@ -939,7 +939,7 @@ void register_err_constants(INIT_FUNC_ARGS) /* {{{ */
+ len += 1;
+ #endif
+
+- zend_register_long_constant(buf, len, desc->code, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
++ zend_register_long_constant(buf, len, desc->code, CONST_CS | CONST_PERSISTENT, module_number);
+ }
+ } /* }}} */
+
+@@ -989,32 +989,32 @@ PHP_MINIT_FUNCTION(rdkafka)
+ set_object_handler_offset(&kafka_object_handlers, XtOffsetOf(kafka_object, std));
+
+ INIT_CLASS_ENTRY(ce, "RdKafka", kafka_fe);
+- ce_kafka = zend_register_internal_class(&ce TSRMLS_CC);
++ ce_kafka = zend_register_internal_class(&ce);
+ ce_kafka->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
+ ce_kafka->create_object = kafka_new;
+
+- zend_declare_property_null(ce_kafka, ZEND_STRL("error_cb"), ZEND_ACC_PRIVATE TSRMLS_CC);
+- zend_declare_property_null(ce_kafka, ZEND_STRL("dr_cb"), ZEND_ACC_PRIVATE TSRMLS_CC);
++ zend_declare_property_null(ce_kafka, ZEND_STRL("error_cb"), ZEND_ACC_PRIVATE);
++ zend_declare_property_null(ce_kafka, ZEND_STRL("dr_cb"), ZEND_ACC_PRIVATE);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Consumer", kafka_consumer_fe);
+- ce_kafka_consumer = rdkafka_register_internal_class_ex(&ce, ce_kafka TSRMLS_CC);
++ ce_kafka_consumer = rdkafka_register_internal_class_ex(&ce, ce_kafka);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Producer", kafka_producer_fe);
+- ce_kafka_producer = rdkafka_register_internal_class_ex(&ce, ce_kafka TSRMLS_CC);
++ ce_kafka_producer = rdkafka_register_internal_class_ex(&ce, ce_kafka);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Exception", NULL);
+- ce_kafka_exception = rdkafka_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
++ ce_kafka_exception = rdkafka_register_internal_class_ex(&ce, zend_exception_get_default());
+
+- kafka_conf_minit(TSRMLS_C);
++ kafka_conf_minit();
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+- kafka_error_minit(TSRMLS_C);
++ kafka_error_minit();
+ #endif
+- kafka_kafka_consumer_minit(TSRMLS_C);
+- kafka_message_minit(TSRMLS_C);
+- kafka_metadata_minit(TSRMLS_C);
+- kafka_metadata_topic_partition_minit(TSRMLS_C);
+- kafka_queue_minit(TSRMLS_C);
+- kafka_topic_minit(TSRMLS_C);
++ kafka_kafka_consumer_minit();
++ kafka_message_minit();
++ kafka_metadata_minit();
++ kafka_metadata_topic_partition_minit();
++ kafka_queue_minit();
++ kafka_topic_minit();
+
+ return SUCCESS;
+ }
+diff --git a/tests/conf_setDefaultTopicConf8.phpt b/tests/conf_setDefaultTopicConf8.phpt
+new file mode 100644
+index 0000000..e5fdfe1
+--- /dev/null
++++ b/tests/conf_setDefaultTopicConf8.phpt
+@@ -0,0 +1,38 @@
++--TEST--
++RdKafka\Conf::setDefaultTopicConf()
++--SKIPIF--
++<?php
++if (!method_exists('RdKafka\Conf', 'setDefaultTopicConf') || 8 > PHP_MAJOR_VERSION) {
++ echo "skip";
++}
++?>
++--FILE--
++<?php
++
++$conf = new RdKafka\Conf();
++
++echo "Setting valid topic conf\n";
++$conf->setDefaultTopicConf(new RdKafka\TopicConf());
++
++echo "Setting invalid topic conf\n";
++try {
++ $conf->setDefaultTopicConf($conf);
++} catch(TypeError $error) {
++ echo $error->getMessage() . PHP_EOL;
++ echo $error->getFile() . PHP_EOL;
++ echo $error->getLine() . PHP_EOL;
++ echo $error->getCode();
++}
++
++--EXPECTF--
++Setting valid topic conf
++
++Deprecated: Method RdKafka\Conf::setDefaultTopicConf() is deprecated in %s%econf_setDefaultTopicConf8.php on line 6
++Setting invalid topic conf
++
++Deprecated: Method RdKafka\Conf::setDefaultTopicConf() is deprecated in %s%econf_setDefaultTopicConf8.php on line 10
++RdKafka\Conf::setDefaultTopicConf(): Argument #1 ($topic_conf) must be of type RdKafka\TopicConf, RdKafka\Conf given
++%s%econf_setDefaultTopicConf8.php
++10
++0
++
+diff --git a/topic.c b/topic.c
+index 63ae06a..389ae4a 100644
+--- a/topic.c
++++ b/topic.c
+@@ -43,30 +43,30 @@ typedef struct _php_callback {
+ zend_fcall_info_cache fcc;
+ } php_callback;
+
+-static void kafka_topic_free(zend_object *object TSRMLS_DC) /* {{{ */
++static void kafka_topic_free(zend_object *object) /* {{{ */
+ {
+ kafka_topic_object *intern = get_custom_object(kafka_topic_object, object);
+
+ if (ZE_ISDEF(intern->zrk) && intern->rkt) {
+- kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (kafka_intern) {
+ zend_hash_index_del(&kafka_intern->topics, (zend_ulong)intern);
+ }
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_topic_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value kafka_topic_new(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ kafka_topic_object *intern;
+
+ intern = alloc_object(intern, class_type);
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_topic_free, NULL);
+@@ -93,19 +93,19 @@ static void consume_callback(rd_kafka_message_t *msg, void *opaque)
+
+ MAKE_STD_ZEVAL(args[0]);
+
+- kafka_message_new(P_ZEVAL(args[0]), msg TSRMLS_CC);
++ kafka_message_new(P_ZEVAL(args[0]), msg);
+
+- rdkafka_call_function(&cb->fci, &cb->fcc, NULL, 1, args TSRMLS_CC);
++ rdkafka_call_function(&cb->fci, &cb->fcc, NULL, 1, args);
+
+ zval_ptr_dtor(&args[0]);
+ }
+
+-kafka_topic_object * get_kafka_topic_object(zval *zrkt TSRMLS_DC)
++kafka_topic_object * get_kafka_topic_object(zval *zrkt)
+ {
+ kafka_topic_object *orkt = get_custom_object_zval(kafka_topic_object, zrkt);
+
+ if (!orkt->rkt) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\Topic::__construct() has not been called" TSRMLS_CC);
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\Topic::__construct() has not been called");
+ return NULL;
+ }
+
+@@ -128,16 +128,16 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeCallback)
+ long result;
+ kafka_topic_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llf", &partition, &timeout_ms, &cb.fci, &cb.fcc) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "llf", &partition, &timeout_ms, &cb.fci, &cb.fcc) == FAILURE) {
+ return;
+ }
+
+ if (partition < 0 || partition > 0x7FFFFFFF) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -172,26 +172,26 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeQueueStart)
+ rd_kafka_resp_err_t err;
+ kafka_object *kafka_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llO", &partition, &offset, &zrkqu, ce_kafka_queue) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "llO", &partition, &offset, &zrkqu, ce_kafka_queue) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- queue_intern = get_kafka_queue_object(zrkqu TSRMLS_CC);
++ queue_intern = get_kafka_queue_object(zrkqu);
+ if (!queue_intern) {
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (!kafka_intern) {
+ return;
+ }
+@@ -199,7 +199,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeQueueStart)
+ if (is_consuming_toppar(kafka_intern, intern->rkt, partition)) {
+ zend_throw_exception_ex(
+ ce_kafka_exception,
+- 0 TSRMLS_CC,
++ 0,
+ "%s:" ZEND_LONG_FMT " is already being consumed by the same Consumer instance",
+ rd_kafka_topic_name(intern->rkt),
+ partition
+@@ -211,7 +211,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeQueueStart)
+
+ if (ret == -1) {
+ err = rd_kafka_last_error();
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -236,21 +236,21 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStart)
+ rd_kafka_resp_err_t err;
+ kafka_object *kafka_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &partition, &offset) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &partition, &offset) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (!kafka_intern) {
+ return;
+ }
+@@ -258,7 +258,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStart)
+ if (is_consuming_toppar(kafka_intern, intern->rkt, partition)) {
+ zend_throw_exception_ex(
+ ce_kafka_exception,
+- 0 TSRMLS_CC,
++ 0,
+ "%s:" ZEND_LONG_FMT " is already being consumed by the same Consumer instance",
+ rd_kafka_topic_name(intern->rkt),
+ partition
+@@ -270,7 +270,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStart)
+
+ if (ret == -1) {
+ err = rd_kafka_last_error();
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -293,21 +293,21 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStop)
+ rd_kafka_resp_err_t err;
+ kafka_object *kafka_intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &partition) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &partition) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (!kafka_intern) {
+ return;
+ }
+@@ -316,7 +316,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStop)
+
+ if (ret == -1) {
+ err = rd_kafka_last_error();
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+@@ -340,16 +340,16 @@ PHP_METHOD(RdKafka__ConsumerTopic, consume)
+ rd_kafka_message_t *message;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &partition, &timeout_ms) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &partition, &timeout_ms) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -361,11 +361,11 @@ PHP_METHOD(RdKafka__ConsumerTopic, consume)
+ if (err == RD_KAFKA_RESP_ERR__TIMED_OUT) {
+ return;
+ }
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+- kafka_message_new(return_value, message TSRMLS_CC);
++ kafka_message_new(return_value, message);
+
+ rd_kafka_message_destroy(message);
+ }
+@@ -388,21 +388,21 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeBatch)
+ rd_kafka_message_t **rkmessages;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &partition, &timeout_ms, &batch_size) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "lll", &partition, &timeout_ms, &batch_size) == FAILURE) {
+ return;
+ }
+
+ if (0 >= batch_size) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for batch_size", batch_size TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for batch_size", batch_size);
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -414,12 +414,12 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeBatch)
+ if (result == -1) {
+ free(rkmessages);
+ err = rd_kafka_last_error();
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+
+ if (result >= 0) {
+- kafka_message_list_to_array(return_value, rkmessages, result TSRMLS_CC);
++ kafka_message_list_to_array(return_value, rkmessages, result);
+ for (i = 0; i < result; ++i) {
+ rd_kafka_message_destroy(rkmessages[i]);
+ }
+@@ -443,16 +443,16 @@ PHP_METHOD(RdKafka__ConsumerTopic, offsetStore)
+ zend_long offset;
+ rd_kafka_resp_err_t err;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &partition, &offset) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll", &partition, &offset) == FAILURE) {
+ return;
+ }
+
+ if (partition < 0 || partition > 0x7FFFFFFF) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -460,7 +460,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, offsetStore)
+ err = rd_kafka_offset_store(intern->rkt, partition, offset);
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -509,27 +509,27 @@ PHP_METHOD(RdKafka__ProducerTopic, produce)
+ rd_kafka_resp_err_t err;
+ kafka_topic_object *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll|s!s!", &partition, &msgflags, &payload, &payload_len, &key, &key_len) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll|s!s!", &partition, &msgflags, &payload, &payload_len, &key, &key_len) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+ if (msgflags != 0 && msgflags != RD_KAFKA_MSG_F_BLOCK) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Invalid value '%ld' for $msgflags", msgflags TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Invalid value '%ld' for $msgflags", msgflags);
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+
+ ret = rd_kafka_produce(intern->rkt, partition, msgflags | RD_KAFKA_MSG_F_COPY, payload, payload_len, key, key_len, NULL);
+
+ if (ret == -1) {
+ err = rd_kafka_last_error();
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -567,17 +567,17 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ zend_long timestamp_ms = 0;
+ zend_bool timestamp_ms_is_null = 0;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll|s!s!h!l!", &partition, &msgflags, &payload, &payload_len, &key, &key_len, &headersParam, &timestamp_ms, &timestamp_ms_is_null) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll|s!s!h!l!", &partition, &msgflags, &payload, &payload_len, &key, &key_len, &headersParam, &timestamp_ms, &timestamp_ms_is_null) == FAILURE) {
+ return;
+ }
+
+ if (partition != RD_KAFKA_PARTITION_UA && (partition < 0 || partition > 0x7FFFFFFF)) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Out of range value '%ld' for $partition", partition TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Out of range value '%ld' for $partition", partition);
+ return;
+ }
+
+ if (msgflags != 0 && msgflags != RD_KAFKA_MSG_F_BLOCK) {
+- zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Invalid value '%ld' for $msgflags", msgflags TSRMLS_CC);
++ zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Invalid value '%ld' for $msgflags", msgflags);
+ return;
+ }
+
+@@ -585,7 +585,7 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ timestamp_ms = 0;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+
+ if (headersParam != NULL && zend_hash_num_elements(headersParam) > 0) {
+ headers = rd_kafka_headers_new(zend_hash_num_elements(headersParam));
+@@ -606,7 +606,7 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ headers = rd_kafka_headers_new(0);
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk) TSRMLS_CC);
++ kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
+ if (!kafka_intern) {
+ return;
+ }
+@@ -625,7 +625,7 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+
+ if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ rd_kafka_headers_destroy(headers);
+- zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err TSRMLS_CC);
++ zend_throw_exception(ce_kafka_exception, rd_kafka_err2str(err), err);
+ return;
+ }
+ }
+@@ -654,7 +654,7 @@ PHP_METHOD(RdKafka__Topic, getName)
+ return;
+ }
+
+- intern = get_kafka_topic_object(getThis() TSRMLS_CC);
++ intern = get_kafka_topic_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -668,7 +668,7 @@ static const zend_function_entry kafka_topic_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_topic_minit(TSRMLS_D) { /* {{{ */
++void kafka_topic_minit() { /* {{{ */
+
+ zend_class_entry ce;
+
+@@ -678,16 +678,16 @@ void kafka_topic_minit(TSRMLS_D) { /* {{{ */
+ set_object_handler_offset(&object_handlers, XtOffsetOf(kafka_topic_object, std));
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Topic", kafka_topic_fe);
+- ce_kafka_topic = zend_register_internal_class(&ce TSRMLS_CC);
++ ce_kafka_topic = zend_register_internal_class(&ce);
+ ce_kafka_topic->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
+ ce_kafka_topic->create_object = kafka_topic_new;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ConsumerTopic", kafka_consumer_topic_fe);
+- ce_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic TSRMLS_CC);
++ ce_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaConsumerTopic", kafka_kafka_consumer_topic_fe);
+- ce_kafka_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic TSRMLS_CC);
++ ce_kafka_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ProducerTopic", kafka_producer_topic_fe);
+- ce_kafka_producer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic TSRMLS_CC);
++ ce_kafka_producer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
+ } /* }}} */
+diff --git a/topic.h b/topic.h
+index 07f49ae..78beec3 100644
+--- a/topic.h
++++ b/topic.h
+@@ -29,8 +29,8 @@ typedef struct _kafka_topic_object {
+ #endif
+ } kafka_topic_object;
+
+-void kafka_topic_minit(TSRMLS_D);
+-kafka_topic_object * get_kafka_topic_object(zval *zrkt TSRMLS_DC);
++void kafka_topic_minit();
++kafka_topic_object * get_kafka_topic_object(zval *zrkt);
+
+ extern zend_class_entry * ce_kafka_consumer_topic;
+ extern zend_class_entry * ce_kafka_kafka_consumer_topic;
+diff --git a/topic_partition.c b/topic_partition.c
+index 2e6d334..f9a08d9 100644
+--- a/topic_partition.c
++++ b/topic_partition.c
+@@ -33,13 +33,13 @@
+
+ typedef kafka_topic_partition_intern object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC);
++static HashTable *get_debug_info(zval *object, int *is_temp);
+
+ zend_class_entry * ce_kafka_topic_partition;
+
+ static zend_object_handlers handlers;
+
+-static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
++static void free_object(zend_object *object) /* {{{ */
+ {
+ object_intern *intern = get_custom_object(object_intern, object);
+
+@@ -47,19 +47,19 @@ static void free_object(zend_object *object TSRMLS_DC) /* {{{ */
+ efree(intern->topic);
+ }
+
+- zend_object_std_dtor(&intern->std TSRMLS_CC);
++ zend_object_std_dtor(&intern->std);
+
+ free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
++static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
+ {
+ zend_object_value retval;
+ object_intern *intern;
+
+ intern = ecalloc(1, sizeof(*intern));
+- zend_object_std_init(&intern->std, class_type TSRMLS_CC);
++ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+ STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+@@ -69,24 +69,24 @@ static zend_object_value create_object(zend_class_entry *class_type TSRMLS_DC) /
+ }
+ /* }}} */
+
+-static object_intern * get_object(zval *z TSRMLS_DC) /* {{{ */
++static object_intern * get_object(zval *z) /* {{{ */
+ {
+ object_intern * intern = get_custom_object_zval(object_intern, z);
+
+ if (!intern->topic) {
+- zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "RdKafka\\TopicPartition::__construct() has not been called");
++ zend_throw_exception_ex(NULL, 0, "RdKafka\\TopicPartition::__construct() has not been called");
+ return NULL;
+ }
+
+ return intern;
+ } /* }}} */
+
+-kafka_topic_partition_intern * get_topic_partition_object(zval *z TSRMLS_DC) /* {{{ */
++kafka_topic_partition_intern * get_topic_partition_object(zval *z) /* {{{ */
+ {
+- return get_object(z TSRMLS_CC);
++ return get_object(z);
+ } /* }}} */
+
+-static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
++static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -95,7 +95,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object TSRMLS_CC);
++ intern = get_object(object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -113,7 +113,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
+ }
+ /* }}} */
+
+-void kafka_topic_partition_init(zval *zobj, char * topic, int32_t partition, int64_t offset TSRMLS_DC) /* {{{ */
++void kafka_topic_partition_init(zval *zobj, char * topic, int32_t partition, int64_t offset) /* {{{ */
+ {
+ object_intern *intern;
+
+@@ -131,7 +131,7 @@ void kafka_topic_partition_init(zval *zobj, char * topic, int32_t partition, int
+ intern->offset = offset;
+ } /* }}} */
+
+-void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_partition_list_t *list TSRMLS_DC) /* {{{ */
++void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_partition_list_t *list) /* {{{ */
+ {
+ rd_kafka_topic_partition_t *topar;
+ zeval ztopar;
+@@ -143,12 +143,12 @@ void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_part
+ topar = &list->elems[i];
+ MAKE_STD_ZEVAL(ztopar);
+ object_init_ex(P_ZEVAL(ztopar), ce_kafka_topic_partition);
+- kafka_topic_partition_init(P_ZEVAL(ztopar), topar->topic, topar->partition, topar->offset TSRMLS_CC);
++ kafka_topic_partition_init(P_ZEVAL(ztopar), topar->topic, topar->partition, topar->offset);
+ add_next_index_zval(return_value, P_ZEVAL(ztopar));
+ }
+ } /* }}} */
+
+-rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int argnum, HashTable *ary TSRMLS_DC) { /* {{{ */
++rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int argnum, HashTable *ary) { /* {{{ */
+
+ HashPosition pos;
+ rd_kafka_topic_partition_list_t *list;
+@@ -162,20 +162,20 @@ rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int ar
+ kafka_topic_partition_intern *topar_intern;
+ rd_kafka_topic_partition_t *topar;
+
+- if (Z_TYPE_P(ZEVAL(zv)) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(ZEVAL(zv)), ce_kafka_topic_partition TSRMLS_CC)) {
++ if (Z_TYPE_P(ZEVAL(zv)) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(ZEVAL(zv)), ce_kafka_topic_partition)) {
+ const char *space;
+- const char *class_name = get_active_class_name(&space TSRMLS_CC);
++ const char *class_name = get_active_class_name(&space);
+ rd_kafka_topic_partition_list_destroy(list);
+ php_error(E_ERROR,
+ "Argument %d passed to %s%s%s() must be an array of RdKafka\\TopicPartition, at least one element is a(n) %s",
+ argnum,
+ class_name, space,
+- get_active_function_name(TSRMLS_C),
++ get_active_function_name(),
+ zend_zval_type_name(ZEVAL(zv)));
+ return NULL;
+ }
+
+- topar_intern = get_topic_partition_object(ZEVAL(zv) TSRMLS_CC);
++ topar_intern = get_topic_partition_object(ZEVAL(zv));
+ if (!topar_intern) {
+ rd_kafka_topic_partition_list_destroy(list);
+ return NULL;
+@@ -206,16 +206,16 @@ PHP_METHOD(RdKafka__TopicPartition, __construct)
+ zend_long offset = 0;
+ zend_error_handling error_handling;
+
+- zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
++ zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling);
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", &topic, &topic_len, &partition, &offset) == FAILURE) {
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l", &topic, &topic_len, &partition, &offset) == FAILURE) {
++ zend_restore_error_handling(&error_handling);
+ return;
+ }
+
+- kafka_topic_partition_init(getThis(), topic, partition, offset TSRMLS_CC);
++ kafka_topic_partition_init(getThis(), topic, partition, offset);
+
+- zend_restore_error_handling(&error_handling TSRMLS_CC);
++ zend_restore_error_handling(&error_handling);
+ }
+ /* }}} */
+
+@@ -233,7 +233,7 @@ PHP_METHOD(RdKafka__TopicPartition, getTopic)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -259,11 +259,11 @@ PHP_METHOD(RdKafka__TopicPartition, setTopic)
+ arglen_t topic_len;
+ object_intern *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &topic, &topic_len) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &topic, &topic_len) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -292,7 +292,7 @@ PHP_METHOD(RdKafka__TopicPartition, getPartition)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -313,11 +313,11 @@ PHP_METHOD(RdKafka__TopicPartition, setPartition)
+ zend_long partition;
+ object_intern *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &partition) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &partition) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -342,7 +342,7 @@ PHP_METHOD(RdKafka__TopicPartition, getOffset)
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -363,11 +363,11 @@ PHP_METHOD(RdKafka__TopicPartition, setOffset)
+ zend_long offset;
+ object_intern *intern;
+
+- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &offset) == FAILURE) {
++ if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &offset) == FAILURE) {
+ return;
+ }
+
+- intern = get_object(getThis() TSRMLS_CC);
++ intern = get_object(getThis());
+ if (!intern) {
+ return;
+ }
+@@ -389,12 +389,12 @@ static const zend_function_entry fe[] = { /* {{{ */
+ PHP_FE_END
+ }; /* }}} */
+
+-void kafka_metadata_topic_partition_minit(TSRMLS_D) /* {{{ */
++void kafka_metadata_topic_partition_minit() /* {{{ */
+ {
+ zend_class_entry tmpce;
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "TopicPartition", fe);
+- ce_kafka_topic_partition = zend_register_internal_class(&tmpce TSRMLS_CC);
++ ce_kafka_topic_partition = zend_register_internal_class(&tmpce);
+ ce_kafka_topic_partition->create_object = create_object;
+
+ handlers = kafka_default_object_handlers;
+diff --git a/topic_partition.h b/topic_partition.h
+index cbc0f43..a7aab8b 100644
+--- a/topic_partition.h
++++ b/topic_partition.h
+@@ -28,12 +28,12 @@ typedef struct _kafka_topic_partition_intern {
+ #endif
+ } kafka_topic_partition_intern;
+
+-void kafka_metadata_topic_partition_minit(TSRMLS_D);
++void kafka_metadata_topic_partition_minit();
+
+-kafka_topic_partition_intern * get_topic_partition_object(zval *z TSRMLS_DC);
+-void kafka_topic_partition_init(zval *z, char *topic, int32_t partition, int64_t offset TSRMLS_DC);
++kafka_topic_partition_intern * get_topic_partition_object(zval *z);
++void kafka_topic_partition_init(zval *z, char *topic, int32_t partition, int64_t offset);
+
+-void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_partition_list_t *list TSRMLS_DC);
+-rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int argnum, HashTable *ary TSRMLS_DC);
++void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_partition_list_t *list);
++rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int argnum, HashTable *ary);
+
+ extern zend_class_entry * ce_kafka_topic_partition;
+From 134024a653f53618ed3208a3ec1867d1ec2c3747 Mon Sep 17 00:00:00 2001
+From: Arnaud Le Blanc <arnaud.lb@gmail.com>
+Date: Mon, 7 Dec 2020 11:26:57 +0100
+Subject: [PATCH] Drop the php5 compatibility layer: zeval.h (#403)
+
+Co-authored-by: Nick <nickjobszh@gmail.com>
+---
+ conf.c | 109 ++++++++++++++++++++--------------------
+ fun.c | 19 ++++---
+ kafka_consumer.c | 10 ++--
+ kafka_error_exception.c | 1 -
+ kafka_error_exception.h | 3 +-
+ message.c | 8 +--
+ metadata.c | 17 +++----
+ metadata_broker.c | 1 -
+ metadata_collection.c | 9 ++--
+ metadata_topic.c | 9 ++--
+ queue.c | 2 +-
+ queue.h | 2 +-
+ rdkafka.c | 8 +--
+ topic.c | 26 +++++-----
+ topic.h | 4 +-
+ topic_partition.c | 19 ++++---
+ zeval.h | 71 --------------------------
+ 17 files changed, 119 insertions(+), 199 deletions(-)
+ delete mode 100644 zeval.h
+
+diff --git a/conf.c b/conf.c
+index 69d1863..6e814b7 100644
+--- a/conf.c
++++ b/conf.c
+@@ -31,7 +31,6 @@
+ #include "conf.h"
+ #include "topic_partition.h"
+ #include "message.h"
+-#include "zeval.h"
+
+ zend_class_entry * ce_kafka_conf;
+ zend_class_entry * ce_kafka_topic_conf;
+@@ -143,7 +142,7 @@ kafka_conf_object * get_kafka_conf_object(zval *zconf)
+ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[3];
++ zval args[3];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -154,13 +153,13 @@ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, voi
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
+- MAKE_STD_ZEVAL(args[2]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
++ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- ZVAL_LONG(P_ZEVAL(args[1]), err);
+- RDKAFKA_ZVAL_STRING(P_ZEVAL(args[2]), reason);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_LONG(&args[1], err);
++ RDKAFKA_ZVAL_STRING(&args[2], reason);
+
+ rdkafka_call_function(&cbs->error->fci, &cbs->error->fcc, NULL, 3, args);
+
+@@ -172,7 +171,7 @@ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, voi
+ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[2];
++ zval args[2];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -183,11 +182,11 @@ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- kafka_message_new(P_ZEVAL(args[1]), msg);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ kafka_message_new(&args[1], msg);
+
+ rdkafka_call_function(&cbs->dr_msg->fci, &cbs->dr_msg->fcc, NULL, 2, args);
+
+@@ -198,7 +197,7 @@ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
+ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[3];
++ zval args[3];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -209,13 +208,13 @@ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void
+ return 0;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
+- MAKE_STD_ZEVAL(args[2]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
++ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- RDKAFKA_ZVAL_STRING(P_ZEVAL(args[1]), json);
+- ZVAL_LONG(P_ZEVAL(args[2]), json_len);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ RDKAFKA_ZVAL_STRING(&args[1], json);
++ ZVAL_LONG(&args[2], json_len);
+
+ rdkafka_call_function(&cbs->stats->fci, &cbs->stats->fcc, NULL, 3, args);
+
+@@ -229,7 +228,7 @@ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void
+ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_kafka_topic_partition_list_t *partitions, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[3];
++ zval args[3];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -247,13 +246,13 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
+- MAKE_STD_ZEVAL(args[2]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
++ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- ZVAL_LONG(P_ZEVAL(args[1]), err);
+- kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_LONG(&args[1], err);
++ kafka_topic_partition_list_to_array(&args[2], partitions);
+
+ rdkafka_call_function(&cbs->rebalance->fci, &cbs->rebalance->fcc, NULL, 3, args);
+
+@@ -265,7 +264,7 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[2];
++ zval args[2];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -276,11 +275,11 @@ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
+
+- kafka_message_new(P_ZEVAL(args[0]), msg);
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[1]), &cbs->zrk, 1, 0);
++ kafka_message_new(&args[0], msg);
++ KAFKA_ZVAL_ZVAL(&args[1], &cbs->zrk, 1, 0);
+
+
+ rdkafka_call_function(&cbs->consume->fci, &cbs->consume->fcc, NULL, 2, args);
+@@ -292,7 +291,7 @@ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_kafka_topic_partition_list_t *partitions, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+- zeval args[3];
++ zval args[3];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -303,13 +302,13 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
+- MAKE_STD_ZEVAL(args[2]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
++ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- ZVAL_LONG(P_ZEVAL(args[1]), err);
+- kafka_topic_partition_list_to_array(P_ZEVAL(args[2]), partitions);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_LONG(&args[1], err);
++ kafka_topic_partition_list_to_array(&args[2], partitions);
+
+ rdkafka_call_function(&cbs->offset_commit->fci, &cbs->offset_commit->fcc, NULL, 3, args);
+
+@@ -320,7 +319,7 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+
+ static void kafka_conf_log_cb(const rd_kafka_t *rk, int level, const char *facility, const char *message)
+ {
+- zeval args[4];
++ zval args[4];
+ TSRMLS_FETCH();
+
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) rd_kafka_opaque(rk);
+@@ -329,15 +328,15 @@ static void kafka_conf_log_cb(const rd_kafka_t *rk, int level, const char *facil
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
+- MAKE_STD_ZEVAL(args[1]);
+- MAKE_STD_ZEVAL(args[2]);
+- MAKE_STD_ZEVAL(args[3]);
++ ZVAL_NULL(&args[0]);
++ ZVAL_NULL(&args[1]);
++ ZVAL_NULL(&args[2]);
++ ZVAL_NULL(&args[3]);
+
+- KAFKA_ZVAL_ZVAL(P_ZEVAL(args[0]), &cbs->zrk, 1, 0);
+- ZVAL_LONG(P_ZEVAL(args[1]), level);
+- RDKAFKA_ZVAL_STRING(P_ZEVAL(args[2]), facility);
+- RDKAFKA_ZVAL_STRING(P_ZEVAL(args[3]), message);
++ KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_LONG(&args[1], level);
++ RDKAFKA_ZVAL_STRING(&args[2], facility);
++ RDKAFKA_ZVAL_STRING(&args[3], message);
+
+ rdkafka_call_function(&cbs->log->fci, &cbs->log->fcc, NULL, 4, args);
+
+@@ -523,7 +522,7 @@ PHP_METHOD(RdKafka__Conf, setErrorCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.error) {
+ zval_ptr_dtor(&intern->cbs.error->fci.function_name);
+@@ -560,7 +559,7 @@ PHP_METHOD(RdKafka__Conf, setDrMsgCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.dr_msg) {
+ zval_ptr_dtor(&intern->cbs.dr_msg->fci.function_name);
+@@ -597,7 +596,7 @@ PHP_METHOD(RdKafka__Conf, setStatsCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.stats) {
+ zval_ptr_dtor(&intern->cbs.stats->fci.function_name);
+@@ -634,7 +633,7 @@ PHP_METHOD(RdKafka__Conf, setRebalanceCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.rebalance) {
+ zval_ptr_dtor(&intern->cbs.rebalance->fci.function_name);
+@@ -671,7 +670,7 @@ PHP_METHOD(RdKafka__Conf, setConsumeCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.consume) {
+ zval_ptr_dtor(&intern->cbs.consume->fci.function_name);
+@@ -708,7 +707,7 @@ PHP_METHOD(RdKafka__Conf, setOffsetCommitCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (intern->cbs.offset_commit) {
+ zval_ptr_dtor(&intern->cbs.offset_commit->fci.function_name);
+@@ -746,7 +745,7 @@ PHP_METHOD(RdKafka__Conf, setLogCb)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(fci.function_name));
++ Z_ADDREF_P(&fci.function_name);
+
+ if (conf->cbs.log) {
+ zval_ptr_dtor(&conf->cbs.log->fci.function_name);
+diff --git a/fun.c b/fun.c
+index ee21814..77053ec 100644
+--- a/fun.c
++++ b/fun.c
+@@ -26,7 +26,6 @@
+ #include "librdkafka/rdkafka.h"
+ #include "Zend/zend_exceptions.h"
+ #include "ext/spl/spl_exceptions.h"
+-#include "zeval.h"
+
+ /* {{{ arginfo */
+ ZEND_BEGIN_ARG_INFO_EX(arginfo_kafka_get_err_descs, 0, 0, 0)
+@@ -71,7 +70,7 @@ PHP_FUNCTION(rd_kafka_get_err_descs)
+
+ for (i = 0; i < cnt; i++) {
+ const struct rd_kafka_err_desc *desc = &errdescs[i];
+- zeval el;
++ zval el;
+
+ if (desc->code == 0) {
+ if (seen_zero) {
+@@ -80,20 +79,20 @@ PHP_FUNCTION(rd_kafka_get_err_descs)
+ seen_zero = 1;
+ }
+
+- MAKE_STD_ZEVAL(el);
+- array_init(P_ZEVAL(el));
+- add_assoc_long(P_ZEVAL(el), "code", desc->code);
++ ZVAL_NULL(&el);
++ array_init(&el);
++ add_assoc_long(&el, "code", desc->code);
+ if (desc->name) {
+- rdkafka_add_assoc_string(P_ZEVAL(el), "name", (char*) desc->name);
++ rdkafka_add_assoc_string(&el, "name", (char*) desc->name);
+ } else {
+- add_assoc_null(P_ZEVAL(el), "name");
++ add_assoc_null(&el, "name");
+ }
+ if (desc->desc) {
+- rdkafka_add_assoc_string(P_ZEVAL(el), "desc", (char*) desc->desc);
++ rdkafka_add_assoc_string(&el, "desc", (char*) desc->desc);
+ }else {
+- add_assoc_null(P_ZEVAL(el), "desc");
++ add_assoc_null(&el, "desc");
+ }
+- add_next_index_zval(return_value, P_ZEVAL(el));
++ add_next_index_zval(return_value, &el);
+ }
+ }
+ /* }}} */
+diff --git a/kafka_consumer.c b/kafka_consumer.c
+index 8b6c4c2..0c604b6 100644
+--- a/kafka_consumer.c
++++ b/kafka_consumer.c
+@@ -271,7 +271,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, subscribe)
+ object_intern *intern;
+ rd_kafka_topic_partition_list_t *topics;
+ rd_kafka_resp_err_t err;
+- zeval *zv;
++ zval *zv;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &htopics) == FAILURE) {
+ return;
+@@ -288,7 +288,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, subscribe)
+ (zv = rdkafka_hash_get_current_data_ex(htopics, &pos)) != NULL;
+ zend_hash_move_forward_ex(htopics, &pos)) {
+ convert_to_string_ex(zv);
+- rd_kafka_topic_partition_list_add(topics, Z_STRVAL_P(ZEVAL(zv)), RD_KAFKA_PARTITION_UA);
++ rd_kafka_topic_partition_list_add(topics, Z_STRVAL_P(zv), RD_KAFKA_PARTITION_UA);
+ }
+
+ err = rd_kafka_subscribe(intern->rk, topics);
+@@ -334,7 +334,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, getSubscription)
+ array_init_size(return_value, topics->cnt);
+
+ for (i = 0; i < topics->cnt; i++) {
+- add_next_index_string(return_value, topics->elems[i].topic ZEVAL_DUP_CC);
++ add_next_index_string(return_value, topics->elems[i].topic);
+ }
+
+ rd_kafka_topic_partition_list_destroy(topics);
+@@ -785,8 +785,8 @@ PHP_METHOD(RdKafka__KafkaConsumer, queryWatermarkOffsets)
+ return;
+ }
+
+- ZEVAL_DEREF(lowResult);
+- ZEVAL_DEREF(highResult);
++ ZVAL_DEREF(lowResult);
++ ZVAL_DEREF(highResult);
+
+ intern = get_object(getThis());
+ if (!intern) {
+diff --git a/kafka_error_exception.c b/kafka_error_exception.c
+index ea3bdba..5ab27e5 100644
+--- a/kafka_error_exception.c
++++ b/kafka_error_exception.c
+@@ -26,7 +26,6 @@
+ #include "Zend/zend_interfaces.h"
+ #include "Zend/zend_exceptions.h"
+ #include "kafka_error_exception.h"
+-#include "zeval.h"
+
+ zend_class_entry * ce_kafka_error;
+
+diff --git a/kafka_error_exception.h b/kafka_error_exception.h
+index 12068a6..9193877 100644
+--- a/kafka_error_exception.h
++++ b/kafka_error_exception.h
+@@ -17,8 +17,9 @@
+ */
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+
+-#include "zeval.h"
+ #include "librdkafka/rdkafka.h"
++#include "php.h"
++
+ extern zend_class_entry * ce_kafka_error;
+ void kafka_error_minit();
+ void create_kafka_error(zval *return_value, const rd_kafka_error_t *error);
+diff --git a/message.c b/message.c
+index c09bc26..7348971 100644
+--- a/message.c
++++ b/message.c
+@@ -89,16 +89,16 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message)
+ void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size) /* {{{ */
+ {
+ rd_kafka_message_t *msg;
+- zeval zmsg;
++ zval zmsg;
+ int i;
+
+ array_init_size(return_value, size);
+
+ for (i = 0; i < size; i++) {
+ msg = messages[i];
+- MAKE_STD_ZEVAL(zmsg);
+- kafka_message_new(P_ZEVAL(zmsg), msg);
+- add_next_index_zval(return_value, P_ZEVAL(zmsg));
++ ZVAL_NULL(&zmsg);
++ kafka_message_new(&zmsg, msg);
++ add_next_index_zval(return_value, &zmsg);
+ }
+ } /* }}} */
+
+diff --git a/metadata.c b/metadata.c
+index 86cdbf5..7d7a6d1 100644
+--- a/metadata.c
++++ b/metadata.c
+@@ -29,7 +29,6 @@
+ #include "metadata_broker.h"
+ #include "metadata_partition.h"
+ #include "Zend/zend_exceptions.h"
+-#include "zeval.h"
+
+ typedef struct _object_intern {
+ #if PHP_MAJOR_VERSION < 7
+@@ -102,8 +101,8 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+- zeval brokers;
+- zeval topics;
++ zval brokers;
++ zval topics;
+
+ *is_temp = 1;
+
+@@ -114,13 +113,13 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ return Z_ARRVAL(ary);
+ }
+
+- MAKE_STD_ZEVAL(brokers);
+- brokers_collection(P_ZEVAL(brokers), object, intern);
+- add_assoc_zval(&ary, "brokers", P_ZEVAL(brokers));
++ ZVAL_NULL(&brokers);
++ brokers_collection(&brokers, object, intern);
++ add_assoc_zval(&ary, "brokers", &brokers);
+
+- MAKE_STD_ZEVAL(topics);
+- topics_collection(P_ZEVAL(topics), object, intern);
+- add_assoc_zval(&ary, "topics", P_ZEVAL(topics));
++ ZVAL_NULL(&topics);
++ topics_collection(&topics, object, intern);
++ add_assoc_zval(&ary, "topics", &topics);
+
+ add_assoc_long(&ary, "orig_broker_id", intern->metadata->orig_broker_id);
+ rdkafka_add_assoc_string(&ary, "orig_broker_name", intern->metadata->orig_broker_name);
+diff --git a/metadata_broker.c b/metadata_broker.c
+index 540b278..d7df197 100644
+--- a/metadata_broker.c
++++ b/metadata_broker.c
+@@ -27,7 +27,6 @@
+ #include "ext/spl/spl_iterators.h"
+ #include "Zend/zend_interfaces.h"
+ #include "Zend/zend_exceptions.h"
+-#include "zeval.h"
+
+ typedef struct _object_intern {
+ #if PHP_MAJOR_VERSION < 7
+diff --git a/metadata_collection.c b/metadata_collection.c
+index 8b19083..168465f 100644
+--- a/metadata_collection.c
++++ b/metadata_collection.c
+@@ -28,7 +28,6 @@
+ #include "Zend/zend_interfaces.h"
+ #include "metadata_collection.h"
+ #include "Zend/zend_exceptions.h"
+-#include "zeval.h"
+
+ typedef struct _object_intern {
+ #if PHP_MAJOR_VERSION < 7
+@@ -97,7 +96,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ zval ary;
+ object_intern *intern;
+ size_t i;
+- zeval item;
++ zval item;
+
+ *is_temp = 1;
+
+@@ -109,9 +108,9 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ }
+
+ for (i = 0; i < intern->item_cnt; i++) {
+- MAKE_STD_ZEVAL(item);
+- intern->ctor(P_ZEVAL(item), &intern->zmetadata, (char *)intern->items + i * intern->item_size);
+- add_next_index_zval(&ary, P_ZEVAL(item));
++ ZVAL_NULL(&item);
++ intern->ctor(&item, &intern->zmetadata, (char *)intern->items + i * intern->item_size);
++ add_next_index_zval(&ary, &item);
+ }
+
+ return Z_ARRVAL(ary);
+diff --git a/metadata_topic.c b/metadata_topic.c
+index 8a54757..512c83e 100644
+--- a/metadata_topic.c
++++ b/metadata_topic.c
+@@ -29,7 +29,6 @@
+ #include "metadata_partition.h"
+ #include "metadata_collection.h"
+ #include "Zend/zend_exceptions.h"
+-#include "zeval.h"
+
+ typedef struct _object_intern {
+ #if PHP_MAJOR_VERSION < 7
+@@ -98,7 +97,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+- zeval partitions;
++ zval partitions;
+
+ *is_temp = 1;
+
+@@ -111,9 +110,9 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ rdkafka_add_assoc_string(&ary, "topic", intern->metadata_topic->topic);
+
+- MAKE_STD_ZEVAL(partitions);
+- partitions_collection(P_ZEVAL(partitions), object, intern);
+- add_assoc_zval(&ary, "partitions", P_ZEVAL(partitions));
++ ZVAL_NULL(&partitions);
++ partitions_collection(&partitions, object, intern);
++ add_assoc_zval(&ary, "partitions", &partitions);
+
+ add_assoc_long(&ary, "err", intern->metadata_topic->err);
+
+diff --git a/queue.c b/queue.c
+index 3b0c517..0f0dadc 100644
+--- a/queue.c
++++ b/queue.c
+@@ -40,7 +40,7 @@ static void kafka_queue_free(zend_object *object) /* {{{ */
+ kafka_queue_object *intern = get_custom_object(kafka_queue_object, object);
+
+ if (intern->rkqu) {
+- kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ kafka_object *kafka_intern = get_kafka_object(&intern->zrk);
+ if (kafka_intern) {
+ zend_hash_index_del(&kafka_intern->queues, (zend_ulong)intern);
+ }
+diff --git a/queue.h b/queue.h
+index 532621c..3349f18 100644
+--- a/queue.h
++++ b/queue.h
+@@ -21,7 +21,7 @@ typedef struct _kafka_queue_object {
+ zend_object std;
+ #endif
+ rd_kafka_queue_t *rkqu;
+- zeval zrk;
++ zval zrk;
+ #if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+ #endif
+diff --git a/rdkafka.c b/rdkafka.c
+index 2052708..71d0aae 100644
+--- a/rdkafka.c
++++ b/rdkafka.c
+@@ -316,7 +316,7 @@ PHP_METHOD(RdKafka__Consumer, newQueue)
+ #else
+ queue_intern->zrk = getThis();
+ #endif
+- Z_ADDREF_P(P_ZEVAL(queue_intern->zrk));
++ Z_ADDREF_P(&queue_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->queues, (zend_ulong)queue_intern, queue_intern);
+ }
+@@ -492,7 +492,7 @@ PHP_METHOD(RdKafka__Kafka, newTopic)
+ #else
+ topic_intern->zrk = getThis();
+ #endif
+- Z_ADDREF_P(P_ZEVAL(topic_intern->zrk));
++ Z_ADDREF_P(&topic_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->topics, (zend_ulong)topic_intern, topic_intern);
+ }
+@@ -623,8 +623,8 @@ PHP_METHOD(RdKafka__Kafka, queryWatermarkOffsets)
+ return;
+ }
+
+- ZEVAL_DEREF(lowResult);
+- ZEVAL_DEREF(highResult);
++ ZVAL_DEREF(lowResult);
++ ZVAL_DEREF(highResult);
+
+ intern = get_kafka_object(getThis());
+ if (!intern) {
+diff --git a/topic.c b/topic.c
+index 389ae4a..f834ce3 100644
+--- a/topic.c
++++ b/topic.c
+@@ -47,8 +47,8 @@ static void kafka_topic_free(zend_object *object) /* {{{ */
+ {
+ kafka_topic_object *intern = get_custom_object(kafka_topic_object, object);
+
+- if (ZE_ISDEF(intern->zrk) && intern->rkt) {
+- kafka_object *kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ if (Z_TYPE(intern->zrk) != IS_UNDEF && intern->rkt) {
++ kafka_object *kafka_intern = get_kafka_object(&intern->zrk);
+ if (kafka_intern) {
+ zend_hash_index_del(&kafka_intern->topics, (zend_ulong)intern);
+ }
+@@ -80,7 +80,7 @@ static zend_object_value kafka_topic_new(zend_class_entry *class_type) /* {{{ */
+ static void consume_callback(rd_kafka_message_t *msg, void *opaque)
+ {
+ php_callback *cb = (php_callback*) opaque;
+- zeval args[1];
++ zval args[1];
+ TSRMLS_FETCH();
+
+ if (!opaque) {
+@@ -91,9 +91,9 @@ static void consume_callback(rd_kafka_message_t *msg, void *opaque)
+ return;
+ }
+
+- MAKE_STD_ZEVAL(args[0]);
++ ZVAL_NULL(&args[0]);
+
+- kafka_message_new(P_ZEVAL(args[0]), msg);
++ kafka_message_new(&args[0], msg);
+
+ rdkafka_call_function(&cb->fci, &cb->fcc, NULL, 1, args);
+
+@@ -142,7 +142,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeCallback)
+ return;
+ }
+
+- Z_ADDREF_P(P_ZEVAL(cb.fci.function_name));
++ Z_ADDREF_P(&cb.fci.function_name);
+
+ result = rd_kafka_consume_callback(intern->rkt, partition, timeout_ms, consume_callback, &cb);
+
+@@ -191,7 +191,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeQueueStart)
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ kafka_intern = get_kafka_object(&intern->zrk);
+ if (!kafka_intern) {
+ return;
+ }
+@@ -250,7 +250,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStart)
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ kafka_intern = get_kafka_object(&intern->zrk);
+ if (!kafka_intern) {
+ return;
+ }
+@@ -307,7 +307,7 @@ PHP_METHOD(RdKafka__ConsumerTopic, consumeStop)
+ return;
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ kafka_intern = get_kafka_object(&intern->zrk);
+ if (!kafka_intern) {
+ return;
+ }
+@@ -562,7 +562,7 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ HashTable *headersParam = NULL;
+ HashPosition headersParamPos;
+ char *header_key;
+- zeval *header_value;
++ zval *header_value;
+ rd_kafka_headers_t *headers;
+ zend_long timestamp_ms = 0;
+ zend_bool timestamp_ms_is_null = 0;
+@@ -598,15 +598,15 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ headers,
+ header_key,
+ -1, // Auto detect header title length
+- Z_STRVAL_P(ZEVAL(header_value)),
+- Z_STRLEN_P(ZEVAL(header_value))
++ Z_STRVAL_P(header_value),
++ Z_STRLEN_P(header_value)
+ );
+ }
+ } else {
+ headers = rd_kafka_headers_new(0);
+ }
+
+- kafka_intern = get_kafka_object(P_ZEVAL(intern->zrk));
++ kafka_intern = get_kafka_object(&intern->zrk);
+ if (!kafka_intern) {
+ return;
+ }
+diff --git a/topic.h b/topic.h
+index 78beec3..e6bbbd5 100644
+--- a/topic.h
++++ b/topic.h
+@@ -16,14 +16,12 @@
+ +----------------------------------------------------------------------+
+ */
+
+-#include "zeval.h"
+-
+ typedef struct _kafka_topic_object {
+ #if PHP_MAJOR_VERSION < 7
+ zend_object std;
+ #endif
+ rd_kafka_topic_t *rkt;
+- zeval zrk;
++ zval zrk;
+ #if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+ #endif
+diff --git a/topic_partition.c b/topic_partition.c
+index f9a08d9..c71a17b 100644
+--- a/topic_partition.c
++++ b/topic_partition.c
+@@ -29,7 +29,6 @@
+ #include "Zend/zend_exceptions.h"
+ #include "ext/spl/spl_exceptions.h"
+ #include "topic_partition.h"
+-#include "zeval.h"
+
+ typedef kafka_topic_partition_intern object_intern;
+
+@@ -134,17 +133,17 @@ void kafka_topic_partition_init(zval *zobj, char * topic, int32_t partition, int
+ void kafka_topic_partition_list_to_array(zval *return_value, rd_kafka_topic_partition_list_t *list) /* {{{ */
+ {
+ rd_kafka_topic_partition_t *topar;
+- zeval ztopar;
++ zval ztopar;
+ int i;
+
+ array_init_size(return_value, list->cnt);
+
+ for (i = 0; i < list->cnt; i++) {
+ topar = &list->elems[i];
+- MAKE_STD_ZEVAL(ztopar);
+- object_init_ex(P_ZEVAL(ztopar), ce_kafka_topic_partition);
+- kafka_topic_partition_init(P_ZEVAL(ztopar), topar->topic, topar->partition, topar->offset);
+- add_next_index_zval(return_value, P_ZEVAL(ztopar));
++ ZVAL_NULL(&ztopar);
++ object_init_ex(&ztopar, ce_kafka_topic_partition);
++ kafka_topic_partition_init(&ztopar, topar->topic, topar->partition, topar->offset);
++ add_next_index_zval(return_value, &ztopar);
+ }
+ } /* }}} */
+
+@@ -152,7 +151,7 @@ rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int ar
+
+ HashPosition pos;
+ rd_kafka_topic_partition_list_t *list;
+- zeval *zv;
++ zval *zv;
+
+ list = rd_kafka_topic_partition_list_new(zend_hash_num_elements(ary));
+
+@@ -162,7 +161,7 @@ rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int ar
+ kafka_topic_partition_intern *topar_intern;
+ rd_kafka_topic_partition_t *topar;
+
+- if (Z_TYPE_P(ZEVAL(zv)) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(ZEVAL(zv)), ce_kafka_topic_partition)) {
++ if (Z_TYPE_P(zv) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(zv), ce_kafka_topic_partition)) {
+ const char *space;
+ const char *class_name = get_active_class_name(&space);
+ rd_kafka_topic_partition_list_destroy(list);
+@@ -171,11 +170,11 @@ rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int ar
+ argnum,
+ class_name, space,
+ get_active_function_name(),
+- zend_zval_type_name(ZEVAL(zv)));
++ zend_zval_type_name(zv));
+ return NULL;
+ }
+
+- topar_intern = get_topic_partition_object(ZEVAL(zv));
++ topar_intern = get_topic_partition_object(zv);
+ if (!topar_intern) {
+ rd_kafka_topic_partition_list_destroy(list);
+ return NULL;
+diff --git a/zeval.h b/zeval.h
+deleted file mode 100644
+index 74c2711..0000000
+--- a/zeval.h
++++ /dev/null
+@@ -1,71 +0,0 @@
+-#ifndef incl_ZEVAL_H
+-#define incl_ZEVAL_H
+-
+-#ifdef HAVE_CONFIG_H
+-# include "config.h"
+-#endif
+-
+-#include "php.h"
+-
+-/***************************************************************************/
+-#ifdef ZEND_ENGINE_3
+-
+-typedef zval zeval;
+-
+-#define ZEVAL(v) (v)
+-#define P_ZEVAL(v) (&(v))
+-
+-#define MAKE_STD_ZEVAL(v) ZVAL_NULL(&v)
+-#define ZEVAL_UNINIT(v) ZVAL_NULL(v)
+-
+-#define ZE_ISDEF(v) (Z_TYPE(v) != IS_UNDEF)
+-#define ZE_TYPE(v) Z_TYPE(v)
+-#define ZE_BVAL(v) Z_BVAL(v)
+-#define ZE_LVAL(V) Z_LVAL(v)
+-#define ZE_DVAL(v) Z_DVAL(v)
+-#define ZE_STRVAL(v) Z_STRVAL(v)
+-#define ZE_STRLEN(v) Z_STRLEN(v)
+-#define ZE_ARRVAL(v) Z_ARRVAL(v)
+-#define ZE_OBJCE(v) Z_OBJCE(v)
+-
+-#define ZEVAL_DUP_C
+-#define ZEVAL_DUP_CC
+-
+-#define ZEVAL_DEREF(v) ZVAL_DEREF(v)
+-
+-/***************************************************************************/
+-#elif defined(ZEND_ENGINE_2)
+-
+-typedef zval* zeval;
+-
+-#define ZEVAL(v) (*(v))
+-#define P_ZEVAL(v) (v)
+-
+-#define MAKE_STD_ZEVAL(v) MAKE_STD_ZVAL(v)
+-#define ZEVAL_UNINIT(v) (v = NULL)
+-
+-#define ZE_ISDEF(v) (v)
+-#define IS_TRUE 14
+-#define IS_FALSE 15
+-#define ZE_TYPE(v) ((Z_TYPE_P(v) == IS_BOOL) \
+- ? (Z_BVAL_P(v) ? IS_TRUE : IS_FALSE) \
+- : Z_TYPE_P(v))
+-#define ZE_BVAL(v) Z_BVAL_P(v)
+-#define ZE_LVAL(V) Z_LVAL_P(v)
+-#define ZE_DVAL(v) Z_DVAL_P(v)
+-#define ZE_STRVAL(v) Z_STRVAL_P(v)
+-#define ZE_STRLEN(v) Z_STRLEN_P(v)
+-#define ZE_ARRVAL(v) Z_ARRVAL_P(v)
+-#define ZE_OBJCE(v) Z_OBJCE_P(v)
+-
+-#define ZEVAL_DUP_C 1
+-#define ZEVAL_DUP_CC , 1
+-
+-#define ZEVAL_DEREF(v) (v)
+-
+-/***************************************************************************/
+-#else
+-# error "Unknown Zend Engine version"
+-#endif
+-
+-#endif
+From b2af8a5ce918287ded20a6ebc0a3d46c530e2626 Mon Sep 17 00:00:00 2001
+From: Arnaud Le Blanc <arnaud.lb@gmail.com>
+Date: Mon, 7 Dec 2020 12:46:13 +0100
+Subject: [PATCH] Drop remaining php5 compatibility code (#405)
+
+Co-authored-by: Nick <nickjobszh@gmail.com>
+---
+ compat.c | 33 --------
+ compat.h | 33 --------
+ conf.c | 55 +++++--------
+ conf.h | 5 --
+ config.m4 | 2 +-
+ config.w32 | 2 +-
+ fun.c | 6 +-
+ kafka_consumer.c | 27 +++---
+ kafka_error_exception.c | 20 +----
+ message.c | 4 +-
+ metadata.c | 25 ++----
+ metadata_broker.c | 25 ++----
+ metadata_collection.c | 21 ++---
+ metadata_partition.c | 21 ++---
+ metadata_topic.c | 25 ++----
+ php_rdkafka.h | 6 --
+ php_rdkafka_priv.h | 178 ----------------------------------------
+ queue.c | 16 ++--
+ queue.h | 5 --
+ rdkafka.c | 40 +++------
+ topic.c | 35 ++++----
+ topic.h | 5 --
+ topic_partition.c | 24 +++---
+ topic_partition.h | 5 --
+ 24 files changed, 128 insertions(+), 490 deletions(-)
+ delete mode 100644 compat.c
+ delete mode 100644 compat.h
+
+diff --git a/compat.c b/compat.c
+deleted file mode 100644
+index 6643978..0000000
+--- a/compat.c
++++ /dev/null
+@@ -1,33 +0,0 @@
+-/*
+- +----------------------------------------------------------------------+
+- | php-rdkafka |
+- +----------------------------------------------------------------------+
+- | Copyright (c) 2016 Arnaud Le Blanc |
+- +----------------------------------------------------------------------+
+- | This source file is subject to version 3.01 of the PHP license, |
+- | that is bundled with this package in the file LICENSE, and is |
+- | available through the world-wide-web at the following url: |
+- | http://www.php.net/license/3_01.txt |
+- | If you did not receive a copy of the PHP license and are unable to |
+- | obtain it through the world-wide-web, please send a note to |
+- | license@php.net so we can mail you a copy immediately. |
+- +----------------------------------------------------------------------+
+- | Author: Arnaud Le Blanc <arnaud.lb@gmail.com> |
+- +----------------------------------------------------------------------+
+-*/
+-
+-#ifdef HAVE_CONFIG_H
+-#include "config.h"
+-#endif
+-
+-#include "php.h"
+-#include "php_ini.h"
+-
+-#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 4
+-void rdkafka_object_properties_init_53(zend_object *object, zend_class_entry *class_type) /* {{{ */
+-{
+- zval * tmp;
+- zend_hash_copy(object->properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+-}
+-/* }}} */
+-#endif
+diff --git a/compat.h b/compat.h
+deleted file mode 100644
+index c9f8b6d..0000000
+--- a/compat.h
++++ /dev/null
+@@ -1,33 +0,0 @@
+-/*
+- +----------------------------------------------------------------------+
+- | php-rdkafka |
+- +----------------------------------------------------------------------+
+- | Copyright (c) 2016 Arnaud Le Blanc |
+- +----------------------------------------------------------------------+
+- | This source file is subject to version 3.01 of the PHP license, |
+- | that is bundled with this package in the file LICENSE, and is |
+- | available through the world-wide-web at the following url: |
+- | http://www.php.net/license/3_01.txt |
+- | If you did not receive a copy of the PHP license and are unable to |
+- | obtain it through the world-wide-web, please send a note to |
+- | license@php.net so we can mail you a copy immediately. |
+- +----------------------------------------------------------------------+
+- | Author: Arnaud Le Blanc <arnaud.lb@gmail.com> |
+- +----------------------------------------------------------------------+
+-*/
+-
+-#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 4
+-void rdkafka_object_properties_init_53(zend_object *object, zend_class_entry *class_type);
+-#define object_properties_init rdkafka_object_properties_init_53
+-#endif
+-
+-#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 6
+-# define KAFKA_ZVAL_ZVAL(z, zv, copy, dtor) do { \
+- zval * ___z = (z); \
+- zval * ___zv = (zv); \
+- ZVAL_ZVAL(___z, ___zv, copy, dtor); \
+- } while (0)
+-#else
+-# define KAFKA_ZVAL_ZVAL ZVAL_ZVAL
+-#endif
+-
+diff --git a/conf.c b/conf.c
+index 6e814b7..ec171c6 100644
+--- a/conf.c
++++ b/conf.c
+@@ -68,11 +68,7 @@ static void kafka_conf_callback_copy(kafka_conf_callback **to, kafka_conf_callba
+ if (from) {
+ *to = emalloc(sizeof(**to));
+ **to = *from;
+-#if PHP_MAJOR_VERSION >= 7
+ zval_copy_ctor(&(*to)->fci.function_name);
+-#else
+- Z_ADDREF_P((*to)->fci.function_name);
+-#endif
+ }
+ } /* }}} */
+
+@@ -106,22 +102,20 @@ static void kafka_conf_free(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_conf_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_conf_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ kafka_conf_object *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_conf_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -143,7 +137,6 @@ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, voi
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[3];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -157,9 +150,9 @@ static void kafka_conf_error_cb(rd_kafka_t *rk, int err, const char *reason, voi
+ ZVAL_NULL(&args[1]);
+ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+ ZVAL_LONG(&args[1], err);
+- RDKAFKA_ZVAL_STRING(&args[2], reason);
++ ZVAL_STRING(&args[2], reason);
+
+ rdkafka_call_function(&cbs->error->fci, &cbs->error->fcc, NULL, 3, args);
+
+@@ -172,7 +165,6 @@ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[2];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -185,7 +177,7 @@ static void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
+ ZVAL_NULL(&args[0]);
+ ZVAL_NULL(&args[1]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+ kafka_message_new(&args[1], msg);
+
+ rdkafka_call_function(&cbs->dr_msg->fci, &cbs->dr_msg->fcc, NULL, 2, args);
+@@ -198,7 +190,6 @@ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[3];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return 0;
+@@ -212,8 +203,8 @@ static int kafka_conf_stats_cb(rd_kafka_t *rk, char *json, size_t json_len, void
+ ZVAL_NULL(&args[1]);
+ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+- RDKAFKA_ZVAL_STRING(&args[1], json);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_STRING(&args[1], json);
+ ZVAL_LONG(&args[2], json_len);
+
+ rdkafka_call_function(&cbs->stats->fci, &cbs->stats->fcc, NULL, 3, args);
+@@ -229,7 +220,6 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[3];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -250,7 +240,7 @@ static void kafka_conf_rebalance_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_
+ ZVAL_NULL(&args[1]);
+ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+ ZVAL_LONG(&args[1], err);
+ kafka_topic_partition_list_to_array(&args[2], partitions);
+
+@@ -265,7 +255,6 @@ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[2];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -279,7 +268,7 @@ static void kafka_conf_consume_cb(rd_kafka_message_t *msg, void *opaque)
+ ZVAL_NULL(&args[1]);
+
+ kafka_message_new(&args[0], msg);
+- KAFKA_ZVAL_ZVAL(&args[1], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[1], &cbs->zrk, 1, 0);
+
+
+ rdkafka_call_function(&cbs->consume->fci, &cbs->consume->fcc, NULL, 2, args);
+@@ -292,7 +281,6 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+ {
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) opaque;
+ zval args[3];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -306,7 +294,7 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+ ZVAL_NULL(&args[1]);
+ ZVAL_NULL(&args[2]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+ ZVAL_LONG(&args[1], err);
+ kafka_topic_partition_list_to_array(&args[2], partitions);
+
+@@ -320,7 +308,6 @@ static void kafka_conf_offset_commit_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err,
+ static void kafka_conf_log_cb(const rd_kafka_t *rk, int level, const char *facility, const char *message)
+ {
+ zval args[4];
+- TSRMLS_FETCH();
+
+ kafka_conf_callbacks *cbs = (kafka_conf_callbacks*) rd_kafka_opaque(rk);
+
+@@ -333,10 +320,10 @@ static void kafka_conf_log_cb(const rd_kafka_t *rk, int level, const char *facil
+ ZVAL_NULL(&args[2]);
+ ZVAL_NULL(&args[3]);
+
+- KAFKA_ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
++ ZVAL_ZVAL(&args[0], &cbs->zrk, 1, 0);
+ ZVAL_LONG(&args[1], level);
+- RDKAFKA_ZVAL_STRING(&args[2], facility);
+- RDKAFKA_ZVAL_STRING(&args[3], message);
++ ZVAL_STRING(&args[2], facility);
++ ZVAL_STRING(&args[3], message);
+
+ rdkafka_call_function(&cbs->log->fci, &cbs->log->fcc, NULL, 4, args);
+
+@@ -409,7 +396,7 @@ PHP_METHOD(RdKafka__Conf, dump)
+ for (i = 0; i < cntp; i+=2) {
+ const char *key = dump[i];
+ const char *value = dump[i+1];
+- rdkafka_add_assoc_string(return_value, (char*)key, (char*)value);
++ add_assoc_string(return_value, (char*)key, (char*)value);
+ }
+
+ rd_kafka_conf_dump_free(dump, cntp);
+@@ -427,9 +414,9 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__Conf, set)
+ {
+ char *name;
+- arglen_t name_len;
++ size_t name_len;
+ char *value;
+- arglen_t value_len;
++ size_t value_len;
+ kafka_conf_object *intern;
+ rd_kafka_conf_res_t ret = 0;
+ char errstr[512];
+@@ -858,8 +845,8 @@ void kafka_conf_minit()
+ zend_class_entry tmpce;
+
+ handlers = kafka_default_object_handlers;
+- set_object_handler_free_obj(&handlers, kafka_conf_free);
+- set_object_handler_offset(&handlers, XtOffsetOf(kafka_conf_object, std));
++ handlers.free_obj = kafka_conf_free;
++ handlers.offset = XtOffsetOf(kafka_conf_object, std);
+
+ INIT_NS_CLASS_ENTRY(tmpce, "RdKafka", "Conf", kafka_conf_fe);
+ ce_kafka_conf = zend_register_internal_class(&tmpce);
+diff --git a/conf.h b/conf.h
+index 4bf13b2..673e14c 100644
+--- a/conf.h
++++ b/conf.h
+@@ -49,18 +49,13 @@ typedef struct _kafka_conf_callbacks {
+ } kafka_conf_callbacks;
+
+ typedef struct _kafka_conf_object {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ kafka_conf_type type;
+ union {
+ rd_kafka_conf_t *conf;
+ rd_kafka_topic_conf_t *topic_conf;
+ } u;
+ kafka_conf_callbacks cbs;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } kafka_conf_object;
+
+ kafka_conf_object * get_kafka_conf_object(zval *zconf);
+diff --git a/config.m4 b/config.m4
+index 3f4a654..9df6b31 100644
+--- a/config.m4
++++ b/config.m4
+@@ -27,7 +27,7 @@ if test "$PHP_RDKAFKA" != "no"; then
+
+ PHP_ADD_INCLUDE($RDKAFKA_DIR/include)
+
+- SOURCES="rdkafka.c metadata.c metadata_broker.c metadata_topic.c metadata_partition.c metadata_collection.c compat.c conf.c topic.c queue.c message.c fun.c kafka_consumer.c topic_partition.c"
++ SOURCES="rdkafka.c metadata.c metadata_broker.c metadata_topic.c metadata_partition.c metadata_collection.c conf.c topic.c queue.c message.c fun.c kafka_consumer.c topic_partition.c"
+
+ LIBNAME=rdkafka
+ LIBSYMBOL=rd_kafka_new
+diff --git a/config.w32 b/config.w32
+index 451692e..837ef38 100644
+--- a/config.w32
++++ b/config.w32
+@@ -11,7 +11,7 @@ if (PHP_RDKAFKA != "no") {
+ AC_DEFINE('HAVE_RD_KAFKA_GET_ERR_DESCS', 1, '');
+ AC_DEFINE('HAVE_NEW_KAFKA_CONSUMER', 1, '');
+ EXTENSION("rdkafka", "rdkafka.c metadata.c metadata_broker.c metadata_topic.c \
+- metadata_partition.c metadata_collection.c compat.c conf.c \
++ metadata_partition.c metadata_collection.c conf.c \
+ topic.c queue.c message.c fun.c kafka_consumer.c topic_partition.c kafka_error_exception.c");
+
+ AC_DEFINE('HAVE_RDKAFKA', 1, '');
+diff --git a/fun.c b/fun.c
+index 77053ec..d73e202 100644
+--- a/fun.c
++++ b/fun.c
+@@ -83,12 +83,12 @@ PHP_FUNCTION(rd_kafka_get_err_descs)
+ array_init(&el);
+ add_assoc_long(&el, "code", desc->code);
+ if (desc->name) {
+- rdkafka_add_assoc_string(&el, "name", (char*) desc->name);
++ add_assoc_string(&el, "name", (char*) desc->name);
+ } else {
+ add_assoc_null(&el, "name");
+ }
+ if (desc->desc) {
+- rdkafka_add_assoc_string(&el, "desc", (char*) desc->desc);
++ add_assoc_string(&el, "desc", (char*) desc->desc);
+ }else {
+ add_assoc_null(&el, "desc");
+ }
+@@ -112,7 +112,7 @@ PHP_FUNCTION(rd_kafka_err2str)
+ errstr = rd_kafka_err2str(err);
+
+ if (errstr) {
+- RDKAFKA_RETURN_STRING(errstr);
++ RETURN_STRING(errstr);
+ }
+ }
+ /* }}} */
+diff --git a/kafka_consumer.c b/kafka_consumer.c
+index 0c604b6..8cc4b9d 100644
+--- a/kafka_consumer.c
++++ b/kafka_consumer.c
+@@ -33,14 +33,9 @@
+ #include "metadata.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ rd_kafka_t *rk;
+ kafka_conf_callbacks cbs;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static zend_class_entry * ce;
+@@ -66,22 +61,20 @@ static void kafka_consumer_free(zend_object *object) /* {{{ */
+ kafka_conf_callbacks_dtor(&intern->cbs);
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_consumer_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_consumer_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_consumer_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -285,7 +278,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, subscribe)
+ topics = rd_kafka_topic_partition_list_new(zend_hash_num_elements(htopics));
+
+ for (zend_hash_internal_pointer_reset_ex(htopics, &pos);
+- (zv = rdkafka_hash_get_current_data_ex(htopics, &pos)) != NULL;
++ (zv = zend_hash_get_current_data_ex(htopics, &pos)) != NULL;
+ zend_hash_move_forward_ex(htopics, &pos)) {
+ convert_to_string_ex(zv);
+ rd_kafka_topic_partition_list_add(topics, Z_STRVAL_P(zv), RD_KAFKA_PARTITION_UA);
+@@ -593,7 +586,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__KafkaConsumer, newTopic)
+ {
+ char *topic;
+- arglen_t topic_len;
++ size_t topic_len;
+ rd_kafka_topic_t *rkt;
+ object_intern *intern;
+ kafka_topic_object *topic_intern;
+@@ -775,7 +768,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, queryWatermarkOffsets)
+ {
+ object_intern *intern;
+ char *topic;
+- arglen_t topic_length;
++ size_t topic_length;
+ long low, high;
+ zend_long partition, timeout;
+ zval *lowResult, *highResult;
+@@ -834,8 +827,8 @@ void kafka_kafka_consumer_minit() /* {{{ */
+ ce->create_object = kafka_consumer_new;
+
+ handlers = kafka_default_object_handlers;
+- set_object_handler_free_obj(&handlers, kafka_consumer_free);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = kafka_consumer_free;
++ handlers.offset = XtOffsetOf(object_intern, std);
+
+ zend_declare_property_null(ce, ZEND_STRL("error_cb"), ZEND_ACC_PRIVATE);
+ zend_declare_property_null(ce, ZEND_STRL("rebalance_cb"), ZEND_ACC_PRIVATE);
+diff --git a/kafka_error_exception.c b/kafka_error_exception.c
+index 5ab27e5..b1cd9a8 100644
+--- a/kafka_error_exception.c
++++ b/kafka_error_exception.c
+@@ -57,7 +57,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__KafkaErrorException, __construct)
+ {
+ char *message, *error_string = "";
+- arglen_t message_length = 0, error_string_length = 0;
++ size_t message_length = 0, error_string_length = 0;
+ zend_bool isFatal = 0, isRetriable = 0, transactionRequiresAbort = 0;
+ zend_long code = 0;
+
+@@ -94,12 +94,8 @@ PHP_METHOD(RdKafka__KafkaErrorException, getErrorString)
+ return;
+ }
+
+-#if PHP_MAJOR_VERSION >= 7
+ ZVAL_DEREF(res);
+ ZVAL_COPY(return_value, res);
+-#else
+- RETURN_ZVAL(res, 1, 0)
+-#endif
+ }
+ /* }}} */
+
+@@ -120,16 +116,12 @@ PHP_METHOD(RdKafka__KafkaErrorException, isFatal)
+
+ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), 0);
+
+-#if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+ }
+
+ ZVAL_DEREF(res);
+ ZVAL_COPY(return_value, res);
+-#else
+- RETURN_ZVAL(res, 1, 0)
+-#endif
+ }
+ /* }}} */
+
+@@ -149,16 +141,12 @@ PHP_METHOD(RdKafka__KafkaErrorException, isRetriable)
+
+ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), 0);
+
+-#if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+ }
+
+ ZVAL_DEREF(res);
+ ZVAL_COPY(return_value, res);
+-#else
+- RETURN_ZVAL(res, 1, 0)
+-#endif
+ }
+ /* }}} */
+
+@@ -178,16 +166,12 @@ PHP_METHOD(RdKafka__KafkaErrorException, transactionRequiresAbort)
+
+ res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), 0);
+
+-#if PHP_MAJOR_VERSION >= 7
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+ }
+
+ ZVAL_DEREF(res);
+ ZVAL_COPY(return_value, res);
+-#else
+- RETURN_ZVAL(res, 1, 0)
+-#endif
+ }
+ /* }}} */
+
+@@ -205,7 +189,7 @@ void kafka_error_minit() /* {{{ */
+ zend_class_entry ce;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaErrorException", kafka_error_fe);
+- ce_kafka_error = rdkafka_register_internal_class_ex(&ce, ce_kafka_exception);
++ ce_kafka_error = zend_register_internal_class_ex(&ce, ce_kafka_exception);
+
+ zend_declare_property_null(ce_kafka_error, ZEND_STRL("error_string"), ZEND_ACC_PRIVATE);
+ zend_declare_property_bool(ce_kafka_error, ZEND_STRL("isFatal"), 0, ZEND_ACC_PRIVATE);
+diff --git a/message.c b/message.c
+index 7348971..a6ed916 100644
+--- a/message.c
++++ b/message.c
+@@ -77,7 +77,7 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message)
+ if (header_response != RD_KAFKA_RESP_ERR_NO_ERROR) {
+ break;
+ }
+- rdkafka_add_assoc_stringl(&headers_array, header_name, (const char*)header_value, header_size);
++ add_assoc_stringl(&headers_array, header_name, (const char*)header_value, header_size);
+ }
+ zend_update_property(NULL, return_value, ZEND_STRL("headers"), &headers_array);
+ zval_ptr_dtor(&headers_array);
+@@ -128,7 +128,7 @@ PHP_METHOD(RdKafka__Message, errstr)
+ errstr = rd_kafka_err2str(Z_LVAL_P(zerr));
+
+ if (errstr) {
+- RDKAFKA_RETURN_STRING(errstr);
++ RETURN_STRING(errstr);
+ }
+
+ zpayload = rdkafka_read_property(NULL, getThis(), ZEND_STRL("payload"), 0);
+diff --git a/metadata.c b/metadata.c
+index 7d7a6d1..a43123c 100644
+--- a/metadata.c
++++ b/metadata.c
+@@ -31,13 +31,8 @@
+ #include "Zend/zend_exceptions.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ const rd_kafka_metadata_t *metadata;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static HashTable *get_debug_info(zval *object, int *is_temp);
+@@ -64,22 +59,20 @@ static void kafka_metadata_free(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_metadata_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_metadata_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_metadata_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -122,7 +115,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ add_assoc_zval(&ary, "topics", &topics);
+
+ add_assoc_long(&ary, "orig_broker_id", intern->metadata->orig_broker_id);
+- rdkafka_add_assoc_string(&ary, "orig_broker_name", intern->metadata->orig_broker_name);
++ add_assoc_string(&ary, "orig_broker_name", intern->metadata->orig_broker_name);
+
+ return Z_ARRVAL(ary);
+ }
+@@ -170,7 +163,7 @@ PHP_METHOD(RdKafka__Metadata, getOrigBrokerName)
+ return;
+ }
+
+- RDKAFKA_RETURN_STRING(intern->metadata->orig_broker_name);
++ RETURN_STRING(intern->metadata->orig_broker_name);
+ }
+ /* }}} */
+
+@@ -238,8 +231,8 @@ void kafka_metadata_minit()
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, kafka_metadata_free);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = kafka_metadata_free;
++ handlers.offset = XtOffsetOf(object_intern, std);
+
+ kafka_metadata_topic_minit();
+ kafka_metadata_broker_minit();
+diff --git a/metadata_broker.c b/metadata_broker.c
+index d7df197..db9b4e3 100644
+--- a/metadata_broker.c
++++ b/metadata_broker.c
+@@ -29,14 +29,9 @@
+ #include "Zend/zend_exceptions.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ zval zmetadata;
+ const rd_kafka_metadata_broker_t *metadata_broker;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static HashTable *get_debug_info(zval *object, int *is_temp);
+@@ -53,23 +48,21 @@ static void free_object(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
++static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -102,7 +95,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ }
+
+ add_assoc_long(&ary, "id", intern->metadata_broker->id);
+- rdkafka_add_assoc_string(&ary, "host", intern->metadata_broker->host);
++ add_assoc_string(&ary, "host", intern->metadata_broker->host);
+ add_assoc_long(&ary, "port", intern->metadata_broker->port);
+
+ return Z_ARRVAL(ary);
+@@ -151,7 +144,7 @@ PHP_METHOD(RdKafka__Metadata__Broker, getHost)
+ return;
+ }
+
+- RDKAFKA_RETURN_STRING(intern->metadata_broker->host);
++ RETURN_STRING(intern->metadata_broker->host);
+ }
+ /* }}} */
+
+@@ -195,8 +188,8 @@ void kafka_metadata_broker_minit()
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, free_object);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = free_object;
++ handlers.offset = XtOffsetOf(object_intern, std);
+ }
+
+ void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *data)
+diff --git a/metadata_collection.c b/metadata_collection.c
+index 168465f..460b3bc 100644
+--- a/metadata_collection.c
++++ b/metadata_collection.c
+@@ -30,18 +30,13 @@
+ #include "Zend/zend_exceptions.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ zval zmetadata;
+ const void *items;
+ size_t item_cnt;
+ size_t item_size;
+ size_t position;
+ kafka_metadata_collection_ctor_t ctor;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static HashTable *get_debug_info(zval *object, int *is_temp);
+@@ -58,22 +53,20 @@ static void free_object(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
++static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -286,8 +279,8 @@ void kafka_metadata_collection_minit()
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, free_object);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = free_object;
++ handlers.offset = XtOffsetOf(object_intern, std);
+ }
+
+ void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor)
+diff --git a/metadata_partition.c b/metadata_partition.c
+index 70b7430..6f5f08f 100644
+--- a/metadata_partition.c
++++ b/metadata_partition.c
+@@ -30,14 +30,9 @@
+ #include "metadata_collection.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ zval zmetadata;
+ const rd_kafka_metadata_partition_t *metadata_partition;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static HashTable *get_debug_info(zval *object, int *is_temp);
+@@ -54,22 +49,20 @@ static void free_object(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
++static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -249,8 +242,8 @@ void kafka_metadata_partition_minit()
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, free_object);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = free_object;
++ handlers.offset = XtOffsetOf(object_intern, std);
+ }
+
+ void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *data)
+diff --git a/metadata_topic.c b/metadata_topic.c
+index 512c83e..9830beb 100644
+--- a/metadata_topic.c
++++ b/metadata_topic.c
+@@ -31,14 +31,9 @@
+ #include "Zend/zend_exceptions.h"
+
+ typedef struct _object_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ zval zmetadata;
+ const rd_kafka_metadata_topic_t *metadata_topic;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } object_intern;
+
+ static HashTable *get_debug_info(zval *object, int *is_temp);
+@@ -60,22 +55,20 @@ static void free_object(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
++static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -108,7 +101,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ return Z_ARRVAL(ary);
+ }
+
+- rdkafka_add_assoc_string(&ary, "topic", intern->metadata_topic->topic);
++ add_assoc_string(&ary, "topic", intern->metadata_topic->topic);
+
+ ZVAL_NULL(&partitions);
+ partitions_collection(&partitions, object, intern);
+@@ -139,7 +132,7 @@ PHP_METHOD(RdKafka__Metadata__Topic, getTopic)
+ return;
+ }
+
+- RDKAFKA_RETURN_STRING(intern->metadata_topic->topic);
++ RETURN_STRING(intern->metadata_topic->topic);
+ }
+ /* }}} */
+
+@@ -207,8 +200,8 @@ void kafka_metadata_topic_minit()
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, free_object);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = free_object;
++ handlers.offset = XtOffsetOf(object_intern, std);
+ }
+
+ void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *data)
+diff --git a/php_rdkafka.h b/php_rdkafka.h
+index 1041b1c..77b40c8 100644
+--- a/php_rdkafka.h
++++ b/php_rdkafka.h
+@@ -22,7 +22,6 @@
+ #define PHP_RDKAFKA_H
+
+ #include "librdkafka/rdkafka.h"
+-#include "compat.h"
+ #include "conf.h"
+
+ #ifndef PHP_FE_END
+@@ -30,18 +29,13 @@
+ #endif
+
+ typedef struct _kafka_object {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ rd_kafka_type_t type;
+ rd_kafka_t *rk;
+ kafka_conf_callbacks cbs;
+ HashTable consuming;
+ HashTable topics;
+ HashTable queues;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } kafka_object;
+
+ PHP_METHOD(RdKafka, __construct);
+diff --git a/php_rdkafka_priv.h b/php_rdkafka_priv.h
+index d00a8eb..a2d44cf 100644
+--- a/php_rdkafka_priv.h
++++ b/php_rdkafka_priv.h
+@@ -19,22 +19,6 @@
+ #ifndef PHP_RDKAFKA_PRIV_H
+ #define PHP_RDKAFKA_PRIV_H
+
+-#if PHP_MAJOR_VERSION >= 7
+-
+-typedef zend_object* zend_object_value;
+-
+-typedef size_t arglen_t;
+-
+-#define STORE_OBJECT(retval, intern, dtor, free, clone) do { \
+- retval = &intern->std; \
+-} while (0)
+-
+-#define SET_OBJECT_HANDLERS(retval, _handlers) do { \
+- retval->handlers = _handlers; \
+-} while (0)
+-
+-#define alloc_object(intern, ce) ecalloc(1, sizeof(*intern) + zend_object_properties_size(ce))
+-
+ static inline zval * is_zval(zval * zv) {
+ return zv;
+ }
+@@ -49,22 +33,6 @@ static inline zend_object * is_zend_object(zend_object * object) {
+ #define get_custom_object(type, object) \
+ ((type*)((char *)is_zend_object(object) - XtOffsetOf(type, std)))
+
+-#define free_custom_object(object) /* no-op */
+-
+-static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce)
+-{
+- return zend_register_internal_class_ex(class_entry, parent_ce);
+-}
+-
+-static inline void set_object_handler_free_obj(zend_object_handlers * handlers, zend_object_free_obj_t free_obj)
+-{
+- handlers->free_obj = free_obj;
+-}
+-static inline void set_object_handler_offset(zend_object_handlers * handlers, size_t offset)
+-{
+- handlers->offset = offset;
+-}
+-
+ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval *retval, uint32_t param_count, zval params[])
+ {
+ int local_retval;
+@@ -94,11 +62,6 @@ static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object,
+ return zend_read_property(scope, object, name, name_length, silent, &rv);
+ }
+
+-static inline zval *rdkafka_hash_get_current_data_ex(HashTable *ht, HashPosition *pos)
+-{
+- return zend_hash_get_current_data_ex(ht, pos);
+-}
+-
+ static inline char *rdkafka_hash_get_current_key_ex(HashTable *ht, HashPosition *pos)
+ {
+ zend_string* key;
+@@ -111,147 +74,6 @@ static inline char *rdkafka_hash_get_current_key_ex(HashTable *ht, HashPosition
+ return NULL;
+ }
+
+-#define rdkafka_add_assoc_string(arg, key, str) add_assoc_string(arg, key, str)
+-
+-#define rdkafka_add_assoc_stringl(arg, key, str, str_length) add_assoc_stringl(arg, key, str, str_length)
+-
+-#define RDKAFKA_RETURN_STRING(str) RETURN_STRING(str)
+-#define RDKAFKA_ZVAL_STRING(zv, str) ZVAL_STRING(zv, str)
+-#else /* PHP < 7 */
+-
+-typedef long zend_long;
+-#define ZEND_LONG_FMT "%ld"
+-
+-typedef int arglen_t;
+-
+-#define STORE_OBJECT(retval, intern, dtor, free, clone) do { \
+- void (*___free_object_storage)(zend_object *object) = free; \
+- retval.handle = zend_objects_store_put(&intern->std, dtor, (zend_objects_free_object_storage_t)___free_object_storage, clone); \
+-} while (0)
+-
+-#define SET_OBJECT_HANDLERS(retval, _handlers) do { \
+- retval.handlers = _handlers; \
+-} while (0)
+-
+-#define alloc_object(intern, ce) ecalloc(1, sizeof(*intern))
+-
+-#define get_custom_object_zval(type, zobject) \
+- ((type*)zend_object_store_get_object(zobject))
+-
+-#define get_custom_object(type, object) \
+- ((type*)object)
+-
+-#define free_custom_object(object) efree(object)
+-
+-static inline void *zend_hash_str_add_ptr(HashTable *ht, const char *str, size_t len, void *pData)
+-{
+- void *pDest;
+- zend_hash_add(ht, str, len, &pData, sizeof(pData), &pDest);
+- return pDest;
+-}
+-
+-static inline int zend_hash_str_del(HashTable *ht, const char *str, size_t len)
+-{
+- return zend_hash_del(ht, str, len);
+-}
+-
+-static inline zend_bool zend_hash_str_exists(const HashTable *ht, const char *str, size_t len)
+-{
+- return zend_hash_exists(ht, str, len);
+-}
+-
+-static inline void *zend_hash_index_add_ptr(HashTable *ht, zend_ulong h, void *pData)
+-{
+- void *pDest;
+- zend_hash_index_update(ht, h, &pData, sizeof(pData), &pDest);
+- return pDest;
+-}
+-
+-static inline zend_class_entry *rdkafka_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce)
+-{
+- return zend_register_internal_class_ex(class_entry, parent_ce, NULL);
+-}
+-
+-typedef void (*zend_object_free_obj_t)(zend_object *object);
+-static inline void set_object_handler_free_obj(zend_object_handlers * handlers, zend_object_free_obj_t free_obj)
+-{
+- /* no-op */
+-}
+-
+-static inline void set_object_handler_offset(zend_object_handlers * handlers, size_t offset)
+-{
+- /* no-op */
+-}
+-
+-static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval **retval, uint32_t param_count, zval *params[])
+-{
+- uint32_t i;
+- int local_retval;
+- zval *local_retval_zv;
+- zval ***params_array;
+-
+- if (retval) {
+- local_retval = 0;
+- } else {
+- local_retval = 1;
+- retval = &local_retval_zv;
+- }
+-
+- params_array = (zval ***) emalloc(sizeof(zval **)*param_count);
+- for (i = 0; i < param_count; i++) {
+- params_array[i] = &params[i];
+- }
+-
+- fci->retval_ptr_ptr = retval;
+- fci->params = params_array;
+- fci->param_count = param_count;
+-
+- zend_call_function(fci, fci_cache);
+-
+- if (local_retval && *retval) {
+- zval_ptr_dtor(retval);
+- }
+-
+- efree(params_array);
+-}
+-
+-static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent)
+-{
+- return zend_read_property(scope, object, name, name_length, silent);
+-}
+-
+-static inline zval **rdkafka_hash_get_current_data_ex(HashTable *ht, HashPosition *pos)
+-{
+- zval **zv;
+-
+- if (zend_hash_get_current_data_ex(ht, (void**)&zv, pos) == SUCCESS) {
+- return zv;
+- }
+-
+- return NULL;
+-}
+-
+-static inline char **rdkafka_hash_get_current_key_ex(HashTable *ht, HashPosition *pos)
+-{
+- char *key = NULL;
+- uint klen;
+- ulong index;
+-
+- if (zend_hash_get_current_key_ex(ht, &key, &klen, &index, 0, pos) == HASH_KEY_IS_STRING) {
+- return key;
+- }
+-
+- return NULL;
+-}
+-
+-#define rdkafka_add_assoc_string(arg, key, str) add_assoc_string(arg, key, str, 1)
+-
+-#define rdkafka_add_assoc_stringl(arg, key, str, str_length) add_assoc_stringl(arg, key, str, str_length, 1)
+-
+-#define RDKAFKA_RETURN_STRING(str) RETURN_STRING(str, 1)
+-#define RDKAFKA_ZVAL_STRING(zv, str) ZVAL_STRING(zv, str, 1)
+-#endif
+-
+ kafka_object * get_kafka_object(zval *zrk);
+ void add_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t partition);
+ void del_consuming_toppar(kafka_object * intern, rd_kafka_topic_t * rkt, int32_t partition);
+diff --git a/queue.c b/queue.c
+index 0f0dadc..99ab609 100644
+--- a/queue.c
++++ b/queue.c
+@@ -47,22 +47,20 @@ static void kafka_queue_free(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_queue_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_queue_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ kafka_queue_object *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_queue_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -134,8 +132,8 @@ void kafka_queue_minit() { /* {{{ */
+ zend_class_entry ce;
+
+ handlers = kafka_default_object_handlers;
+- set_object_handler_free_obj(&handlers, kafka_queue_free);
+- set_object_handler_offset(&handlers, XtOffsetOf(kafka_queue_object, std));
++ handlers.free_obj = kafka_queue_free;
++ handlers.offset = XtOffsetOf(kafka_queue_object, std);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Queue", kafka_queue_fe);
+ ce_kafka_queue = zend_register_internal_class(&ce);
+diff --git a/queue.h b/queue.h
+index 3349f18..79e8b3c 100644
+--- a/queue.h
++++ b/queue.h
+@@ -17,14 +17,9 @@
+ */
+
+ typedef struct _kafka_queue_object {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ rd_kafka_queue_t *rkqu;
+ zval zrk;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } kafka_queue_object;
+
+ void kafka_queue_minit();
+diff --git a/rdkafka.c b/rdkafka.c
+index 71d0aae..5d97b22 100644
+--- a/rdkafka.c
++++ b/rdkafka.c
+@@ -93,8 +93,6 @@ static void kafka_free(zend_object *object) /* {{{ */
+ kafka_conf_callbacks_dtor(&intern->cbs);
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+@@ -159,17 +157,17 @@ static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf) /* {{{
+ }
+ /* }}} */
+
+-static zend_object_value kafka_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ kafka_object *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &kafka_object_handlers);
++ retval = &intern->std;
++ retval->handlers = &kafka_object_handlers;
+
+ return retval;
+ }
+@@ -311,11 +309,7 @@ PHP_METHOD(RdKafka__Consumer, newQueue)
+ // Keep a reference to the parent Kafka object, attempts to ensure that
+ // the Queue object is destroyed before the Kafka object.
+ // This avoids rd_kafka_destroy() hanging.
+-#if PHP_MAJOR_VERSION >= 7
+ queue_intern->zrk = *getThis();
+-#else
+- queue_intern->zrk = getThis();
+-#endif
+ Z_ADDREF_P(&queue_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->queues, (zend_ulong)queue_intern, queue_intern);
+@@ -338,7 +332,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__Kafka, addBrokers)
+ {
+ char *broker_list;
+- arglen_t broker_list_len;
++ size_t broker_list_len;
+ kafka_object *intern;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &broker_list, &broker_list_len) == FAILURE) {
+@@ -435,7 +429,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__Kafka, newTopic)
+ {
+ char *topic;
+- arglen_t topic_len;
++ size_t topic_len;
+ rd_kafka_topic_t *rkt;
+ kafka_object *intern;
+ kafka_topic_object *topic_intern;
+@@ -487,11 +481,7 @@ PHP_METHOD(RdKafka__Kafka, newTopic)
+ }
+
+ topic_intern->rkt = rkt;
+-#if PHP_MAJOR_VERSION >= 7
+ topic_intern->zrk = *getThis();
+-#else
+- topic_intern->zrk = getThis();
+-#endif
+ Z_ADDREF_P(&topic_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->topics, (zend_ulong)topic_intern, topic_intern);
+@@ -613,7 +603,7 @@ PHP_METHOD(RdKafka__Kafka, queryWatermarkOffsets)
+ {
+ kafka_object *intern;
+ char *topic;
+- arglen_t topic_length;
++ size_t topic_length;
+ long low, high;
+ zend_long partition, timeout;
+ zval *lowResult, *highResult;
+@@ -935,10 +925,6 @@ void register_err_constants(INIT_FUNC_ARGS) /* {{{ */
+ len = sizeof(buf)-1;
+ }
+
+-#if PHP_MAJOR_VERSION < 7
+- len += 1;
+-#endif
+-
+ zend_register_long_constant(buf, len, desc->code, CONST_CS | CONST_PERSISTENT, module_number);
+ }
+ } /* }}} */
+@@ -985,8 +971,8 @@ PHP_MINIT_FUNCTION(rdkafka)
+ kafka_default_object_handlers.clone_obj = NULL;
+
+ kafka_object_handlers = kafka_default_object_handlers;
+- set_object_handler_free_obj(&kafka_object_handlers, kafka_free);
+- set_object_handler_offset(&kafka_object_handlers, XtOffsetOf(kafka_object, std));
++ kafka_object_handlers.free_obj = kafka_free;
++ kafka_object_handlers.offset = XtOffsetOf(kafka_object, std);
+
+ INIT_CLASS_ENTRY(ce, "RdKafka", kafka_fe);
+ ce_kafka = zend_register_internal_class(&ce);
+@@ -997,13 +983,13 @@ PHP_MINIT_FUNCTION(rdkafka)
+ zend_declare_property_null(ce_kafka, ZEND_STRL("dr_cb"), ZEND_ACC_PRIVATE);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Consumer", kafka_consumer_fe);
+- ce_kafka_consumer = rdkafka_register_internal_class_ex(&ce, ce_kafka);
++ ce_kafka_consumer = zend_register_internal_class_ex(&ce, ce_kafka);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Producer", kafka_producer_fe);
+- ce_kafka_producer = rdkafka_register_internal_class_ex(&ce, ce_kafka);
++ ce_kafka_producer = zend_register_internal_class_ex(&ce, ce_kafka);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Exception", NULL);
+- ce_kafka_exception = rdkafka_register_internal_class_ex(&ce, zend_exception_get_default());
++ ce_kafka_exception = zend_register_internal_class_ex(&ce, zend_exception_get_default());
+
+ kafka_conf_minit();
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+diff --git a/topic.c b/topic.c
+index f834ce3..78887a3 100644
+--- a/topic.c
++++ b/topic.c
+@@ -55,22 +55,20 @@ static void kafka_topic_free(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value kafka_topic_new(zend_class_entry *class_type) /* {{{ */
++static zend_object *kafka_topic_new(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ kafka_topic_object *intern;
+
+- intern = alloc_object(intern, class_type);
++ intern = zend_object_alloc(sizeof(*intern), class_type);
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, kafka_topic_free, NULL);
+- SET_OBJECT_HANDLERS(retval, &object_handlers);
++ retval = &intern->std;
++ retval->handlers = &object_handlers;
+
+ return retval;
+ }
+@@ -81,7 +79,6 @@ static void consume_callback(rd_kafka_message_t *msg, void *opaque)
+ {
+ php_callback *cb = (php_callback*) opaque;
+ zval args[1];
+- TSRMLS_FETCH();
+
+ if (!opaque) {
+ return;
+@@ -502,9 +499,9 @@ PHP_METHOD(RdKafka__ProducerTopic, produce)
+ zend_long partition;
+ zend_long msgflags;
+ char *payload = NULL;
+- arglen_t payload_len = 0;
++ size_t payload_len = 0;
+ char *key = NULL;
+- arglen_t key_len = 0;
++ size_t key_len = 0;
+ int ret;
+ rd_kafka_resp_err_t err;
+ kafka_topic_object *intern;
+@@ -553,9 +550,9 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ zend_long partition;
+ zend_long msgflags;
+ char *payload = NULL;
+- arglen_t payload_len = 0;
++ size_t payload_len = 0;
+ char *key = NULL;
+- arglen_t key_len = 0;
++ size_t key_len = 0;
+ rd_kafka_resp_err_t err;
+ kafka_topic_object *intern;
+ kafka_object *kafka_intern;
+@@ -590,7 +587,7 @@ PHP_METHOD(RdKafka__ProducerTopic, producev)
+ if (headersParam != NULL && zend_hash_num_elements(headersParam) > 0) {
+ headers = rd_kafka_headers_new(zend_hash_num_elements(headersParam));
+ for (zend_hash_internal_pointer_reset_ex(headersParam, &headersParamPos);
+- (header_value = rdkafka_hash_get_current_data_ex(headersParam, &headersParamPos)) != NULL &&
++ (header_value = zend_hash_get_current_data_ex(headersParam, &headersParamPos)) != NULL &&
+ (header_key = rdkafka_hash_get_current_key_ex(headersParam, &headersParamPos)) != NULL;
+ zend_hash_move_forward_ex(headersParam, &headersParamPos)) {
+ convert_to_string_ex(header_value);
+@@ -659,7 +656,7 @@ PHP_METHOD(RdKafka__Topic, getName)
+ return;
+ }
+
+- RDKAFKA_RETURN_STRING(rd_kafka_topic_name(intern->rkt));
++ RETURN_STRING(rd_kafka_topic_name(intern->rkt));
+ }
+ /* }}} */
+
+@@ -674,8 +671,8 @@ void kafka_topic_minit() { /* {{{ */
+
+ memcpy(&object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+ object_handlers.clone_obj = NULL;
+- set_object_handler_free_obj(&object_handlers, kafka_topic_free);
+- set_object_handler_offset(&object_handlers, XtOffsetOf(kafka_topic_object, std));
++ object_handlers.free_obj = kafka_topic_free;
++ object_handlers.offset = XtOffsetOf(kafka_topic_object, std);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Topic", kafka_topic_fe);
+ ce_kafka_topic = zend_register_internal_class(&ce);
+@@ -683,11 +680,11 @@ void kafka_topic_minit() { /* {{{ */
+ ce_kafka_topic->create_object = kafka_topic_new;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ConsumerTopic", kafka_consumer_topic_fe);
+- ce_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
++ ce_kafka_consumer_topic = zend_register_internal_class_ex(&ce, ce_kafka_topic);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaConsumerTopic", kafka_kafka_consumer_topic_fe);
+- ce_kafka_kafka_consumer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
++ ce_kafka_kafka_consumer_topic = zend_register_internal_class_ex(&ce, ce_kafka_topic);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ProducerTopic", kafka_producer_topic_fe);
+- ce_kafka_producer_topic = rdkafka_register_internal_class_ex(&ce, ce_kafka_topic);
++ ce_kafka_producer_topic = zend_register_internal_class_ex(&ce, ce_kafka_topic);
+ } /* }}} */
+diff --git a/topic.h b/topic.h
+index e6bbbd5..51aa186 100644
+--- a/topic.h
++++ b/topic.h
+@@ -17,14 +17,9 @@
+ */
+
+ typedef struct _kafka_topic_object {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ rd_kafka_topic_t *rkt;
+ zval zrk;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } kafka_topic_object;
+
+ void kafka_topic_minit();
+diff --git a/topic_partition.c b/topic_partition.c
+index c71a17b..ebbbfaf 100644
+--- a/topic_partition.c
++++ b/topic_partition.c
+@@ -47,22 +47,20 @@ static void free_object(zend_object *object) /* {{{ */
+ }
+
+ zend_object_std_dtor(&intern->std);
+-
+- free_custom_object(intern);
+ }
+ /* }}} */
+
+-static zend_object_value create_object(zend_class_entry *class_type) /* {{{ */
++static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ {
+- zend_object_value retval;
++ zend_object* retval;
+ object_intern *intern;
+
+ intern = ecalloc(1, sizeof(*intern));
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+- STORE_OBJECT(retval, intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_object, NULL);
+- SET_OBJECT_HANDLERS(retval, &handlers);
++ retval = &intern->std;
++ retval->handlers = &handlers;
+
+ return retval;
+ }
+@@ -100,7 +98,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+ }
+
+ if (intern->topic) {
+- rdkafka_add_assoc_string(&ary, "topic", intern->topic);
++ add_assoc_string(&ary, "topic", intern->topic);
+ } else {
+ add_assoc_null(&ary, "topic");
+ }
+@@ -156,7 +154,7 @@ rd_kafka_topic_partition_list_t * array_arg_to_kafka_topic_partition_list(int ar
+ list = rd_kafka_topic_partition_list_new(zend_hash_num_elements(ary));
+
+ for (zend_hash_internal_pointer_reset_ex(ary, &pos);
+- (zv = rdkafka_hash_get_current_data_ex(ary, &pos)) != NULL;
++ (zv = zend_hash_get_current_data_ex(ary, &pos)) != NULL;
+ zend_hash_move_forward_ex(ary, &pos)) {
+ kafka_topic_partition_intern *topar_intern;
+ rd_kafka_topic_partition_t *topar;
+@@ -200,7 +198,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__TopicPartition, __construct)
+ {
+ char *topic;
+- arglen_t topic_len;
++ size_t topic_len;
+ zend_long partition;
+ zend_long offset = 0;
+ zend_error_handling error_handling;
+@@ -238,7 +236,7 @@ PHP_METHOD(RdKafka__TopicPartition, getTopic)
+ }
+
+ if (intern->topic) {
+- RDKAFKA_RETURN_STRING(intern->topic);
++ RETURN_STRING(intern->topic);
+ } else {
+ RETURN_NULL();
+ }
+@@ -255,7 +253,7 @@ ZEND_END_ARG_INFO()
+ PHP_METHOD(RdKafka__TopicPartition, setTopic)
+ {
+ char * topic;
+- arglen_t topic_len;
++ size_t topic_len;
+ object_intern *intern;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &topic, &topic_len) == FAILURE) {
+@@ -398,6 +396,6 @@ void kafka_metadata_topic_partition_minit() /* {{{ */
+
+ handlers = kafka_default_object_handlers;
+ handlers.get_debug_info = get_debug_info;
+- set_object_handler_free_obj(&handlers, free_object);
+- set_object_handler_offset(&handlers, XtOffsetOf(object_intern, std));
++ handlers.free_obj = free_object;
++ handlers.offset = XtOffsetOf(object_intern, std);
+ } /* }}} */
+diff --git a/topic_partition.h b/topic_partition.h
+index a7aab8b..746b1a5 100644
+--- a/topic_partition.h
++++ b/topic_partition.h
+@@ -17,15 +17,10 @@
+ */
+
+ typedef struct _kafka_topic_partition_intern {
+-#if PHP_MAJOR_VERSION < 7
+- zend_object std;
+-#endif
+ char *topic;
+ int32_t partition;
+ int64_t offset;
+-#if PHP_MAJOR_VERSION >= 7
+ zend_object std;
+-#endif
+ } kafka_topic_partition_intern;
+
+ void kafka_metadata_topic_partition_minit();
+From a9e2af8f13d469f3f087f2a9f466edb66d6050be Mon Sep 17 00:00:00 2001
+From: Arnaud Le Blanc <arnaud.lb@gmail.com>
+Date: Mon, 7 Dec 2020 13:41:55 +0100
+Subject: [PATCH] PHP 8 support (#406)
+
+Co-authored-by: Nick <nickjobszh@gmail.com>
+---
+ .github/workflows/test.yml | 4 ---
+ README.md | 4 +--
+ conf.c | 10 +++----
+ conf.h | 2 +-
+ kafka_consumer.c | 18 ++++++-------
+ kafka_consumer.h | 2 +-
+ kafka_error_exception.c | 32 +++++++++++------------
+ kafka_error_exception.h | 3 ++-
+ message.c | 24 ++++++++---------
+ message.h | 2 +-
+ metadata.c | 30 ++++++++++-----------
+ metadata.h | 2 +-
+ metadata_broker.c | 15 +++++------
+ metadata_broker.h | 2 +-
+ metadata_collection.c | 18 +++++++------
+ metadata_collection.h | 4 +--
+ metadata_partition.c | 18 ++++++-------
+ metadata_partition.h | 2 +-
+ metadata_topic.c | 18 ++++++-------
+ metadata_topic.h | 2 +-
+ package.xml | 3 ---
+ php_rdkafka.h | 4 ---
+ php_rdkafka_priv.h | 32 +++++++++++++++--------
+ queue.c | 6 ++---
+ queue.h | 2 +-
+ rdkafka.c | 33 ++++++++++++------------
+ tests/bug115.phpt | 6 -----
+ tests/bug74.phpt | 6 ++++-
+ tests/conf_setDefaultTopicConf.phpt | 2 +-
+ tests/message_headers.phpt | 7 ++---
+ tests/produce_consume.phpt | 8 +++---
+ tests/produce_consume_queue.phpt | 15 +++++++++--
+ tests/produce_consume_transactional.phpt | 7 +++++
+ topic.c | 6 ++---
+ topic.h | 2 +-
+ topic_partition.c | 15 ++++++-----
+ topic_partition.h | 2 +-
+ 37 files changed, 194 insertions(+), 174 deletions(-)
+
+diff --git a/README.md b/README.md
+index 8257df8..f946d43 100644
+--- a/README.md
++++ b/README.md
+@@ -2,9 +2,9 @@
+
+ [![Join the chat at https://gitter.im/arnaud-lb/php-rdkafka](https://badges.gitter.im/arnaud-lb/php-rdkafka.svg)](https://gitter.im/arnaud-lb/php-rdkafka?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+-[![Supported librdkafka versions: >= 0.11](https://img.shields.io/badge/librdkafka-%3E%3D%200.11-blue.svg)](https://github.com/edenhill/librdkafka/releases) [![Supported Kafka versions: >= 0.8](https://img.shields.io/badge/kafka-%3E%3D%200.8-blue.svg)](https://github.com/edenhill/librdkafka/wiki/Broker-version-compatibility) ![Supported PHP versions: 5.6 .. 7.x](https://img.shields.io/badge/php-5.6%20..%207.x-blue.svg) [![Build Status](https://travis-ci.org/arnaud-lb/php-rdkafka.svg)](https://travis-ci.org/arnaud-lb/php-rdkafka)
++[![Supported librdkafka versions: >= 0.11](https://img.shields.io/badge/librdkafka-%3E%3D%200.11-blue.svg)](https://github.com/edenhill/librdkafka/releases) [![Supported Kafka versions: >= 0.8](https://img.shields.io/badge/kafka-%3E%3D%200.8-blue.svg)]()https://github.com/edenhill/librdkafka/blob/master/INTRODUCTION.md#broker-version-compatibility ![Supported PHP versions: 7.x .. 8.x](https://img.shields.io/badge/php-7.x%20..%208.x-blue.svg)
+
+-PHP-rdkafka is a thin [librdkafka](https://github.com/edenhill/librdkafka) binding providing a working PHP 5 / PHP 7 [Kafka](https://kafka.apache.org/) client.
++PHP-rdkafka is a thin [librdkafka](https://github.com/edenhill/librdkafka) binding providing a working PHP 7 / PHP 8 [Kafka](https://kafka.apache.org/) client.
+
+ It supports the high level and low level *consumers*, *producer*, and *metadata* APIs.
+
+diff --git a/conf.c b/conf.c
+index ec171c6..1ec2e59 100644
+--- a/conf.c
++++ b/conf.c
+@@ -85,7 +85,7 @@ void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *f
+
+ static void kafka_conf_free(zend_object *object) /* {{{ */
+ {
+- kafka_conf_object *intern = get_custom_object(kafka_conf_object, object);
++ kafka_conf_object *intern = php_kafka_from_obj(kafka_conf_object, object);
+
+ switch (intern->type) {
+ case KAFKA_CONF:
+@@ -123,7 +123,7 @@ static zend_object *kafka_conf_new(zend_class_entry *class_type) /* {{{ */
+
+ kafka_conf_object * get_kafka_conf_object(zval *zconf)
+ {
+- kafka_conf_object *oconf = get_custom_object_zval(kafka_conf_object, zconf);
++ kafka_conf_object *oconf = Z_RDKAFKA_P(kafka_conf_object, zconf);
+
+ if (!oconf->type) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Conf::__construct() has not been called");
+@@ -350,7 +350,7 @@ PHP_METHOD(RdKafka__Conf, __construct)
+ return;
+ }
+
+- intern = get_custom_object_zval(kafka_conf_object, getThis());
++ intern = Z_RDKAFKA_P(kafka_conf_object, getThis());
+ intern->type = KAFKA_CONF;
+ intern->u.conf = rd_kafka_conf_new();
+
+@@ -761,7 +761,7 @@ PHP_METHOD(RdKafka__TopicConf, __construct)
+ return;
+ }
+
+- intern = get_custom_object_zval(kafka_conf_object, getThis());
++ intern = Z_RDKAFKA_P(kafka_conf_object, getThis());
+ intern->type = KAFKA_TOPIC_CONF;
+ intern->u.topic_conf = rd_kafka_topic_conf_new();
+
+@@ -840,7 +840,7 @@ static const zend_function_entry kafka_conf_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_conf_minit()
++void kafka_conf_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+diff --git a/conf.h b/conf.h
+index 673e14c..9778eb5 100644
+--- a/conf.h
++++ b/conf.h
+@@ -59,7 +59,7 @@ typedef struct _kafka_conf_object {
+ } kafka_conf_object;
+
+ kafka_conf_object * get_kafka_conf_object(zval *zconf);
+-void kafka_conf_minit();
++void kafka_conf_minit(INIT_FUNC_ARGS);
+
+ void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs);
+ void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from);
+diff --git a/kafka_consumer.c b/kafka_consumer.c
+index 8cc4b9d..f1b596a 100644
+--- a/kafka_consumer.c
++++ b/kafka_consumer.c
+@@ -43,7 +43,7 @@ static zend_object_handlers handlers;
+
+ static void kafka_consumer_free(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+ rd_kafka_resp_err_t err;
+ kafka_conf_callbacks_dtor(&intern->cbs);
+
+@@ -82,7 +82,7 @@ static zend_object *kafka_consumer_new(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zconsumer) /* {{{ */
+ {
+- object_intern *oconsumer = get_custom_object_zval(object_intern, zconsumer);
++ object_intern *oconsumer = Z_RDKAFKA_P(object_intern, zconsumer);
+
+ if (!oconsumer->rk) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\KafkaConsumer::__construct() has not been called");
+@@ -134,7 +134,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, __construct)
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, getThis());
++ intern = Z_RDKAFKA_P(object_intern, getThis());
+
+ conf_intern = get_kafka_conf_object(zconf);
+ if (conf_intern) {
+@@ -424,25 +424,25 @@ static void consumer_commit(int async, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
+ zval *zoffset;
+ rd_kafka_topic_partition_t *rktpar;
+
+- zerr = rdkafka_read_property(NULL, zarg, ZEND_STRL("err"), 0);
++ zerr = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(zarg), ZEND_STRL("err"), 0);
+ if (zerr && Z_TYPE_P(zerr) != IS_NULL && (Z_TYPE_P(zerr) != IS_LONG || Z_LVAL_P(zerr) != RD_KAFKA_RESP_ERR_NO_ERROR)) {
+ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message has an error", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- ztopic = rdkafka_read_property(NULL, zarg, ZEND_STRL("topic_name"), 0);
++ ztopic = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(zarg), ZEND_STRL("topic_name"), 0);
+ if (!ztopic || Z_TYPE_P(ztopic) != IS_STRING) {
+ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's topic_name is not a string", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- zpartition = rdkafka_read_property(NULL, zarg, ZEND_STRL("partition"), 0);
++ zpartition = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(zarg), ZEND_STRL("partition"), 0);
+ if (!zpartition || Z_TYPE_P(zpartition) != IS_LONG) {
+ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's partition is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+ }
+
+- zoffset = rdkafka_read_property(NULL, zarg, ZEND_STRL("offset"), 0);
++ zoffset = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(zarg), ZEND_STRL("offset"), 0);
+ if (!zoffset || Z_TYPE_P(zoffset) != IS_LONG) {
+ zend_throw_exception(ce_kafka_exception, "Invalid argument: Specified Message's offset is not an int", RD_KAFKA_RESP_ERR__INVALID_ARG);
+ return;
+@@ -620,7 +620,7 @@ PHP_METHOD(RdKafka__KafkaConsumer, newTopic)
+ return;
+ }
+
+- topic_intern = get_custom_object_zval(kafka_topic_object, return_value);
++ topic_intern = Z_RDKAFKA_P(kafka_topic_object, return_value);
+ if (!topic_intern) {
+ return;
+ }
+@@ -818,7 +818,7 @@ static const zend_function_entry fe[] = { /* {{{ */
+ PHP_FE_END
+ }; /* }}} */
+
+-void kafka_kafka_consumer_minit() /* {{{ */
++void kafka_kafka_consumer_minit(INIT_FUNC_ARGS) /* {{{ */
+ {
+ zend_class_entry tmpce;
+
+diff --git a/kafka_consumer.h b/kafka_consumer.h
+index 0ac97f3..cc4be66 100644
+--- a/kafka_consumer.h
++++ b/kafka_consumer.h
+@@ -16,4 +16,4 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_kafka_consumer_minit();
++void kafka_kafka_consumer_minit(INIT_FUNC_ARGS);
+diff --git a/kafka_error_exception.c b/kafka_error_exception.c
+index b1cd9a8..93e5848 100644
+--- a/kafka_error_exception.c
++++ b/kafka_error_exception.c
+@@ -33,12 +33,12 @@ void create_kafka_error(zval *return_value, const rd_kafka_error_t *error) /* {{
+ {
+ object_init_ex(return_value, ce_kafka_error);
+
+- zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("message"), rd_kafka_error_name(error));
+- zend_update_property_long(ce_kafka_error, return_value, ZEND_STRL("code"), rd_kafka_error_code(error));
+- zend_update_property_string(ce_kafka_error, return_value, ZEND_STRL("error_string"), rd_kafka_error_string(error));
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isFatal"), rd_kafka_error_is_fatal(error));
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("isRetriable"), rd_kafka_error_is_retriable(error));
+- zend_update_property_bool(ce_kafka_error, return_value, ZEND_STRL("transactionRequiresAbort"), rd_kafka_error_txn_requires_abort(error));
++ zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("message"), rd_kafka_error_name(error));
++ zend_update_property_long(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("code"), rd_kafka_error_code(error));
++ zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("error_string"), rd_kafka_error_string(error));
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("isFatal"), rd_kafka_error_is_fatal(error));
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("isRetriable"), rd_kafka_error_is_retriable(error));
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("transactionRequiresAbort"), rd_kafka_error_txn_requires_abort(error));
+
+ Z_ADDREF_P(return_value);
+ }
+@@ -65,12 +65,12 @@ PHP_METHOD(RdKafka__KafkaErrorException, __construct)
+ return;
+ }
+
+- zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("message"), message);
+- zend_update_property_long(ce_kafka_error, getThis(), ZEND_STRL("code"), code);
+- zend_update_property_string(ce_kafka_error, getThis(), ZEND_STRL("error_string"), error_string);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), isFatal);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), isRetriable);
+- zend_update_property_bool(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), transactionRequiresAbort);
++ zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("message"), message);
++ zend_update_property_long(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("code"), code);
++ zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("error_string"), error_string);
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isFatal"), isFatal);
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isRetriable"), isRetriable);
++ zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("transactionRequiresAbort"), transactionRequiresAbort);
+ }
+ /* }}} */
+
+@@ -88,7 +88,7 @@ PHP_METHOD(RdKafka__KafkaErrorException, getErrorString)
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("error_string"), 0);
++ res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("error_string"), 0);
+
+ if (!res || Z_TYPE_P(res) != IS_STRING) {
+ return;
+@@ -114,7 +114,7 @@ PHP_METHOD(RdKafka__KafkaErrorException, isFatal)
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isFatal"), 0);
++ res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isFatal"), 0);
+
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+@@ -139,7 +139,7 @@ PHP_METHOD(RdKafka__KafkaErrorException, isRetriable)
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("isRetriable"), 0);
++ res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isRetriable"), 0);
+
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+@@ -164,7 +164,7 @@ PHP_METHOD(RdKafka__KafkaErrorException, transactionRequiresAbort)
+ return;
+ }
+
+- res = rdkafka_read_property(ce_kafka_error, getThis(), ZEND_STRL("transactionRequiresAbort"), 0);
++ res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("transactionRequiresAbort"), 0);
+
+ if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+ return;
+diff --git a/kafka_error_exception.h b/kafka_error_exception.h
+index 9193877..d44b895 100644
+--- a/kafka_error_exception.h
++++ b/kafka_error_exception.h
+@@ -15,10 +15,11 @@
+ | Author: Arnaud Le Blanc <arnaud.lb@gmail.com> |
+ +----------------------------------------------------------------------+
+ */
++
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+
+ #include "librdkafka/rdkafka.h"
+-#include "php.h"
++#include "Zend/zend_interfaces.h"
+
+ extern zend_class_entry * ce_kafka_error;
+ void kafka_error_minit();
+diff --git a/message.c b/message.c
+index a6ed916..f4c4c7f 100644
+--- a/message.c
++++ b/message.c
+@@ -51,21 +51,21 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message)
+ uint i;
+ #endif /* HAVE_RD_KAFKA_MESSAGE_HEADERS */
+
+- zend_update_property_long(NULL, return_value, ZEND_STRL("err"), message->err);
++ zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("err"), message->err);
+
+ if (message->rkt) {
+- zend_update_property_string(NULL, return_value, ZEND_STRL("topic_name"), rd_kafka_topic_name(message->rkt));
++ zend_update_property_string(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("topic_name"), rd_kafka_topic_name(message->rkt));
+ }
+- zend_update_property_long(NULL, return_value, ZEND_STRL("partition"), message->partition);
++ zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("partition"), message->partition);
+ if (message->payload) {
+- zend_update_property_long(NULL, return_value, ZEND_STRL("timestamp"), timestamp);
+- zend_update_property_stringl(NULL, return_value, ZEND_STRL("payload"), message->payload, message->len);
+- zend_update_property_long(NULL, return_value, ZEND_STRL("len"), message->len);
++ zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("timestamp"), timestamp);
++ zend_update_property_stringl(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("payload"), message->payload, message->len);
++ zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("len"), message->len);
+ }
+ if (message->key) {
+- zend_update_property_stringl(NULL, return_value, ZEND_STRL("key"), message->key, message->key_len);
++ zend_update_property_stringl(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("key"), message->key, message->key_len);
+ }
+- zend_update_property_long(NULL, return_value, ZEND_STRL("offset"), message->offset);
++ zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("offset"), message->offset);
+
+ #ifdef HAVE_RD_KAFKA_MESSAGE_HEADERS
+ if (message->err == RD_KAFKA_RESP_ERR_NO_ERROR) {
+@@ -79,7 +79,7 @@ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message)
+ }
+ add_assoc_stringl(&headers_array, header_name, (const char*)header_value, header_size);
+ }
+- zend_update_property(NULL, return_value, ZEND_STRL("headers"), &headers_array);
++ zend_update_property(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("headers"), &headers_array);
+ zval_ptr_dtor(&headers_array);
+ }
+ }
+@@ -119,7 +119,7 @@ PHP_METHOD(RdKafka__Message, errstr)
+ return;
+ }
+
+- zerr = rdkafka_read_property(NULL, getThis(), ZEND_STRL("err"), 0);
++ zerr = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("err"), 0);
+
+ if (!zerr || Z_TYPE_P(zerr) != IS_LONG) {
+ return;
+@@ -131,7 +131,7 @@ PHP_METHOD(RdKafka__Message, errstr)
+ RETURN_STRING(errstr);
+ }
+
+- zpayload = rdkafka_read_property(NULL, getThis(), ZEND_STRL("payload"), 0);
++ zpayload = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("payload"), 0);
+
+ if (zpayload && Z_TYPE_P(zpayload) == IS_STRING) {
+ RETURN_ZVAL(zpayload, 1, 0);
+@@ -144,7 +144,7 @@ static const zend_function_entry kafka_message_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_message_minit() { /* {{{ */
++void kafka_message_minit(INIT_FUNC_ARGS) { /* {{{ */
+ zend_class_entry ce;
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Message", kafka_message_fe);
+diff --git a/message.h b/message.h
+index 5db24ce..3a0f701 100644
+--- a/message.h
++++ b/message.h
+@@ -16,7 +16,7 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_message_minit();
++void kafka_message_minit(INIT_FUNC_ARGS);
+ void kafka_message_new(zval *return_value, const rd_kafka_message_t *message);
+ void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size);
+
+diff --git a/metadata.c b/metadata.c
+index a43123c..4d3f12d 100644
+--- a/metadata.c
++++ b/metadata.c
+@@ -35,24 +35,24 @@ typedef struct _object_intern {
+ zend_object std;
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void brokers_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++static void brokers_collection(zval *return_value, Z_RDKAFKA_OBJ *parent, object_intern *intern) { /* {{{ */
+ kafka_metadata_collection_init(return_value, parent, intern->metadata->brokers, intern->metadata->broker_cnt, sizeof(*intern->metadata->brokers), kafka_metadata_broker_ctor);
+ }
+ /* }}} */
+
+-static void topics_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++static void topics_collection(zval *return_value, Z_RDKAFKA_OBJ *parent, object_intern *intern) { /* {{{ */
+ kafka_metadata_collection_init(return_value, parent, intern->metadata->topics, intern->metadata->topic_cnt, sizeof(*intern->metadata->topics), kafka_metadata_topic_ctor);
+ }
+ /* }}} */
+
+ static void kafka_metadata_free(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->metadata) {
+ rd_kafka_metadata_destroy(intern->metadata);
+@@ -80,7 +80,7 @@ static zend_object *kafka_metadata_new(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zmetadata)
+ {
+- object_intern *ometadata = get_custom_object_zval(object_intern, zmetadata);
++ object_intern *ometadata = Z_RDKAFKA_P(object_intern, zmetadata);
+
+ if (!ometadata->metadata) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata::__construct() has not been called");
+@@ -90,7 +90,7 @@ static object_intern * get_object(zval *zmetadata)
+ return ometadata;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -101,7 +101,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -186,7 +186,7 @@ PHP_METHOD(RdKafka__Metadata, getBrokers)
+ return;
+ }
+
+- brokers_collection(return_value, getThis(), intern);
++ brokers_collection(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern);
+ }
+ /* }}} */
+
+@@ -209,7 +209,7 @@ PHP_METHOD(RdKafka__Metadata, getTopics)
+ return;
+ }
+
+- topics_collection(return_value, getThis(), intern);
++ topics_collection(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern);
+ }
+ /* }}} */
+
+@@ -221,7 +221,7 @@ static const zend_function_entry kafka_metadata_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_minit()
++void kafka_metadata_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+@@ -234,10 +234,10 @@ void kafka_metadata_minit()
+ handlers.free_obj = kafka_metadata_free;
+ handlers.offset = XtOffsetOf(object_intern, std);
+
+- kafka_metadata_topic_minit();
+- kafka_metadata_broker_minit();
+- kafka_metadata_partition_minit();
+- kafka_metadata_collection_minit();
++ kafka_metadata_topic_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_metadata_broker_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_metadata_partition_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_metadata_collection_minit(INIT_FUNC_ARGS_PASSTHRU);
+ }
+
+ void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata)
+@@ -248,7 +248,7 @@ void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, return_value);
++ intern = Z_RDKAFKA_P(object_intern, return_value);
+ if (!intern) {
+ return;
+ }
+diff --git a/metadata.h b/metadata.h
+index b68592b..d09d2db 100644
+--- a/metadata.h
++++ b/metadata.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_minit();
++void kafka_metadata_minit(INIT_FUNC_ARGS);
+ void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata);
+diff --git a/metadata_broker.c b/metadata_broker.c
+index db9b4e3..b964231 100644
+--- a/metadata_broker.c
++++ b/metadata_broker.c
+@@ -34,14 +34,14 @@ typedef struct _object_intern {
+ zend_object std;
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+ static void free_object(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->metadata_broker) {
+ zval_dtor(&intern->zmetadata);
+@@ -60,7 +60,6 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+
+-
+ retval = &intern->std;
+ retval->handlers = &handlers;
+
+@@ -70,7 +69,7 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zmt)
+ {
+- object_intern *omt = get_custom_object_zval(object_intern, zmt);
++ object_intern *omt = Z_RDKAFKA_P(object_intern, zmt);
+
+ if (!omt->metadata_broker) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Broker::__construct() has not been called");
+@@ -80,7 +79,7 @@ static object_intern * get_object(zval *zmt)
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -89,7 +88,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -178,7 +177,7 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_broker_minit()
++void kafka_metadata_broker_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+@@ -201,7 +200,7 @@ void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, return_value);
++ intern = Z_RDKAFKA_P(object_intern, return_value);
+ if (!intern) {
+ return;
+ }
+diff --git a/metadata_broker.h b/metadata_broker.h
+index c860495..6f64928 100644
+--- a/metadata_broker.h
++++ b/metadata_broker.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_broker_minit();
++void kafka_metadata_broker_minit(INIT_FUNC_ARGS);
+ void kafka_metadata_broker_ctor(zval *return_value, zval *zmetadata, const void *metadata_broker);
+diff --git a/metadata_collection.c b/metadata_collection.c
+index 460b3bc..af986ff 100644
+--- a/metadata_collection.c
++++ b/metadata_collection.c
+@@ -39,14 +39,14 @@ typedef struct _object_intern {
+ zend_object std;
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ static zend_class_entry *ce;
+ static zend_object_handlers handlers;
+
+ static void free_object(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->items) {
+ zval_dtor(&intern->zmetadata);
+@@ -74,7 +74,7 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zmti)
+ {
+- object_intern *omti = get_custom_object_zval(object_intern, zmti);
++ object_intern *omti = Z_RDKAFKA_P(object_intern, zmti);
+
+ if (!omti->items) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Collection::__construct() has not been called");
+@@ -84,7 +84,7 @@ static object_intern * get_object(zval *zmti)
+ return omti;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -95,7 +95,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -268,7 +268,7 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_collection_minit()
++void kafka_metadata_collection_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+@@ -283,7 +283,7 @@ void kafka_metadata_collection_minit()
+ handlers.offset = XtOffsetOf(object_intern, std);
+ }
+
+-void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor)
++void kafka_metadata_collection_init(zval *return_value, Z_RDKAFKA_OBJ *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor)
+ {
+ object_intern *intern;
+
+@@ -291,12 +291,14 @@ void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const v
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, return_value);
++ intern = Z_RDKAFKA_P(object_intern, return_value);
+ if (!intern) {
+ return;
+ }
+
++#if PHP_MAJOR_VERSION < 8
+ ZVAL_ZVAL(&intern->zmetadata, zmetadata, 1, 0);
++#endif
+ intern->items = items;
+ intern->item_cnt = item_cnt;
+ intern->item_size = item_size;
+diff --git a/metadata_collection.h b/metadata_collection.h
+index 13c6123..fff2fd6 100644
+--- a/metadata_collection.h
++++ b/metadata_collection.h
+@@ -18,5 +18,5 @@
+
+ typedef void (*kafka_metadata_collection_ctor_t)(zval *renurn_value, zval *zmetadata, const void *object);
+
+-void kafka_metadata_collection_minit();
+-void kafka_metadata_collection_init(zval *return_value, zval *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor);
++void kafka_metadata_collection_minit(INIT_FUNC_ARGS);
++void kafka_metadata_collection_init(zval *return_value, Z_RDKAFKA_OBJ *zmetadata, const void * items, size_t item_cnt, size_t item_size, kafka_metadata_collection_ctor_t ctor);
+diff --git a/metadata_partition.c b/metadata_partition.c
+index 6f5f08f..7fcabc2 100644
+--- a/metadata_partition.c
++++ b/metadata_partition.c
+@@ -35,14 +35,14 @@ typedef struct _object_intern {
+ zend_object std;
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+ static void free_object(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->metadata_partition) {
+ zval_dtor(&intern->zmetadata);
+@@ -70,7 +70,7 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zmt)
+ {
+- object_intern *omt = get_custom_object_zval(object_intern, zmt);
++ object_intern *omt = Z_RDKAFKA_P(object_intern, zmt);
+
+ if (!omt->metadata_partition) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Partition::__construct() has not been called");
+@@ -80,7 +80,7 @@ static object_intern * get_object(zval *zmt)
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -89,7 +89,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -196,7 +196,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getReplicas)
+ return;
+ }
+
+- kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->replicas, intern->metadata_partition->replica_cnt, sizeof(*intern->metadata_partition->replicas), int32_ctor);
++ kafka_metadata_collection_init(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern->metadata_partition->replicas, intern->metadata_partition->replica_cnt, sizeof(*intern->metadata_partition->replicas), int32_ctor);
+ }
+ /* }}} */
+
+@@ -219,7 +219,7 @@ PHP_METHOD(RdKafka__Metadata__Partition, getIsrs)
+ return;
+ }
+
+- kafka_metadata_collection_init(return_value, getThis(), intern->metadata_partition->isrs, intern->metadata_partition->isr_cnt, sizeof(*intern->metadata_partition->isrs), int32_ctor);
++ kafka_metadata_collection_init(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern->metadata_partition->isrs, intern->metadata_partition->isr_cnt, sizeof(*intern->metadata_partition->isrs), int32_ctor);
+ }
+ /* }}} */
+
+@@ -232,7 +232,7 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_partition_minit()
++void kafka_metadata_partition_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+@@ -255,7 +255,7 @@ void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const vo
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, return_value);
++ intern = Z_RDKAFKA_P(object_intern, return_value);
+ if (!intern) {
+ return;
+ }
+diff --git a/metadata_partition.h b/metadata_partition.h
+index 9d9b4dc..8ce35b8 100644
+--- a/metadata_partition.h
++++ b/metadata_partition.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_partition_minit();
++void kafka_metadata_partition_minit(INIT_FUNC_ARGS);
+ void kafka_metadata_partition_ctor(zval *return_value, zval *zmetadata, const void *metadata_partition);
+diff --git a/metadata_topic.c b/metadata_topic.c
+index 9830beb..5aeeed7 100644
+--- a/metadata_topic.c
++++ b/metadata_topic.c
+@@ -36,19 +36,19 @@ typedef struct _object_intern {
+ zend_object std;
+ } object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ static zend_class_entry * ce;
+ static zend_object_handlers handlers;
+
+-static void partitions_collection(zval *return_value, zval *parent, object_intern *intern) { /* {{{ */
++static void partitions_collection(zval *return_value, Z_RDKAFKA_OBJ *parent, object_intern *intern) { /* {{{ */
+ kafka_metadata_collection_init(return_value, parent, intern->metadata_topic->partitions, intern->metadata_topic->partition_cnt, sizeof(*intern->metadata_topic->partitions), kafka_metadata_partition_ctor);
+ }
+ /* }}} */
+
+ static void free_object(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->metadata_topic) {
+ zval_dtor(&intern->zmetadata);
+@@ -76,7 +76,7 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *zmt)
+ {
+- object_intern *omt = get_custom_object_zval(object_intern, zmt);
++ object_intern *omt = Z_RDKAFKA_P(object_intern, zmt);
+
+ if (!omt->metadata_topic) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata\\Topic::__construct() has not been called");
+@@ -86,7 +86,7 @@ static object_intern * get_object(zval *zmt)
+ return omt;
+ }
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -96,7 +96,7 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -179,7 +179,7 @@ PHP_METHOD(RdKafka__Metadata__Topic, getPartitions)
+ return;
+ }
+
+- partitions_collection(return_value, getThis(), intern);
++ partitions_collection(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern);
+ }
+ /* }}} */
+
+@@ -190,7 +190,7 @@ static const zend_function_entry fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_metadata_topic_minit()
++void kafka_metadata_topic_minit(INIT_FUNC_ARGS)
+ {
+ zend_class_entry tmpce;
+
+@@ -213,7 +213,7 @@ void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *
+ return;
+ }
+
+- intern = get_custom_object_zval(object_intern, return_value);
++ intern = Z_RDKAFKA_P(object_intern, return_value);
+ if (!intern) {
+ return;
+ }
+diff --git a/metadata_topic.h b/metadata_topic.h
+index 6c5522a..677203d 100644
+--- a/metadata_topic.h
++++ b/metadata_topic.h
+@@ -16,5 +16,5 @@
+ +----------------------------------------------------------------------+
+ */
+
+-void kafka_metadata_topic_minit();
++void kafka_metadata_topic_minit(INIT_FUNC_ARGS);
+ void kafka_metadata_topic_ctor(zval *return_value, zval *zmetadata, const void *metadata_topic);
+diff --git a/php_rdkafka.h b/php_rdkafka.h
+index 77b40c8..19bef56 100644
+--- a/php_rdkafka.h
++++ b/php_rdkafka.h
+@@ -56,8 +56,4 @@ extern zend_class_entry * ce_kafka_exception;
+ # define PHP_RDKAFKA_API
+ #endif
+
+-#ifdef ZTS
+-#include "TSRM.h"
+-#endif
+-
+ #endif /* PHP_RDKAFKA_H */
+diff --git a/php_rdkafka_priv.h b/php_rdkafka_priv.h
+index a2d44cf..922a88d 100644
+--- a/php_rdkafka_priv.h
++++ b/php_rdkafka_priv.h
+@@ -19,19 +19,28 @@
+ #ifndef PHP_RDKAFKA_PRIV_H
+ #define PHP_RDKAFKA_PRIV_H
+
+-static inline zval * is_zval(zval * zv) {
+- return zv;
+-}
++#if PHP_MAJOR_VERSION >= 8
+
+-#define get_custom_object_zval(type, zobject) \
+- ((type*)((char *)Z_OBJ_P(is_zval(zobject)) - XtOffsetOf(type, std)))
++#define Z_RDKAFKA_OBJ zend_object
+
+-static inline zend_object * is_zend_object(zend_object * object) {
+- return object;
+-}
++#define Z_RDKAFKA_PROP_OBJ(object) Z_OBJ_P(object)
++
++#define rdkafka_get_debug_object(type, object) php_kafka_from_obj(type, object)
++
++#else // PHP 7
++
++#define Z_RDKAFKA_OBJ zval
+
+-#define get_custom_object(type, object) \
+- ((type*)((char *)is_zend_object(object) - XtOffsetOf(type, std)))
++#define Z_RDKAFKA_PROP_OBJ(object) object
++
++#define rdkafka_get_debug_object(type, object) get_object(object)
++
++#endif
++
++#define Z_RDKAFKA_P(php_kafka_type, zobject) php_kafka_from_obj(php_kafka_type, Z_OBJ_P(zobject))
++
++#define php_kafka_from_obj(php_kafka_type, object) \
++ ((php_kafka_type*)((char *)(object) - XtOffsetOf(php_kafka_type, std)))
+
+ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache, zval *retval, uint32_t param_count, zval params[])
+ {
+@@ -56,12 +65,13 @@ static inline void rdkafka_call_function(zend_fcall_info *fci, zend_fcall_info_c
+ }
+ }
+
+-static inline zval *rdkafka_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent)
++static inline zval *rdkafka_read_property(zend_class_entry *scope, Z_RDKAFKA_OBJ *object, const char *name, size_t name_length, zend_bool silent)
+ {
+ zval rv;
+ return zend_read_property(scope, object, name, name_length, silent, &rv);
+ }
+
++
+ static inline char *rdkafka_hash_get_current_key_ex(HashTable *ht, HashPosition *pos)
+ {
+ zend_string* key;
+diff --git a/queue.c b/queue.c
+index 99ab609..182563a 100644
+--- a/queue.c
++++ b/queue.c
+@@ -37,7 +37,7 @@ static zend_object_handlers handlers;
+
+ static void kafka_queue_free(zend_object *object) /* {{{ */
+ {
+- kafka_queue_object *intern = get_custom_object(kafka_queue_object, object);
++ kafka_queue_object *intern = php_kafka_from_obj(kafka_queue_object, object);
+
+ if (intern->rkqu) {
+ kafka_object *kafka_intern = get_kafka_object(&intern->zrk);
+@@ -68,7 +68,7 @@ static zend_object *kafka_queue_new(zend_class_entry *class_type) /* {{{ */
+
+ kafka_queue_object * get_kafka_queue_object(zval *zrkqu)
+ {
+- kafka_queue_object *orkqu = get_custom_object_zval(kafka_queue_object, zrkqu);
++ kafka_queue_object *orkqu = Z_RDKAFKA_P(kafka_queue_object, zrkqu);
+
+ if (!orkqu->rkqu) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Queue::__construct() has not been called");
+@@ -127,7 +127,7 @@ static const zend_function_entry kafka_queue_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_queue_minit() { /* {{{ */
++void kafka_queue_minit(INIT_FUNC_ARGS) { /* {{{ */
+
+ zend_class_entry ce;
+
+diff --git a/queue.h b/queue.h
+index 79e8b3c..c3ecb78 100644
+--- a/queue.h
++++ b/queue.h
+@@ -22,7 +22,7 @@ typedef struct _kafka_queue_object {
+ zend_object std;
+ } kafka_queue_object;
+
+-void kafka_queue_minit();
++void kafka_queue_minit(INIT_FUNC_ARGS);
+ kafka_queue_object * get_kafka_queue_object(zval *zrkqu);
+
+ extern zend_class_entry * ce_kafka_queue;
+diff --git a/rdkafka.c b/rdkafka.c
+index 5d97b22..50cf5b3 100644
+--- a/rdkafka.c
++++ b/rdkafka.c
+@@ -76,7 +76,7 @@ static void stop_consuming(kafka_object * intern) {
+
+ static void kafka_free(zend_object *object) /* {{{ */
+ {
+- kafka_object *intern = get_custom_object(kafka_object, object);
++ kafka_object *intern = php_kafka_from_obj(kafka_object, object);
+
+ if (intern->rk) {
+ if (intern->type == RD_KAFKA_CONSUMER) {
+@@ -122,7 +122,7 @@ static void kafka_init(zval *this_ptr, rd_kafka_type_t type, zval *zconf) /* {{{
+ kafka_conf_object *conf_intern;
+ rd_kafka_conf_t *conf = NULL;
+
+- intern = get_custom_object_zval(kafka_object, this_ptr);
++ intern = Z_RDKAFKA_P(kafka_object, this_ptr);
+ intern->type = type;
+
+ if (zconf) {
+@@ -175,7 +175,7 @@ static zend_object *kafka_new(zend_class_entry *class_type) /* {{{ */
+
+ kafka_object * get_kafka_object(zval *zrk)
+ {
+- kafka_object *ork = get_custom_object_zval(kafka_object, zrk);
++ kafka_object *ork = Z_RDKAFKA_P(kafka_object, zrk);
+
+ if (!ork->rk) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Kafka::__construct() has not been called");
+@@ -299,7 +299,7 @@ PHP_METHOD(RdKafka__Consumer, newQueue)
+ return;
+ }
+
+- queue_intern = get_custom_object_zval(kafka_queue_object, return_value);
++ queue_intern = Z_RDKAFKA_P(kafka_queue_object, return_value);
+ if (!queue_intern) {
+ return;
+ }
+@@ -310,6 +310,7 @@ PHP_METHOD(RdKafka__Consumer, newQueue)
+ // the Queue object is destroyed before the Kafka object.
+ // This avoids rd_kafka_destroy() hanging.
+ queue_intern->zrk = *getThis();
++
+ Z_ADDREF_P(&queue_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->queues, (zend_ulong)queue_intern, queue_intern);
+@@ -392,7 +393,7 @@ PHP_METHOD(RdKafka__Kafka, getMetadata)
+ kafka_metadata_init(return_value, metadata);
+ }
+ /* }}} */
+-
++
+ /* {{{ proto void RdKafka\Kafka::setLogLevel(int $level)
+ Specifies the maximum logging level produced by internal kafka logging and debugging */
+
+@@ -475,13 +476,14 @@ PHP_METHOD(RdKafka__Kafka, newTopic)
+ return;
+ }
+
+- topic_intern = get_custom_object_zval(kafka_topic_object, return_value);
++ topic_intern = Z_RDKAFKA_P(kafka_topic_object, return_value);
+ if (!topic_intern) {
+ return;
+ }
+
+ topic_intern->rkt = rkt;
+ topic_intern->zrk = *getThis();
++
+ Z_ADDREF_P(&topic_intern->zrk);
+
+ zend_hash_index_add_ptr(&intern->topics, (zend_ulong)topic_intern, topic_intern);
+@@ -673,7 +675,6 @@ PHP_METHOD(RdKafka__Kafka, offsetsForTimes)
+ }
+ /* }}} */
+
+-
+ /* {{{ proto void RdKafka::setLogger(mixed $logger)
+ Sets the log callback */
+
+@@ -761,7 +762,6 @@ PHP_METHOD(RdKafka__Producer, __construct)
+ /* }}} */
+
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+-
+ /* {{{ proto int RdKafka\Producer::initTransactions(int timeout_ms)
+ Initializes transactions, needs to be done before producing and starting a transaction */
+ ZEND_BEGIN_ARG_INFO_EX(arginfo_kafka_init_transactions, 0, 0, 1)
+@@ -886,7 +886,6 @@ PHP_METHOD(RdKafka__Producer, abortTransaction)
+ zend_throw_exception_object(return_value);
+ }
+ /* }}} */
+-
+ #endif
+
+ static const zend_function_entry kafka_producer_fe[] = {
+@@ -989,18 +988,18 @@ PHP_MINIT_FUNCTION(rdkafka)
+ ce_kafka_producer = zend_register_internal_class_ex(&ce, ce_kafka);
+
+ INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Exception", NULL);
+- ce_kafka_exception = zend_register_internal_class_ex(&ce, zend_exception_get_default());
++ ce_kafka_exception = zend_register_internal_class_ex(&ce, zend_ce_exception);
+
+- kafka_conf_minit();
++ kafka_conf_minit(INIT_FUNC_ARGS_PASSTHRU);
+ #ifdef HAS_RD_KAFKA_TRANSACTIONS
+ kafka_error_minit();
+ #endif
+- kafka_kafka_consumer_minit();
+- kafka_message_minit();
+- kafka_metadata_minit();
+- kafka_metadata_topic_partition_minit();
+- kafka_queue_minit();
+- kafka_topic_minit();
++ kafka_kafka_consumer_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_message_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_metadata_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_metadata_topic_partition_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_queue_minit(INIT_FUNC_ARGS_PASSTHRU);
++ kafka_topic_minit(INIT_FUNC_ARGS_PASSTHRU);
+
+ return SUCCESS;
+ }
+diff --git a/tests/bug115.phpt b/tests/bug115.phpt
+index 5ea0af8..8c1620d 100644
+--- a/tests/bug115.phpt
++++ b/tests/bug115.phpt
+@@ -17,12 +17,6 @@ $conf->setErrorCb(function ($producer, $err, $errstr) {
+ printf("%s: %s\n", rd_kafka_err2str($err), $errstr);
+ exit;
+ });
+-$conf->setDrMsgCb(function ($producer, $msg) use (&$delivered) {
+- if ($msg->err) {
+- throw new Exception("Message delivery failed: " . $msg->errstr());
+- }
+- $delivered++;
+-});
+ $conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
+
+ $topicName = sprintf("test_rdkafka_%s", uniqid());
+diff --git a/tests/bug74.phpt b/tests/bug74.phpt
+index 8cb23fd..04f4857 100644
+--- a/tests/bug74.phpt
++++ b/tests/bug74.phpt
+@@ -1,10 +1,14 @@
+ --TEST--
+ Bug 74
++--SKIPIF--
++<?php
++require __DIR__ . '/integration-tests-check.php';
+ --FILE--
+ <?php
++require __DIR__ . '/integration-tests-check.php';
+
+ $conf = new RdKafka\Conf();
+-$conf->set('metadata.broker.list', 'localhost:9092');
++$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
+
+ $consumer = new RdKafka\Consumer($conf);
+ $topic = $consumer->newTopic("batman", null);
+diff --git a/tests/conf_setDefaultTopicConf.phpt b/tests/conf_setDefaultTopicConf.phpt
+index 6b48505..ad08f3b 100644
+--- a/tests/conf_setDefaultTopicConf.phpt
++++ b/tests/conf_setDefaultTopicConf.phpt
+@@ -2,7 +2,7 @@
+ RdKafka\Conf::setDefaultTopicConf()
+ --SKIPIF--
+ <?php
+-if (!method_exists('RdKafka\Conf', 'setDefaultTopicConf')) {
++if (!method_exists('RdKafka\Conf', 'setDefaultTopicConf') || 7 < PHP_MAJOR_VERSION) {
+ echo "skip";
+ }
+ ?>
+diff --git a/tests/message_headers.phpt b/tests/message_headers.phpt
+index 61436ae..a244089 100644
+--- a/tests/message_headers.phpt
++++ b/tests/message_headers.phpt
+@@ -15,13 +15,16 @@ $conf->setErrorCb(function ($producer, $err, $errstr) {
+ printf("%s: %s\n", rd_kafka_err2str($err), $errstr);
+ exit;
+ });
++$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
++
++$consumer = new RdKafka\Consumer($conf);
++
+ $conf->setDrMsgCb(function ($producer, $msg) use (&$delivered) {
+ if ($msg->err) {
+ throw new Exception("Message delivery failed: " . $msg->errstr());
+ }
+ $delivered++;
+ });
+-$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
+
+ $producer = new RdKafka\Producer($conf);
+
+@@ -57,8 +60,6 @@ while ($producer->getOutQLen()) {
+
+ printf("%d messages delivered\n", $delivered);
+
+-$consumer = new RdKafka\Consumer($conf);
+-
+ $topic = $consumer->newTopic($topicName);
+ $topic->consumeStart(0, RD_KAFKA_OFFSET_BEGINNING);
+
+diff --git a/tests/produce_consume.phpt b/tests/produce_consume.phpt
+index c10ed1e..9f87208 100644
+--- a/tests/produce_consume.phpt
++++ b/tests/produce_consume.phpt
+@@ -17,13 +17,17 @@ $conf->setErrorCb(function ($producer, $err, $errstr) {
+ printf("%s: %s\n", rd_kafka_err2str($err), $errstr);
+ exit;
+ });
++
++$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
++
++$consumer = new RdKafka\Consumer($conf);
++
+ $conf->setDrMsgCb(function ($producer, $msg) use (&$delivered) {
+ if ($msg->err) {
+ throw new Exception("Message delivery failed: " . $msg->errstr());
+ }
+ $delivered++;
+ });
+-$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
+
+ $producer = new RdKafka\Producer($conf);
+
+@@ -46,8 +50,6 @@ while ($producer->getOutQLen()) {
+
+ printf("%d messages delivered\n", $delivered);
+
+-$consumer = new RdKafka\Consumer($conf);
+-
+ $topic = $consumer->newTopic($topicName);
+ $topic->consumeStart(0, RD_KAFKA_OFFSET_BEGINNING);
+
+diff --git a/tests/produce_consume_queue.phpt b/tests/produce_consume_queue.phpt
+index 9e3dda1..275daf7 100644
+--- a/tests/produce_consume_queue.phpt
++++ b/tests/produce_consume_queue.phpt
+@@ -10,8 +10,6 @@ require __DIR__ . '/integration-tests-check.php';
+ $delivered = 0;
+
+ $conf = new RdKafka\Conf();
+-// Required to detect actual reaching of partition EOF for both topics
+-$conf->set('enable.partition.eof', 'true');
+ if (RD_KAFKA_VERSION >= 0x090000 && false !== getenv('TEST_KAFKA_BROKER_VERSION')) {
+ $conf->set('broker.version.fallback', getenv('TEST_KAFKA_BROKER_VERSION'));
+ }
+@@ -53,6 +51,19 @@ while ($producer->getOutQLen()) {
+
+ printf("%d messages delivered\n", $delivered);
+
++$conf = new RdKafka\Conf();
++// Required to detect actual reaching of partition EOF for both topics
++$conf->set('enable.partition.eof', 'true');
++if (RD_KAFKA_VERSION >= 0x090000 && false !== getenv('TEST_KAFKA_BROKER_VERSION')) {
++ $conf->set('broker.version.fallback', getenv('TEST_KAFKA_BROKER_VERSION'));
++}
++$conf->setErrorCb(function ($producer, $err, $errstr) {
++ printf("%s: %s\n", rd_kafka_err2str($err), $errstr);
++ exit;
++});
++
++$conf->set('metadata.broker.list', getenv('TEST_KAFKA_BROKERS'));
++
+ $consumer = new RdKafka\Consumer($conf);
+
+ $queue = $consumer->newQueue();
+diff --git a/topic.c b/topic.c
+index 78887a3..bc274d6 100644
+--- a/topic.c
++++ b/topic.c
+@@ -45,7 +45,7 @@ typedef struct _php_callback {
+
+ static void kafka_topic_free(zend_object *object) /* {{{ */
+ {
+- kafka_topic_object *intern = get_custom_object(kafka_topic_object, object);
++ kafka_topic_object *intern = php_kafka_from_obj(kafka_topic_object, object);
+
+ if (Z_TYPE(intern->zrk) != IS_UNDEF && intern->rkt) {
+ kafka_object *kafka_intern = get_kafka_object(&intern->zrk);
+@@ -99,7 +99,7 @@ static void consume_callback(rd_kafka_message_t *msg, void *opaque)
+
+ kafka_topic_object * get_kafka_topic_object(zval *zrkt)
+ {
+- kafka_topic_object *orkt = get_custom_object_zval(kafka_topic_object, zrkt);
++ kafka_topic_object *orkt = Z_RDKAFKA_P(kafka_topic_object, zrkt);
+
+ if (!orkt->rkt) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\Topic::__construct() has not been called");
+@@ -665,7 +665,7 @@ static const zend_function_entry kafka_topic_fe[] = {
+ PHP_FE_END
+ };
+
+-void kafka_topic_minit() { /* {{{ */
++void kafka_topic_minit(INIT_FUNC_ARGS) { /* {{{ */
+
+ zend_class_entry ce;
+
+diff --git a/topic.h b/topic.h
+index 51aa186..4e712e9 100644
+--- a/topic.h
++++ b/topic.h
+@@ -22,7 +22,7 @@ typedef struct _kafka_topic_object {
+ zend_object std;
+ } kafka_topic_object;
+
+-void kafka_topic_minit();
++void kafka_topic_minit(INIT_FUNC_ARGS);
+ kafka_topic_object * get_kafka_topic_object(zval *zrkt);
+
+ extern zend_class_entry * ce_kafka_consumer_topic;
+diff --git a/topic_partition.c b/topic_partition.c
+index ebbbfaf..9d1b1f7 100644
+--- a/topic_partition.c
++++ b/topic_partition.c
+@@ -32,7 +32,7 @@
+
+ typedef kafka_topic_partition_intern object_intern;
+
+-static HashTable *get_debug_info(zval *object, int *is_temp);
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+ zend_class_entry * ce_kafka_topic_partition;
+
+@@ -40,7 +40,7 @@ static zend_object_handlers handlers;
+
+ static void free_object(zend_object *object) /* {{{ */
+ {
+- object_intern *intern = get_custom_object(object_intern, object);
++ object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+ if (intern->topic) {
+ efree(intern->topic);
+@@ -68,7 +68,7 @@ static zend_object *create_object(zend_class_entry *class_type) /* {{{ */
+
+ static object_intern * get_object(zval *z) /* {{{ */
+ {
+- object_intern * intern = get_custom_object_zval(object_intern, z);
++ object_intern *intern = Z_RDKAFKA_P(object_intern, z);
+
+ if (!intern->topic) {
+ zend_throw_exception_ex(NULL, 0, "RdKafka\\TopicPartition::__construct() has not been called");
+@@ -83,7 +83,7 @@ kafka_topic_partition_intern * get_topic_partition_object(zval *z) /* {{{ */
+ return get_object(z);
+ } /* }}} */
+
+-static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
++static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+ {
+ zval ary;
+ object_intern *intern;
+@@ -92,7 +92,8 @@ static HashTable *get_debug_info(zval *object, int *is_temp) /* {{{ */
+
+ array_init(&ary);
+
+- intern = get_object(object);
++ intern = rdkafka_get_debug_object(object_intern, object);
++
+ if (!intern) {
+ return Z_ARRVAL(ary);
+ }
+@@ -114,7 +115,7 @@ void kafka_topic_partition_init(zval *zobj, char * topic, int32_t partition, int
+ {
+ object_intern *intern;
+
+- intern = get_custom_object_zval(object_intern, zobj);
++ intern = Z_RDKAFKA_P(object_intern, zobj);
+ if (!intern) {
+ return;
+ }
+@@ -386,7 +387,7 @@ static const zend_function_entry fe[] = { /* {{{ */
+ PHP_FE_END
+ }; /* }}} */
+
+-void kafka_metadata_topic_partition_minit() /* {{{ */
++void kafka_metadata_topic_partition_minit(INIT_FUNC_ARGS) /* {{{ */
+ {
+ zend_class_entry tmpce;
+
+diff --git a/topic_partition.h b/topic_partition.h
+index 746b1a5..f2d405d 100644
+--- a/topic_partition.h
++++ b/topic_partition.h
+@@ -23,7 +23,7 @@ typedef struct _kafka_topic_partition_intern {
+ zend_object std;
+ } kafka_topic_partition_intern;
+
+-void kafka_metadata_topic_partition_minit();
++void kafka_metadata_topic_partition_minit(INIT_FUNC_ARGS);
+
+ kafka_topic_partition_intern * get_topic_partition_object(zval *z);
+ void kafka_topic_partition_init(zval *z, char *topic, int32_t partition, int64_t offset);