PHP 5 is dead, long live PHP 7

This commit removes support for PHP 5 by getting rid of all of our Zend
compatibility layer methods, as well as any call checking against
PHP_MAJOR_VERSION or ZEND_MODULE_API_NO.

Unit tests are all passing for Redis, RedisCluster, and RedisArray but
this should still be considered a work in progress until more testing
can be done.

Addresses issue #1448

16 files changed, 378 insertions, 1506 deletions

diff --git a/.travis.yml b/.travis.yml
index 8c84d018..4829561f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +1,6 @@
 sudo: required
 language: php
 php:
-  - 5.4
-  - 5.5
-  - 5.6
   - 7.0
   - 7.1
   - 7.2
@@ -16,15 +13,6 @@ matrix:
       env: CC=clang
     - php: nightly
   include:
-    # php 5.3 is only available on precise
-    - php: 5.3
-      dist: precise
-    - php: 5.4
-      env: CC=clang
-    - php: 5.5
-      env: CC=clang
-    - php: 5.6
-      env: CC=clang
     - php: 7.0
       env: CC=clang
     - php: 7.1
diff --git a/cluster_library.c b/cluster_library.c
index b0f7b53a..bcc5fb07 100644
--- a/cluster_library.c
+++ b/cluster_library.c
@@ -361,12 +361,7 @@ PHP_REDIS_API int cluster_send_discard(redisCluster *c, short slot TSRMLS_DC) {
  * */
 
 /* Free cluster distribution list inside a HashTable */
-#if (PHP_MAJOR_VERSION < 7)
-static void cluster_dist_free_ht(void *p)
-#else
-static void cluster_dist_free_ht(zval *p)
-#endif
-{
+static void cluster_dist_free_ht(zval *p) {
     clusterDistList *dl = *(clusterDistList**)p;
     int i;
 
@@ -435,7 +430,7 @@ static clusterKeyVal *cluster_dl_add_key(clusterDistList *dl, char *key,
 /* Add a key, returning a pointer to the entry where passed for easy adding
  * of values to match this key */
 int cluster_dist_add_key(redisCluster *c, HashTable *ht, char *key,
-                          strlen_t key_len, clusterKeyVal **kv)
+                          size_t key_len, clusterKeyVal **kv)
 {
     int key_free;
     short slot;
@@ -472,7 +467,7 @@ void cluster_dist_add_val(redisCluster *c, clusterKeyVal *kv, zval *z_val
                          TSRMLS_DC)
 {
     char *val;
-    strlen_t val_len;
+    size_t val_len;
     int val_free;
 
     // Serialize our value
@@ -523,12 +518,7 @@ cluster_set_err(redisCluster *c, char *err, int err_len)
 }
 
 /* Destructor for slaves */
-#if (PHP_MAJOR_VERSION < 7)
-static void ht_free_slave(void *data)
-#else
-static void ht_free_slave(zval *data)
-#endif
-{
+static void ht_free_slave(zval *data) {
     if (*(redisClusterNode**)data) {
         cluster_free_node(*(redisClusterNode**)data);
     }
@@ -801,23 +791,13 @@ static RedisSock *cluster_get_asking_sock(redisCluster *c TSRMLS_DC) {
 }
 
 /* Our context seeds will be a hash table with RedisSock* pointers */
-#if (PHP_MAJOR_VERSION < 7)
-static void ht_free_seed(void *data)
-#else
-static void ht_free_seed(zval *data)
-#endif
-{
+static void ht_free_seed(zval *data) {
     RedisSock *redis_sock = *(RedisSock**)data;
     if (redis_sock) redis_free_socket(redis_sock);
 }
 
 /* Free redisClusterNode objects we've stored */
-#if (PHP_MAJOR_VERSION < 7)
-static void ht_free_node(void *data)
-#else
-static void ht_free_node(zval *data)
-#endif
-{
+static void ht_free_node(zval *data) {
     redisClusterNode *node = *(redisClusterNode**)data;
     cluster_free_node(node);
 }
@@ -1564,13 +1544,9 @@ PHP_REDIS_API void cluster_bulk_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster
             CLUSTER_RETURN_STRING(c, resp, c->reply_len);
         }
     } else {
-        zval zv, *z = &zv;
-        if (redis_unpack(c->flags, resp, c->reply_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z);
-            *z = zv;
-#endif
-            add_next_index_zval(&c->multi_resp, z);
+        zval z_unpacked;
+        if (redis_unpack(c->flags, resp, c->reply_len, &z_unpacked TSRMLS_CC)) {
+            add_next_index_zval(&c->multi_resp, &z_unpacked);
         } else {
             add_next_index_stringl(&c->multi_resp, resp, c->reply_len);
         }
@@ -1705,13 +1681,8 @@ PHP_REDIS_API void cluster_sub_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
     }
 
     // Set up our callback pointers
-#if (PHP_MAJOR_VERSION < 7)
-    zval *z_ret, **z_args[4];
-    sctx->cb.retval_ptr_ptr = &z_ret;
-#else
     zval z_ret, z_args[4];
     sctx->cb.retval = &z_ret;
-#endif
     sctx->cb.params = z_args;
     sctx->cb.no_separation = 0;
 
@@ -1753,19 +1724,6 @@ PHP_REDIS_API void cluster_sub_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
         }
 
         // Always pass our object through
-#if (PHP_MAJOR_VERSION < 7)
-        z_args[0] = &getThis();
-
-        // Set up calbacks depending on type
-        if (is_pmsg) {
-            z_args[1] = &z_pat;
-            z_args[2] = &z_chan;
-            z_args[3] = &z_data;
-        } else {
-            z_args[1] = &z_chan;
-            z_args[2] = &z_data;
-        }
-#else
         z_args[0] = *getThis();
 
         // Set up calbacks depending on type
@@ -1777,7 +1735,6 @@ PHP_REDIS_API void cluster_sub_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
             z_args[1] = *z_chan;
             z_args[2] = *z_data;
         }
-#endif
 
         // Set arg count
         sctx->cb.param_count = tab_idx;
@@ -1851,7 +1808,7 @@ PHP_REDIS_API void cluster_unsub_resp(INTERNAL_FUNCTION_PARAMETERS,
 /* Recursive MULTI BULK -> PHP style response handling */
 static void cluster_mbulk_variant_resp(clusterReply *r, zval *z_ret)
 {
-    zval zv, *z_sub_ele = &zv;
+    zval z_sub_ele;
     int i;
 
     switch(r->type) {
@@ -1873,14 +1830,11 @@ static void cluster_mbulk_variant_resp(clusterReply *r, zval *z_ret)
             }
             break;
         case TYPE_MULTIBULK:
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_sub_ele);
-#endif
-            array_init(z_sub_ele);
+            array_init(&z_sub_ele);
             for (i = 0; i < r->elements; i++) {
-                cluster_mbulk_variant_resp(r->element[i], z_sub_ele);
+                cluster_mbulk_variant_resp(r->element[i], &z_sub_ele);
             }
-            add_next_index_zval(z_ret, z_sub_ele);
+            add_next_index_zval(z_ret, &z_sub_ele);
             break;
         default:
             add_next_index_bool(z_ret, 0);
@@ -1989,7 +1943,7 @@ PHP_REDIS_API void cluster_variant_resp_strings(INTERNAL_FUNCTION_PARAMETERS, re
 PHP_REDIS_API void cluster_gen_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
                                    redisCluster *c, mbulk_cb cb, void *ctx)
 {
-    zval zv, *z_result = &zv;
+    zval z_result;
 
     /* Return FALSE if we didn't get a multi-bulk response */
     if (c->reply_type != TYPE_MULTIBULK) {
@@ -1997,10 +1951,7 @@ PHP_REDIS_API void cluster_gen_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
     }
 
     /* Allocate our array */
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_result);
-#endif
-    array_init(z_result);
+    array_init(&z_result);
 
     /* Consume replies as long as there are more than zero */
     if (c->reply_len > 0) {
@@ -2008,20 +1959,17 @@ PHP_REDIS_API void cluster_gen_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
         c->cmd_sock->serializer = c->flags->serializer;
 
         /* Call our specified callback */
-        if (cb(c->cmd_sock, z_result, c->reply_len, ctx TSRMLS_CC) == FAILURE) {
-            zval_dtor(z_result);
-#if (PHP_MAJOR_VERSION < 7)
-            efree(z_result);
-#endif
+        if (cb(c->cmd_sock, &z_result, c->reply_len, ctx TSRMLS_CC) == FAILURE) {
+            zval_dtor(&z_result);
             CLUSTER_RETURN_FALSE(c);
         }
     }
 
     // Success, make this array our return value
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_result, 0, 1);
+        RETVAL_ZVAL(&z_result, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_result);
+        add_next_index_zval(&c->multi_resp, &z_result);
     }
 }
 
@@ -2086,7 +2034,7 @@ PHP_REDIS_API int cluster_scan_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
 PHP_REDIS_API void cluster_info_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
                               void *ctx)
 {
-    zval zv, *z_result = &zv;
+    zval z_result;
     char *info;
 
     // Read our bulk response
@@ -2096,15 +2044,14 @@ PHP_REDIS_API void cluster_info_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster
     }
 
     /* Parse response, free memory */
-    REDIS_MAKE_STD_ZVAL(z_result);
-    redis_parse_info_response(info, z_result);
+    redis_parse_info_response(info, &z_result);
     efree(info);
 
     // Return our array
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_result, 0, 1);
+        RETVAL_ZVAL(&z_result, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_result);
+        add_next_index_zval(&c->multi_resp, &z_result);
     }
 }
 
@@ -2113,7 +2060,7 @@ PHP_REDIS_API void cluster_client_list_resp(INTERNAL_FUNCTION_PARAMETERS, redisC
                                      void *ctx)
 {
     char *info;
-    zval zv, *z_result = &zv;
+    zval z_result;
 
     /* Read the bulk response */
     info = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC);
@@ -2121,87 +2068,77 @@ PHP_REDIS_API void cluster_client_list_resp(INTERNAL_FUNCTION_PARAMETERS, redisC
         CLUSTER_RETURN_FALSE(c);
     }
 
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_result);
-#endif
-
     /* Parse it and free the bulk string */
-    redis_parse_client_list_response(info, z_result);
+    redis_parse_client_list_response(info, &z_result);
     efree(info);
 
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_result, 0, 1);
+        RETVAL_ZVAL(&z_result, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_result);
+        add_next_index_zval(&c->multi_resp, &z_result);
     }
 }
 
 /* XRANGE */
 PHP_REDIS_API void
 cluster_xrange_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
-    zval zv, *z_messages = &zv;
+    zval z_messages;
 
-    REDIS_MAKE_STD_ZVAL(z_messages);
-    array_init(z_messages);
+    array_init(&z_messages);
 
     c->cmd_sock->serializer = c->flags->serializer;
     c->cmd_sock->compression = c->flags->compression;
 
-    if (redis_read_stream_messages(c->cmd_sock, c->reply_len, z_messages TSRMLS_CC) < 0) {
-        zval_dtor(z_messages);
-        REDIS_FREE_ZVAL(z_messages);
+    if (redis_read_stream_messages(c->cmd_sock, c->reply_len, &z_messages TSRMLS_CC) < 0) {
+        zval_dtor(&z_messages);
         CLUSTER_RETURN_FALSE(c);
     }
 
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_messages, 0, 1);
+        RETVAL_ZVAL(&z_messages, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_messages);
+        add_next_index_zval(&c->multi_resp, &z_messages);
     }
 }
 
 /* XREAD */
 PHP_REDIS_API void
 cluster_xread_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
-    zval zv, *z_streams = &zv;
+    zval z_streams;
 
-    REDIS_MAKE_STD_ZVAL(z_streams);
-    array_init(z_streams);
+    array_init(&z_streams);
 
     c->cmd_sock->serializer = c->flags->serializer;
     c->cmd_sock->compression = c->flags->compression;
 
-    if (redis_read_stream_messages_multi(c->cmd_sock, c->reply_len, z_streams TSRMLS_CC) < 0) {
-        zval_dtor(z_streams);
-        REDIS_FREE_ZVAL(z_streams);
+    if (redis_read_stream_messages_multi(c->cmd_sock, c->reply_len, &z_streams TSRMLS_CC) < 0) {
+        zval_dtor(&z_streams);
         CLUSTER_RETURN_FALSE(c);
     }
 
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_streams, 0, 1);
+        RETVAL_ZVAL(&z_streams, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_streams);
+        add_next_index_zval(&c->multi_resp, &z_streams);
     }
 }
 
 /* XCLAIM */
 PHP_REDIS_API void
 cluster_xclaim_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
-    zval zv, *z_msg = &zv;
+    zval z_msg;
 
-    REDIS_MAKE_STD_ZVAL(z_msg);
-    array_init(z_msg);
+    array_init(&z_msg);
 
-    if (redis_read_xclaim_response(c->cmd_sock, c->reply_len, z_msg TSRMLS_CC) < 0) {
-        zval_dtor(z_msg);
-        REDIS_FREE_ZVAL(z_msg);
+    if (redis_read_xclaim_response(c->cmd_sock, c->reply_len, &z_msg TSRMLS_CC) < 0) {
+        zval_dtor(&z_msg);
         CLUSTER_RETURN_FALSE(c);
     }
 
     if (CLUSTER_IS_ATOMIC(c)) {
-        RETVAL_ZVAL(z_msg, 0, 1);
+        RETVAL_ZVAL(&z_msg, 0, 1);
     } else {
-        add_next_index_zval(&c->multi_resp, z_msg);
+        add_next_index_zval(&c->multi_resp, &z_msg);
     }
 
 }
@@ -2481,13 +2418,9 @@ int mbulk_resp_loop(RedisSock *redis_sock, zval *z_result,
         line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
 
         if (line != NULL) {
-            zval zv, *z = &zv;
-            if (redis_unpack(redis_sock, line, line_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-                MAKE_STD_ZVAL(z);
-                *z = zv;
-#endif
-                add_next_index_zval(z_result, z);
+            zval z_unpacked;
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+                add_next_index_zval(z_result, &z_unpacked);
             } else {
                 add_next_index_stringl(z_result, line, line_len);
             }
@@ -2525,17 +2458,14 @@ int mbulk_resp_loop_zipstr(RedisSock *redis_sock, zval *z_result,
             key = line;
             key_len = line_len;
         } else {
-            /* Attempt serialization */
-            zval zv, *z = &zv;
-            if (redis_unpack(redis_sock, line, line_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-                MAKE_STD_ZVAL(z);
-                *z = zv;
-#endif
-                add_assoc_zval(z_result, key, z);
+            /* Attempt unpacking */
+            zval z_unpacked;
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+                add_assoc_zval(z_result, key, &z_unpacked);
             } else {
                 add_assoc_stringl_ex(z_result, key, key_len, line, line_len);
             }
+
             efree(line);
             efree(key);
         }
@@ -2599,13 +2529,9 @@ int mbulk_resp_loop_assoc(RedisSock *redis_sock, zval *z_result,
         line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
 
         if (line != NULL) {
-            zval zv, *z = &zv;
-            if (redis_unpack(redis_sock, line, line_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-                MAKE_STD_ZVAL(z);
-                *z = zv;
-#endif
-                add_assoc_zval_ex(z_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), z);
+            zval z_unpacked;
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+                add_assoc_zval_ex(z_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), &z_unpacked);
             } else {
                 add_assoc_stringl_ex(z_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), line, line_len);
             }
diff --git a/cluster_library.h b/cluster_library.h
index 366b395a..62f7f9da 100644
--- a/cluster_library.h
+++ b/cluster_library.h
@@ -166,10 +166,6 @@ typedef struct clusterFoldItem clusterFoldItem;
 
 /* RedisCluster implementation structure */
 typedef struct redisCluster {
-#if (PHP_MAJOR_VERSION < 7)
-    zend_object std;
-#endif
-
     zend_string *auth;
 
     /* Timeout and read timeout (for normal operations) */
@@ -240,10 +236,8 @@ typedef struct redisCluster {
     unsigned short     redir_slot;
     unsigned short     redir_port;
 
-#if (PHP_MAJOR_VERSION >= 7)
     /* Zend object handler */
     zend_object std;
-#endif
 } redisCluster;
 
 /* RedisCluster response processing callback */
@@ -329,7 +323,7 @@ void cluster_free_reply(clusterReply *reply, int free_data);
 HashTable *cluster_dist_create();
 void cluster_dist_free(HashTable *ht);
 int cluster_dist_add_key(redisCluster *c, HashTable *ht, char *key,
-    strlen_t key_len, clusterKeyVal **kv);
+    size_t key_len, clusterKeyVal **kv);
 void cluster_dist_add_val(redisCluster *c, clusterKeyVal *kv, zval *val
     TSRMLS_DC);
 
diff --git a/common.h b/common.h
index 65b497b6..34f84416 100644
--- a/common.h
+++ b/common.h
@@ -8,459 +8,12 @@
 
 #include <ext/standard/php_var.h>
 #include <ext/standard/php_math.h>
-#if (PHP_MAJOR_VERSION < 7)
-#include <ext/standard/php_smart_str.h>
-typedef smart_str smart_string;
-#define smart_string_0(x) smart_str_0(x)
-#define smart_string_appendc(dest, c) smart_str_appendc(dest, c)
-#define smart_string_append_long(dest, val) smart_str_append_long(dest, val)
-#define smart_string_appendl(dest, src, len) smart_str_appendl(dest, src, len)
-
-typedef struct {
-    short gc;
-    size_t len;
-    char *val;
-} zend_string;
-
-#define REDIS_MAKE_STD_ZVAL(zv) MAKE_STD_ZVAL(zv)
-#define REDIS_FREE_ZVAL(zv) (efree(zv))
-
-#define ZSTR_VAL(s) (s)->val
-#define ZSTR_LEN(s) (s)->len
-
-static zend_always_inline zend_string *
-zend_string_alloc(size_t len, int persistent)
-{
-    zend_string *zstr = emalloc(sizeof(*zstr) + len + 1);
-
-    ZSTR_VAL(zstr) = (char *)zstr + sizeof(*zstr);
-    ZSTR_LEN(zstr) = len;
-    zstr->gc = 0x01;
-    return zstr;
-}
-
-static zend_always_inline zend_string *
-zend_string_init(const char *str, size_t len, int persistent)
-{
-    zend_string *zstr = zend_string_alloc(len, persistent);
-
-    memcpy(ZSTR_VAL(zstr), str, len);
-    ZSTR_VAL(zstr)[len] = '\0';
-    return zstr;
-}
-
-static zend_always_inline zend_string *
-zend_string_realloc(zend_string *s, size_t len, int persistent)
-{
-    zend_string *zstr;
-
-    if (!s->gc) {
-        zstr = zend_string_init(ZSTR_VAL(s), len, 0);
-    } else if (s->gc & 0x10) {
-        ZSTR_VAL(s) = erealloc(ZSTR_VAL(s), len + 1);
-        ZSTR_LEN(s) = len;
-        zstr = s;
-    } else {
-        zstr = erealloc(s, sizeof(*zstr) + len + 1);
-        ZSTR_VAL(zstr) = (char *)zstr + sizeof(*zstr);
-        ZSTR_LEN(zstr) = len;
-    }
-    return zstr;
-}
-
-#define zend_string_copy(s) zend_string_init(ZSTR_VAL(s), ZSTR_LEN(s), 0)
-
-#define zend_string_equal_val(s1, s2) !memcmp(ZSTR_VAL(s1), ZSTR_VAL(s2), ZSTR_LEN(s1))
-#define zend_string_equal_content(s1, s2) (ZSTR_LEN(s1) == ZSTR_LEN(s2) && zend_string_equal_val(s1, s2))
-#define zend_string_equals(s1, s2) (s1 == s2 || zend_string_equal_content(s1, s2))
-
-#define zend_string_release(s) do { \
-    if ((s) && (s)->gc) { \
-        if ((s)->gc & 0x10 && ZSTR_VAL(s)) efree(ZSTR_VAL(s)); \
-        if ((s)->gc & 0x01) efree((s)); \
-    } \
-} while (0)
-
-#define ZEND_HASH_FOREACH_KEY_VAL(ht, _h, _key, _val) do { \
-    HashPosition _hpos; \
-    for (zend_hash_internal_pointer_reset_ex(ht, &_hpos); \
-         zend_hash_has_more_elements_ex(ht, &_hpos) == SUCCESS; \
-         zend_hash_move_forward_ex(ht, &_hpos) \
-    ) { \
-        zend_string _zstr = {0}; \
-        char *_str_index; uint _str_length; ulong _num_index; \
-        _h = 0; _key = NULL; _val = zend_hash_get_current_data_ex(ht, &_hpos); \
-        switch (zend_hash_get_current_key_ex(ht, &_str_index, &_str_length, &_num_index, 0, &_hpos)) { \
-            case HASH_KEY_IS_STRING: \
-                _zstr.len = _str_length - 1; \
-                _zstr.val = _str_index; \
-                _key = &_zstr; \
-                break; \
-            case HASH_KEY_IS_LONG: \
-                _h = _num_index; \
-                break; \
-            default: \
-                /* noop */ break; \
-        }
-
-#define ZEND_HASH_FOREACH_VAL(ht, _val) do { \
-    HashPosition _hpos; \
-    for (zend_hash_internal_pointer_reset_ex(ht, &_hpos); \
-         zend_hash_has_more_elements_ex(ht, &_hpos) == SUCCESS; \
-         zend_hash_move_forward_ex(ht, &_hpos) \
-    ) { \
-         _val = zend_hash_get_current_data_ex(ht, &_hpos); \
-
-#define ZEND_HASH_FOREACH_PTR(ht, _ptr) do { \
-    HashPosition _hpos; \
-    for (zend_hash_internal_pointer_reset_ex(ht, &_hpos); \
-         zend_hash_has_more_elements_ex(ht, &_hpos) == SUCCESS; \
-         zend_hash_move_forward_ex(ht, &_hpos) \
-    ) { \
-         _ptr = zend_hash_get_current_data_ptr_ex(ht, &_hpos); \
-
-#define ZEND_HASH_FOREACH_END() \
-    } \
-} while(0)
-
-#undef zend_hash_get_current_key
-#define zend_hash_get_current_key(ht, str_index, num_index) \
-    zend_hash_get_current_key_ex(ht, str_index, NULL, num_index, 0, NULL)
-
-#define zend_hash_str_exists(ht, str, len) zend_hash_exists(ht, str, len + 1)
-
-static zend_always_inline zval *
-zend_hash_str_find(const HashTable *ht, const char *key, size_t len)
-{
-    zval **zv;
-
-    if (zend_hash_find(ht, key, len + 1, (void **)&zv) == SUCCESS) {
-        return *zv;
-    }
-    return NULL;
-}
-
-static zend_always_inline void *
-zend_hash_str_find_ptr(const HashTable *ht, const char *str, size_t len)
-{
-    void **ptr;
-
-    if (zend_hash_find(ht, str, len + 1, (void **)&ptr) == SUCCESS) {
-        return *ptr;
-    }
-    return NULL;
-}
-
-static zend_always_inline void *
-zend_hash_str_update_ptr(HashTable *ht, const char *str, size_t len, void *pData)
-{
-    if (zend_hash_update(ht, str, len + 1, (void *)&pData, sizeof(void *), NULL) == SUCCESS) {
-        return pData;
-    }
-    return NULL;
-}
-
-static zend_always_inline void *
-zend_hash_index_update_ptr(HashTable *ht, zend_ulong h, void *pData)
-{
-    if (zend_hash_index_update(ht, h, (void **)&pData, sizeof(void *), NULL) == SUCCESS) {
-        return pData;
-    }
-    return NULL;
-}
-
-#undef zend_hash_get_current_data
-static zend_always_inline zval *
-zend_hash_get_current_data(HashTable *ht)
-{
-    zval **zv;
-
-    if (zend_hash_get_current_data_ex(ht, (void **)&zv, NULL) == SUCCESS) {
-        return *zv;
-    }
-    return NULL;
-}
-
-static zend_always_inline void *
-zend_hash_get_current_data_ptr_ex(HashTable *ht, HashPosition *pos)
-{
-    void **ptr;
-
-    if (zend_hash_get_current_data_ex(ht, (void **)&ptr, pos) == SUCCESS) {
-        return *ptr;
-    }
-    return NULL;
-}
-#define zend_hash_get_current_data_ptr(ht) zend_hash_get_current_data_ptr_ex(ht, NULL)
-
-static int (*_zend_hash_index_find)(const HashTable *, ulong, void **) = &zend_hash_index_find;
-#define zend_hash_index_find(ht, h) inline_zend_hash_index_find(ht, h)
-
-static zend_always_inline zval *
-inline_zend_hash_index_find(const HashTable *ht, zend_ulong h)
-{
-    zval **zv;
-    if (_zend_hash_index_find(ht, h, (void **)&zv) == SUCCESS) {
-        return *zv;
-    }
-    return NULL;
-}
-
-static zend_always_inline void *
-zend_hash_index_find_ptr(const HashTable *ht, zend_ulong h)
-{
-    void **ptr;
-
-    if (_zend_hash_index_find(ht, h, (void **)&ptr) == SUCCESS) {
-        return *ptr;
-    }
-    return NULL;
-}
-
-static int (*_zend_hash_get_current_data_ex)(HashTable *, void **, HashPosition *) = &zend_hash_get_current_data_ex;
-#define zend_hash_get_current_data_ex(ht, pos) inline_zend_hash_get_current_data_ex(ht, pos)
-static zend_always_inline zval *
-inline_zend_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;
-}
-
-#undef zend_hash_next_index_insert
-#define zend_hash_next_index_insert(ht, pData) \
-    _zend_hash_next_index_insert(ht, pData ZEND_FILE_LINE_CC)
-static zend_always_inline zval *
-_zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
-{
-    if (_zend_hash_index_update_or_next_insert(ht, 0, &pData, sizeof(pData),
-            NULL, HASH_NEXT_INSERT ZEND_FILE_LINE_CC) == SUCCESS
-    ) {
-        return pData;
-    }
-    return NULL;
-}
-
-#undef zend_get_parameters_array
-#define zend_get_parameters_array(ht, param_count, argument_array) \
-    inline_zend_get_parameters_array(ht, param_count, argument_array TSRMLS_CC)
-
-static zend_always_inline int
-inline_zend_get_parameters_array(int ht, int param_count, zval *argument_array TSRMLS_DC)
-{
-    int i, ret = FAILURE;
-    zval **zv = ecalloc(param_count, sizeof(zval *));
-
-    if (_zend_get_parameters_array(ht, param_count, zv TSRMLS_CC) == SUCCESS) {
-        for (i = 0; i < param_count; i++) {
-            argument_array[i] = *zv[i];
-        }
-        ret = SUCCESS;
-    }
-    efree(zv);
-    return ret;
-}
-
-typedef zend_rsrc_list_entry zend_resource;
-
-extern int (*_add_next_index_string)(zval *, const char *, int);
-#define add_next_index_string(arg, str) _add_next_index_string(arg, str, 1);
-extern int (*_add_next_index_stringl)(zval *, const char *, uint, int);
-#define add_next_index_stringl(arg, str, length) _add_next_index_stringl(arg, str, length, 1);
-
-#undef ZVAL_STRING
-#define ZVAL_STRING(z, s) do { \
-    const char *_s = (s); \
-    ZVAL_STRINGL(z, _s, strlen(_s)); \
-} while (0)
-#undef RETVAL_STRING
-#define RETVAL_STRING(s) ZVAL_STRING(return_value, s)
-#undef RETURN_STRING
-#define RETURN_STRING(s) { RETVAL_STRING(s); return; }
-
-#undef ZVAL_STRINGL
-#define ZVAL_STRINGL(z, s, l) do { \
-    const char *__s = (s); int __l = l; \
-    zval *__z = (z); \
-    Z_STRLEN_P(__z) = __l; \
-    Z_STRVAL_P(__z) = estrndup(__s, __l); \
-    Z_TYPE_P(__z) = IS_STRING; \
-} while (0)
-#undef RETVAL_STRINGL
-#define RETVAL_STRINGL(s, l) ZVAL_STRINGL(return_value, s, l)
-#undef RETURN_STRINGL
-#define RETURN_STRINGL(s, l) { RETVAL_STRINGL(s, l); return; }
-
-static int (*_call_user_function)(HashTable *, zval **, zval *, zval *, zend_uint, zval *[] TSRMLS_DC) = &call_user_function;
-#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \
-    inline_call_user_function(function_table, object, function_name, retval_ptr, param_count, params TSRMLS_CC)
-
-static zend_always_inline int
-inline_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[] TSRMLS_DC)
-{
-    int i, ret;
-    zval **_params = NULL;
-    if (!params) param_count = 0;
-    if (param_count > 0) {
-        _params = ecalloc(param_count, sizeof(zval *));
-        for (i = 0; i < param_count; ++i) {
-            zval *zv = &params[i];
-            MAKE_STD_ZVAL(_params[i]);
-            ZVAL_ZVAL(_params[i], zv, 1, 0);
-        }
-    }
-    ret = _call_user_function(function_table, &object, function_name, retval_ptr, param_count, _params TSRMLS_CC);
-    if (_params) {
-        for (i = 0; i < param_count; ++i) {
-            zval_ptr_dtor(&_params[i]);
-        }
-        efree(_params);
-    }
-    return ret;
-}
-
-#undef add_assoc_bool
-#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key), __b)
-extern int (*_add_assoc_bool_ex)(zval *, const char *, uint, int);
-#define add_assoc_bool_ex(_arg, _key, _key_len, _b) _add_assoc_bool_ex(_arg, _key, _key_len + 1, _b)
-
-#undef add_assoc_long
-#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
-extern int (*_add_assoc_long_ex)(zval *, const char *, uint, long);
-#define add_assoc_long_ex(_arg, _key, _key_len, _n) _add_assoc_long_ex(_arg, _key, _key_len + 1, _n)
-
-#undef add_assoc_double
-#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
-extern int (*_add_assoc_double_ex)(zval *, const char *, uint, double);
-#define add_assoc_double_ex(_arg, _key, _key_len, _d) _add_assoc_double_ex(_arg, _key, _key_len + 1, _d)
-
-#undef add_assoc_string
-#define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
-extern int (*_add_assoc_string_ex)(zval *, const char *, uint, char *, int);
-#define add_assoc_string_ex(_arg, _key, _key_len, _str) _add_assoc_string_ex(_arg, _key, _key_len + 1, _str, 1)
-
-extern int (*_add_assoc_stringl_ex)(zval *, const char *, uint, char *, uint, int);
-#define add_assoc_stringl_ex(_arg, _key, _key_len, _str, _length) _add_assoc_stringl_ex(_arg, _key, _key_len + 1, _str, _length, 1)
-
-#undef add_assoc_zval
-#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
-extern int (*_add_assoc_zval_ex)(zval *, const char *, uint, zval *);
-#define add_assoc_zval_ex(_arg, _key, _key_len, _value) _add_assoc_zval_ex(_arg, _key, _key_len + 1, _value);
-
-typedef long zend_long;
-static zend_always_inline zend_long
-zval_get_long(zval *op)
-{
-    switch (Z_TYPE_P(op)) {
-        case IS_BOOL:
-        case IS_LONG:
-            return Z_LVAL_P(op);
-        case IS_DOUBLE:
-            return zend_dval_to_lval(Z_DVAL_P(op));
-        case IS_STRING:
-            {
-                double dval;
-                zend_long lval;
-                zend_uchar type = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &lval, &dval, 0);
-                if (type == IS_LONG) {
-                    return lval;
-                } else if (type == IS_DOUBLE) {
-                    return zend_dval_to_lval(dval);
-                }
-            }
-            break;
-        EMPTY_SWITCH_DEFAULT_CASE()
-    }
-    return 0;
-}
-
-static zend_always_inline double
-zval_get_double(zval *op)
-{
-    switch (Z_TYPE_P(op)) {
-        case IS_BOOL:
-        case IS_LONG:
-            return (double)Z_LVAL_P(op);
-        case IS_DOUBLE:
-            return Z_DVAL_P(op);
-        case IS_STRING:
-            return zend_strtod(Z_STRVAL_P(op), NULL);
-        EMPTY_SWITCH_DEFAULT_CASE()
-    }
-    return 0.0;
-}
-
-static zend_always_inline zend_string *
-zval_get_string(zval *op)
-{
-    zend_string *zstr = ecalloc(1, sizeof(zend_string));
-
-    zstr->gc = 0;
-    ZSTR_VAL(zstr) = "";
-    ZSTR_LEN(zstr) = 0;
-    switch (Z_TYPE_P(op)) {
-        case IS_STRING:
-            ZSTR_VAL(zstr) = Z_STRVAL_P(op);
-            ZSTR_LEN(zstr) = Z_STRLEN_P(op);
-            break;
-        case IS_BOOL:
-            if (Z_LVAL_P(op)) {
-                ZSTR_VAL(zstr) = "1";
-                ZSTR_LEN(zstr) = 1;
-            }
-            break;
-        case IS_LONG: {
-            zstr->gc = 0x10;
-            ZSTR_LEN(zstr) = spprintf(&ZSTR_VAL(zstr), 0, "%ld", Z_LVAL_P(op));
-            break;
-        }
-        case IS_DOUBLE: {
-            zstr->gc = 0x10;
-            ZSTR_LEN(zstr) = spprintf(&ZSTR_VAL(zstr), 0, "%.16g", Z_DVAL_P(op));
-            break;
-        }
-        EMPTY_SWITCH_DEFAULT_CASE()
-    }
-    zstr->gc |= 0x01;
-    return zstr;
-}
-
-extern void (*_php_var_serialize)(smart_str *, zval **, php_serialize_data_t * TSRMLS_DC);
-#define php_var_serialize(buf, struc, data) _php_var_serialize(buf, &struc, data TSRMLS_CC)
-extern int (*_php_var_unserialize)(zval **, const unsigned char **, const unsigned char *, php_unserialize_data_t * TSRMLS_DC);
-#define php_var_unserialize(rval, p, max, var_hash) _php_var_unserialize(&rval, p, max, var_hash TSRMLS_CC)
-typedef int strlen_t;
-
-#define PHPREDIS_ZVAL_IS_STRICT_FALSE(z) (Z_TYPE_P(z) == IS_BOOL && !Z_BVAL_P(z))
-
-/* If ZEND_MOD_END isn't defined, use legacy version */
-#ifndef ZEND_MOD_END
-#define ZEND_MOD_END { NULL, NULL, NULL }
-#endif
-
-/* PHP_FE_END exists since 5.3.7 */
-#ifndef PHP_FE_END
-#define PHP_FE_END { NULL, NULL, NULL }
-#endif
-
-/* References don't need any actions */
-#define ZVAL_DEREF(v) PHPREDIS_NOTUSED(v)
-
-#define PHPREDIS_GET_OBJECT(class_entry, z) (class_entry *)zend_objects_get_address(z TSRMLS_CC)
-
-#else
 #include <zend_smart_str.h>
 #include <ext/standard/php_smart_string.h>
-typedef size_t strlen_t;
+
 #define PHPREDIS_ZVAL_IS_STRICT_FALSE(z) (Z_TYPE_P(z) == IS_FALSE)
 #define PHPREDIS_GET_OBJECT(class_entry, z) (class_entry *)((char *)Z_OBJ_P(z) - XtOffsetOf(class_entry, std))
 
-#define REDIS_MAKE_STD_ZVAL(zv) do {} while(0)
-#define REDIS_FREE_ZVAL(zv) do {} while(0)
-#endif
-
 /* NULL check so Eclipse doesn't go crazy */
 #ifndef NULL
 #define NULL   ((void *) 0)
@@ -716,17 +269,10 @@ typedef struct {
 } RedisSock;
 /* }}} */
 
-#if (PHP_MAJOR_VERSION < 7)
-typedef struct {
-    zend_object std;
-    RedisSock *sock;
-} redis_object;
-#else
 typedef struct {
     RedisSock *sock;
     zend_object std;
 } redis_object;
-#endif
 
 /** Argument info for any function expecting 0 args */
 ZEND_BEGIN_ARG_INFO_EX(arginfo_void, 0, 0, 0)
@@ -762,21 +308,13 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_nkeys, 0, 0, 1)
     ZEND_ARG_INFO(0, key)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_keys)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_dst_nkeys, 0, 0, 2)
     ZEND_ARG_INFO(0, dst)
     ZEND_ARG_INFO(0, key)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_keys)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_key_min_max, 0, 0, 3)
@@ -799,11 +337,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_key_members, 0, 0, 2)
     ZEND_ARG_INFO(0, key)
     ZEND_ARG_INFO(0, member)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_members)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_key_timestamp, 0, 0, 2)
@@ -857,12 +391,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_blrpop, 0, 0, 2)
     ZEND_ARG_INFO(0, key)
     ZEND_ARG_INFO(0, timeout_or_key)
-// Can't have variadic keys before timeout.
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, extra_args)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_linsert, 0, 0, 4)
@@ -924,11 +453,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_bitop, 0, 0, 3)
     ZEND_ARG_INFO(0, operation)
     ZEND_ARG_INFO(0, ret_key)
     ZEND_ARG_INFO(0, key)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_keys)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_bitpos, 0, 0, 2)
@@ -1020,20 +545,12 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_unsubscribe, 0, 0, 1)
     ZEND_ARG_INFO(0, channel)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_channels)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_punsubscribe, 0, 0, 1)
     ZEND_ARG_INFO(0, pattern)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_patterns)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_eval, 0, 0, 1)
@@ -1059,28 +576,16 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_watch, 0, 0, 1)
     ZEND_ARG_INFO(0, key)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_keys)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_command, 0, 0, 0)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, args)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_rawcommand, 0, 0, 1)
     ZEND_ARG_INFO(0, cmd)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, args)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_geoadd, 0, 0, 4)
@@ -1088,11 +593,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_geoadd, 0, 0, 4)
     ZEND_ARG_INFO(0, lng)
     ZEND_ARG_INFO(0, lat)
     ZEND_ARG_INFO(0, member)
-#if PHP_VERSION_ID >= 50600
     ZEND_ARG_VARIADIC_INFO(0, other_triples)
-#else
-    ZEND_ARG_INFO(0, ...)
-#endif
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_geodist, 0, 0, 3)
diff --git a/library.c b/library.c
index 93a44600..26358e11 100644
--- a/library.c
+++ b/library.c
@@ -38,24 +38,6 @@
     #include <sys/socket.h>  /* SO_KEEPALIVE */
 #else
     #include <winsock.h>
-
-    # if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION <= 4
-        /* This proto is available from 5.5 on only */
-        PHP_REDIS_API int usleep(unsigned int useconds);
-    # endif
-#endif
-
-#if (PHP_MAJOR_VERSION < 7)
-    int (*_add_next_index_string)(zval *, const char *, int) = &add_next_index_string;
-    int (*_add_next_index_stringl)(zval *, const char *, uint, int) = &add_next_index_stringl;
-    int (*_add_assoc_bool_ex)(zval *, const char *, uint, int) = &add_assoc_bool_ex;
-    int (*_add_assoc_long_ex)(zval *, const char *, uint, long) = &add_assoc_long_ex;
-    int (*_add_assoc_double_ex)(zval *, const char *, uint, double) = &add_assoc_double_ex;
-    int (*_add_assoc_string_ex)(zval *, const char *, uint, char *, int) = &add_assoc_string_ex;
-    int (*_add_assoc_stringl_ex)(zval *, const char *, uint, char *, uint, int) = &add_assoc_stringl_ex;
-    int (*_add_assoc_zval_ex)(zval *, const char *, uint, zval *) = &add_assoc_zval_ex;
-    void (*_php_var_serialize)(smart_str *, zval **, php_serialize_data_t * TSRMLS_DC) = &php_var_serialize;
-    int (*_php_var_unserialize)(zval **, const unsigned char **, const unsigned char *, php_unserialize_data_t * TSRMLS_DC) = &php_var_unserialize;
 #endif
 
 extern zend_class_entry *redis_ce;
@@ -316,13 +298,8 @@ PHP_REDIS_API int redis_subscribe_response(INTERNAL_FUNCTION_PARAMETERS,
         zval_dtor(&z_resp);
     }
 
-#if (PHP_MAJOR_VERSION < 7)
-    zval *z_ret, **z_args[4];
-    sctx->cb.retval_ptr_ptr = &z_ret;
-#else
     zval z_ret, z_args[4];
     sctx->cb.retval = &z_ret;
-#endif
     sctx->cb.params = z_args;
     sctx->cb.no_separation = 0;
 
@@ -367,17 +344,6 @@ PHP_REDIS_API int redis_subscribe_response(INTERNAL_FUNCTION_PARAMETERS,
         }
 
         // Different args for SUBSCRIBE and PSUBSCRIBE
-#if (PHP_MAJOR_VERSION < 7)
-        z_args[0] = &getThis();
-        if(is_pmsg) {
-            z_args[1] = &z_pat;
-            z_args[2] = &z_chan;
-            z_args[3] = &z_data;
-        } else {
-            z_args[1] = &z_chan;
-            z_args[2] = &z_data;
-        }
-#else
         z_args[0] = *getThis();
         if(is_pmsg) {
             z_args[1] = *z_pat;
@@ -387,7 +353,6 @@ PHP_REDIS_API int redis_subscribe_response(INTERNAL_FUNCTION_PARAMETERS,
             z_args[1] = *z_chan;
             z_args[2] = *z_data;
         }
-#endif
 
         // Set arg count
         sctx->cb.param_count = tab_idx;
@@ -575,7 +540,7 @@ union resparg {
 /* A printf like method to construct a Redis RESP command.  It has been extended
  * to take a few different format specifiers that are convienient to phpredis.
  *
- * s - C string followed by length as a strlen_t
+ * s - C string followed by length as a 
  * S - Pointer to a zend_string
  * k - Same as 's' but the value will be prefixed if phpredis is set up do do
  *     that and the working slot will be set if it has been passed.
@@ -594,7 +559,7 @@ redis_spprintf(RedisSock *redis_sock, short *slot TSRMLS_DC, char **ret, char *k
     union resparg arg;
     char *dup;
     int argfree;
-    strlen_t arglen;
+    size_t arglen;
 
     va_start(ap, fmt);
 
@@ -605,7 +570,7 @@ redis_spprintf(RedisSock *redis_sock, short *slot TSRMLS_DC, char **ret, char *k
         switch (*fmt) {
             case 's':
                 arg.str = va_arg(ap, char*);
-                arglen = va_arg(ap, strlen_t);
+                arglen = va_arg(ap, size_t);
                 redis_cmd_append_sstr(&cmd, arg.str, arglen);
                 break;
             case 'S':
@@ -614,7 +579,7 @@ redis_spprintf(RedisSock *redis_sock, short *slot TSRMLS_DC, char **ret, char *k
                 break;
             case 'k':
                 arg.str = va_arg(ap, char*);
-                arglen = va_arg(ap, strlen_t);
+                arglen = va_arg(ap, size_t);
                 argfree = redis_key_prefix(redis_sock, &arg.str, &arglen);
                 redis_cmd_append_sstr(&cmd, arg.str, arglen);
                 if (slot) *slot = cluster_hash_key(arg.str, arglen);
@@ -736,7 +701,7 @@ redis_cmd_append_sstr_dbl(smart_string *str, double value)
  * configured to do that */
 int redis_cmd_append_sstr_zval(smart_string *str, zval *z, RedisSock *redis_sock TSRMLS_DC) {
     char *val;
-    strlen_t vallen;
+    size_t vallen;
     int valfree, retval;
 
     valfree = redis_pack(redis_sock, z, &val, &vallen TSRMLS_CC);
@@ -748,7 +713,7 @@ int redis_cmd_append_sstr_zval(smart_string *str, zval *z, RedisSock *redis_sock
 
 /* Append a string key to a redis command.  This function takes care of prefixing the key
  * for the caller and setting the slot argument if it is passed non null */
-int redis_cmd_append_sstr_key(smart_string *str, char *key, strlen_t len, RedisSock *redis_sock, short *slot) {
+int redis_cmd_append_sstr_key(smart_string *str, char *key, size_t len, RedisSock *redis_sock, short *slot) {
     int valfree, retval;
 
     valfree = redis_key_prefix(redis_sock, &key, &len);
@@ -838,7 +803,7 @@ PHP_REDIS_API void redis_type_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *
 PHP_REDIS_API void redis_info_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx) {
     char *response;
     int response_len;
-    zval zv = {{0}}, *z_ret = &zv;
+    zval z_ret;
 
     /* Read bulk response */
     if ((response = redis_sock_read(redis_sock, &response_len TSRMLS_CC)) == NULL) {
@@ -846,16 +811,16 @@ PHP_REDIS_API void redis_info_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *
     }
 
     /* Parse it into a zval array */
-    REDIS_MAKE_STD_ZVAL(z_ret);
-    redis_parse_info_response(response, z_ret);
+    ZVAL_UNDEF(&z_ret);
+    redis_parse_info_response(response, &z_ret);
 
     /* Free source response */
     efree(response);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_ret, 0, 1);
+        RETVAL_ZVAL(&z_ret, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_ret);
+        add_next_index_zval(z_tab, &z_ret);
     }
 }
 
@@ -916,28 +881,24 @@ redis_parse_info_response(char *response, zval *z_ret)
 PHP_REDIS_API void redis_client_list_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab) {
     char *resp;
     int resp_len;
+    zval z_ret;
 
     /* Make sure we can read the bulk response from Redis */
     if ((resp = redis_sock_read(redis_sock, &resp_len TSRMLS_CC)) == NULL) {
         RETURN_FALSE;
     }
 
-    zval zv, *z_ret = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#endif
-
     /* Parse it out */
-    redis_parse_client_list_response(resp, z_ret);
+    redis_parse_client_list_response(resp, &z_ret);
 
     /* Free our response */
     efree(resp);
 
     /* Return or append depending if we're atomic */
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_ret, 0, 1);
+        RETVAL_ZVAL(&z_ret, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_ret);
+        add_next_index_zval(z_tab, &z_ret);
     }
 }
 
@@ -946,16 +907,11 @@ redis_parse_client_list_response(char *response, zval *z_ret)
 {
     char *p, *lpos, *kpos = NULL, *vpos = NULL, *p2, *key, *value;
     int klen = 0, done = 0, is_numeric;
+    zval z_sub_result;
 
-    // Allocate memory for our response
+    /* Allocate for response and our user */
     array_init(z_ret);
-
-    /* Allocate memory for one user (there should be at least one, namely us!) */
-    zval zv, *z_sub_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    ALLOC_INIT_ZVAL(z_sub_result);
-#endif
-    array_init(z_sub_result);
+    array_init(&z_sub_result);
 
     // Pointers for parsing
     p = response;
@@ -995,22 +951,19 @@ redis_parse_client_list_response(char *response, zval *z_ret)
 
                     /* Add as a long or string, depending */
                     if(is_numeric == 1) {
-                        add_assoc_long(z_sub_result, key, atol(value));
+                        add_assoc_long(&z_sub_result, key, atol(value));
                     } else {
-                        add_assoc_string(z_sub_result, key, value);
+                        add_assoc_string(&z_sub_result, key, value);
                     }
                     efree(value);
                     // If we hit a '\n', then we can add this user to our list
                     if(*p == '\n') {
                         /* Add our user */
-                        add_next_index_zval(z_ret, z_sub_result);
+                        add_next_index_zval(z_ret, &z_sub_result);
 
                         /* If we have another user, make another one */
                         if(*(p+1) != '\0') {
-#if (PHP_MAJOR_VERSION < 7)
-                            ALLOC_INIT_ZVAL(z_sub_result);
-#endif
-                            array_init(z_sub_result);
+                            array_init(&z_sub_result);
                         }
                     }
 
@@ -1128,10 +1081,10 @@ static void array_zip_values_and_scores(RedisSock *redis_sock, zval *z_tab,
                                         int decode TSRMLS_DC)
 {
 
-    zval zv, *z_ret = &zv;
+    zval z_ret, z_sub;
     HashTable *keytable;
 
-    array_init(z_ret);
+    array_init(&z_ret);
     keytable = Z_ARRVAL_P(z_tab);
 
     for(zend_hash_internal_pointer_reset(keytable);
@@ -1161,24 +1114,20 @@ static void array_zip_values_and_scores(RedisSock *redis_sock, zval *z_tab,
 
         /* Decode the score depending on flag */
         if (decode == SCORE_DECODE_INT && Z_STRLEN_P(z_value_p) > 0) {
-            add_assoc_long_ex(z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), atoi(hval+1));
+            add_assoc_long_ex(&z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), atoi(hval+1));
         } else if (decode == SCORE_DECODE_DOUBLE) {
-            add_assoc_double_ex(z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), atof(hval));
+            add_assoc_double_ex(&z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), atof(hval));
         } else {
-            zval zv0, *z = &zv0;
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z);
-#endif
-            ZVAL_ZVAL(z, z_value_p, 1, 0);
-            add_assoc_zval_ex(z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), z);
+            ZVAL_ZVAL(&z_sub, z_value_p, 1, 0);
+            add_assoc_zval_ex(&z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), &z_sub);
         }
         zend_string_release(hkey);
     }
 
     /* replace */
     zval_dtor(z_tab);
-    ZVAL_ZVAL(z_tab, z_ret, 1, 0);
-    zval_dtor(z_ret);
+    ZVAL_ZVAL(z_tab, &z_ret, 1, 0);
+    zval_dtor(&z_ret);
 }
 
 static int
@@ -1226,22 +1175,19 @@ redis_mbulk_reply_zipped(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         return -1;
     }
     numElems = atoi(inbuf+1);
-    zval zv, *z_multi_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_multi_result);
-#endif
-    array_init(z_multi_result); /* pre-allocate array for multi's results. */
+    zval z_multi_result;
+    array_init(&z_multi_result); /* pre-allocate array for multi's results. */
 
     /* Grab our key, value, key, value array */
-    redis_mbulk_reply_loop(redis_sock, z_multi_result, numElems, unserialize TSRMLS_CC);
+    redis_mbulk_reply_loop(redis_sock, &z_multi_result, numElems, unserialize TSRMLS_CC);
 
     /* Zip keys and values */
-    array_zip_values_and_scores(redis_sock, z_multi_result, decode TSRMLS_CC);
+    array_zip_values_and_scores(redis_sock, &z_multi_result, decode TSRMLS_CC);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_multi_result, 0, 1);
+        RETVAL_ZVAL(&z_multi_result, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_multi_result);
+        add_next_index_zval(z_tab, &z_multi_result);
     }
 
     return 0;
@@ -1280,7 +1226,7 @@ PHP_REDIS_API int
 redis_read_stream_messages(RedisSock *redis_sock, int count, zval *z_ret
                            TSRMLS_DC)
 {
-    zval zv, *z_message = &zv;
+    zval z_message;
     int i, mhdr, fields;
     char *id = NULL;
     int idlen;
@@ -1297,12 +1243,11 @@ redis_read_stream_messages(RedisSock *redis_sock, int count, zval *z_ret
             return -1;
         }
 
-        REDIS_MAKE_STD_ZVAL(z_message);
-        array_init(z_message);
+        array_init(&z_message);
 
-        redis_mbulk_reply_loop(redis_sock, z_message, fields, UNSERIALIZE_VALS TSRMLS_CC);
-        array_zip_values_and_scores(redis_sock, z_message, SCORE_DECODE_NONE TSRMLS_CC);
-        add_assoc_zval_ex(z_ret, id, idlen, z_message);
+        redis_mbulk_reply_loop(redis_sock, &z_message, fields, UNSERIALIZE_VALS TSRMLS_CC);
+        array_zip_values_and_scores(redis_sock, &z_message, SCORE_DECODE_NONE TSRMLS_CC);
+        add_assoc_zval_ex(z_ret, id, idlen, &z_message);
         efree(id);
     }
 
@@ -1313,17 +1258,15 @@ PHP_REDIS_API int
 redis_xrange_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                    zval *z_tab, void *ctx)
 {
+    zval z_messages;
     int messages;
-    zval zv, *z_messages = &zv;
 
-    REDIS_MAKE_STD_ZVAL(z_messages);
-    array_init(z_messages);
+    array_init(&z_messages);
 
     if (read_mbulk_header(redis_sock, &messages TSRMLS_CC) < 0 ||
-        redis_read_stream_messages(redis_sock, messages, z_messages TSRMLS_CC) < 0)
+        redis_read_stream_messages(redis_sock, messages, &z_messages TSRMLS_CC) < 0)
     {
-        zval_dtor(z_messages);
-        REDIS_FREE_ZVAL(z_messages);
+        zval_dtor(&z_messages);
         if (IS_ATOMIC(redis_sock)) {
             RETVAL_FALSE;
         } else {
@@ -1333,9 +1276,9 @@ redis_xrange_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_messages, 0, 1);
+        RETVAL_ZVAL(&z_messages, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_messages);
+        add_next_index_zval(z_tab, &z_messages);
     }
 
     return 0;
@@ -1345,7 +1288,7 @@ PHP_REDIS_API int
 redis_read_stream_messages_multi(RedisSock *redis_sock, int count, zval *z_streams
                                  TSRMLS_DC)
 {
-    zval zv, *z_messages = &zv;
+    zval z_messages;
     int i, shdr, messages;
     char *id = NULL;
     int idlen;
@@ -1359,21 +1302,19 @@ redis_read_stream_messages_multi(RedisSock *redis_sock, int count, zval *z_strea
             return -1;
         }
 
-        REDIS_MAKE_STD_ZVAL(z_messages);
-        array_init(z_messages);
+        array_init(&z_messages);
 
-        if (redis_read_stream_messages(redis_sock, messages, z_messages TSRMLS_CC) < 0)
+        if (redis_read_stream_messages(redis_sock, messages, &z_messages TSRMLS_CC) < 0)
             goto failure;
 
-        add_assoc_zval_ex(z_streams, id, idlen, z_messages);
+        add_assoc_zval_ex(z_streams, id, idlen, &z_messages);
         efree(id);
     }
 
     return 0;
 failure:
     efree(id);
-    zval_dtor(z_messages);
-    REDIS_FREE_ZVAL(z_messages);
+    zval_dtor(&z_messages);
     return -1;
 }
 
@@ -1381,28 +1322,26 @@ PHP_REDIS_API int
 redis_xread_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                   zval *z_tab, void *ctx)
 {
-    zval zv, *z_rv = &zv;
+    zval z_rv;
     int streams;
 
     if (read_mbulk_header(redis_sock, &streams TSRMLS_CC) < 0)
         goto failure;
 
-    REDIS_MAKE_STD_ZVAL(z_rv);
-    array_init(z_rv);
+    array_init(&z_rv);
 
-    if (redis_read_stream_messages_multi(redis_sock, streams, z_rv TSRMLS_CC) < 0)
+    if (redis_read_stream_messages_multi(redis_sock, streams, &z_rv TSRMLS_CC) < 0)
         goto cleanup;
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_rv, 0, 1);
+        RETVAL_ZVAL(&z_rv, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_rv);
+        add_next_index_zval(z_tab, &z_rv);
     }
     return 0;
 
 cleanup:
-    zval_dtor(z_rv);
-    REDIS_FREE_ZVAL(z_rv);
+    zval_dtor(&z_rv);
 failure:
     if (IS_ATOMIC(redis_sock)) {
         RETVAL_FALSE;
@@ -1417,7 +1356,7 @@ failure:
  * on whether or not it was called with the JUSTID option */
 PHP_REDIS_API int
 redis_read_xclaim_response(RedisSock *redis_sock, int count, zval *rv TSRMLS_DC) {
-    zval zv, *z_msg = &zv;
+    zval z_msg;
     REDIS_REPLY_TYPE type;
     char *id = NULL;
     int i, fields, idlen;
@@ -1444,12 +1383,11 @@ redis_read_xclaim_response(RedisSock *redis_sock, int count, zval *rv TSRMLS_DC)
                 return -1;
             }
 
-            REDIS_MAKE_STD_ZVAL(z_msg);
-            array_init(z_msg);
+            array_init(&z_msg);
 
-            redis_mbulk_reply_loop(redis_sock, z_msg, fields, UNSERIALIZE_VALS TSRMLS_CC);
-            array_zip_values_and_scores(redis_sock, z_msg, SCORE_DECODE_NONE TSRMLS_CC);
-            add_assoc_zval_ex(rv, id, idlen, z_msg);
+            redis_mbulk_reply_loop(redis_sock, &z_msg, fields, UNSERIALIZE_VALS TSRMLS_CC);
+            array_zip_values_and_scores(redis_sock, &z_msg, SCORE_DECODE_NONE TSRMLS_CC);
+            add_assoc_zval_ex(rv, id, idlen, &z_msg);
             efree(id);
         }
     }
@@ -1461,26 +1399,24 @@ PHP_REDIS_API int
 redis_xclaim_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                    zval *z_tab, void *ctx)
 {
-    zval zv, *z_ret = &zv;
+    zval z_ret;
     int messages;
 
     /* All XCLAIM responses start multibulk */
     if (read_mbulk_header(redis_sock, &messages TSRMLS_CC) < 0)
         goto failure;
 
-    REDIS_MAKE_STD_ZVAL(z_ret);
-    array_init(z_ret);
+    array_init(&z_ret);
 
-    if (redis_read_xclaim_response(redis_sock, messages, z_ret TSRMLS_CC) < 0) {
-        zval_dtor(z_ret);
-        REDIS_FREE_ZVAL(z_ret);
+    if (redis_read_xclaim_response(redis_sock, messages, &z_ret TSRMLS_CC) < 0) {
+        zval_dtor(&z_ret);
         goto failure;
     }
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_ret, 0, 1);
+        RETVAL_ZVAL(&z_ret, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_ret);
+        add_next_index_zval(z_tab, &z_ret);
     }
     return 0;
 
@@ -1562,13 +1498,9 @@ PHP_REDIS_API void redis_string_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock
             RETVAL_STRINGL(response, response_len);
         }
     } else {
-        zval zv, *z = &zv;
-        if (redis_unpack(redis_sock, response, response_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z);
-            *z = zv;
-#endif
-            add_next_index_zval(z_tab, z);
+        zval z_unpacked;
+        if (redis_unpack(redis_sock, response, response_len, &z_unpacked TSRMLS_CC)) {
+            add_next_index_zval(z_tab, &z_unpacked);
         } else {
             add_next_index_stringl(z_tab, response, response_len);
         }
@@ -1642,11 +1574,8 @@ PHP_REDIS_API void redis_debug_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock
         return;
     }
 
-    zval zv, *z_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_result);
-#endif
-    array_init(z_result);
+    zval z_result;
+    array_init(&z_result);
 
     /* Skip the '+' */
     p = resp + 1;
@@ -1673,9 +1602,9 @@ PHP_REDIS_API void redis_debug_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock
 
         /* Add our value */
         if(is_numeric) {
-            add_assoc_long(z_result, p, atol(p2));
+            add_assoc_long(&z_result, p, atol(p2));
         } else {
-            add_assoc_string(z_result, p, p2);
+            add_assoc_string(&z_result, p, p2);
         }
 
         p = p3;
@@ -1684,9 +1613,9 @@ PHP_REDIS_API void redis_debug_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock
     efree(resp);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_result, 0, 1);
+        RETVAL_ZVAL(&z_result, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_result);
+        add_next_index_zval(z_tab, &z_result);
     }
 }
 
@@ -1748,11 +1677,7 @@ PHP_REDIS_API int redis_sock_connect(RedisSock *redis_sock TSRMLS_DC)
     int host_len, usocket = 0, err = 0;
     php_netstream_data_t *sock;
     int tcp_flag = 1;
-#if (PHP_MAJOR_VERSION < 7)
-    char *estr = NULL;
-#else
     zend_string *estr = NULL;
-#endif
 
     if (redis_sock->stream != NULL) {
         redis_sock_disconnect(redis_sock, 0 TSRMLS_CC);
@@ -1804,13 +1729,8 @@ PHP_REDIS_API int redis_sock_connect(RedisSock *redis_sock TSRMLS_DC)
 
     if (!redis_sock->stream) {
         if (estr) {
-#if (PHP_MAJOR_VERSION < 7)
-            redis_sock_set_err(redis_sock, estr, strlen(estr));
-            efree(estr);
-#else
             redis_sock_set_err(redis_sock, ZSTR_VAL(estr), ZSTR_LEN(estr));
             zend_string_release(estr);
-#endif
         }
         return -1;
     }
@@ -1927,19 +1847,17 @@ PHP_REDIS_API int redis_sock_read_multibulk_reply(INTERNAL_FUNCTION_PARAMETERS,
         return -1;
     }
     numElems = atoi(inbuf+1);
-    zval zv, *z_multi_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_multi_result);
-#endif
-    array_init(z_multi_result); /* pre-allocate array for multi's results. */
+    zval z_multi_result;
+    array_init(&z_multi_result); /* pre-allocate array for multi's results. */
 
-    redis_mbulk_reply_loop(redis_sock, z_multi_result, numElems, UNSERIALIZE_ALL TSRMLS_CC);
+    redis_mbulk_reply_loop(redis_sock, &z_multi_result, numElems, UNSERIALIZE_ALL TSRMLS_CC);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_multi_result, 0, 1);
+        RETVAL_ZVAL(&z_multi_result, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_multi_result);
+        add_next_index_zval(z_tab, &z_multi_result);
     }
+
     /*zval_copy_ctor(return_value); */
     return 0;
 }
@@ -1969,18 +1887,15 @@ redis_mbulk_reply_raw(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval
         return -1;
     }
     numElems = atoi(inbuf+1);
-    zval zv, *z_multi_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_multi_result);
-#endif
-    array_init(z_multi_result); /* pre-allocate array for multi's results. */
+    zval z_multi_result;
+    array_init(&z_multi_result); /* pre-allocate array for multi's results. */
 
-    redis_mbulk_reply_loop(redis_sock, z_multi_result, numElems, UNSERIALIZE_NONE TSRMLS_CC);
+    redis_mbulk_reply_loop(redis_sock, &z_multi_result, numElems, UNSERIALIZE_NONE TSRMLS_CC);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_multi_result, 0, 1);
+        RETVAL_ZVAL(&z_multi_result, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_multi_result);
+        add_next_index_zval(z_tab, &z_multi_result);
     }
     /*zval_copy_ctor(return_value); */
     return 0;
@@ -1990,6 +1905,7 @@ PHP_REDIS_API void
 redis_mbulk_reply_loop(RedisSock *redis_sock, zval *z_tab, int count,
                        int unserialize TSRMLS_DC)
 {
+    zval z_unpacked;
     char *line;
     int i, len;
 
@@ -2007,13 +1923,9 @@ redis_mbulk_reply_loop(RedisSock *redis_sock, zval *z_tab, int count,
             (unserialize == UNSERIALIZE_KEYS && i % 2 == 0) ||
             (unserialize == UNSERIALIZE_VALS && i % 2 != 0)
         );
-        zval zv, *z = &zv;
-        if (unwrap && redis_unpack(redis_sock, line, len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z);
-            *z = zv;
-#endif
-            add_next_index_zval(z_tab, z);
+
+        if (unwrap && redis_unpack(redis_sock, line, len, &z_unpacked TSRMLS_CC)) {
+            add_next_index_zval(z_tab, &z_unpacked);
         } else {
             add_next_index_stringl(z_tab, line, len);
         }
@@ -2045,29 +1957,22 @@ PHP_REDIS_API int redis_mbulk_reply_assoc(INTERNAL_FUNCTION_PARAMETERS, RedisSoc
         return -1;
     }
     numElems = atoi(inbuf+1);
-    zval zv, *z_multi_result = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_multi_result);
-#endif
-    array_init(z_multi_result); /* pre-allocate array for multi's results. */
+    zval z_multi_result;
+    array_init(&z_multi_result); /* pre-allocate array for multi's results. */
 
     for(i = 0; i < numElems; ++i) {
         zend_string *zstr = zval_get_string(&z_keys[i]);
         response = redis_sock_read(redis_sock, &response_len TSRMLS_CC);
         if(response != NULL) {
-            zval zv0, *z = &zv0;
-            if (redis_unpack(redis_sock, response, response_len, z TSRMLS_CC)) {
-#if (PHP_MAJOR_VERSION < 7)
-                MAKE_STD_ZVAL(z);
-                *z = zv0;
-#endif
-                add_assoc_zval_ex(z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), z);
+            zval z_unpacked;
+            if (redis_unpack(redis_sock, response, response_len, &z_unpacked TSRMLS_CC)) {
+                add_assoc_zval_ex(&z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), &z_unpacked);
             } else {
-                add_assoc_stringl_ex(z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), response, response_len);
+                add_assoc_stringl_ex(&z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), response, response_len);
             }
             efree(response);
         } else {
-            add_assoc_bool_ex(z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), 0);
+            add_assoc_bool_ex(&z_multi_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), 0);
         }
         zend_string_release(zstr);
         zval_dtor(&z_keys[i]);
@@ -2075,9 +1980,9 @@ PHP_REDIS_API int redis_mbulk_reply_assoc(INTERNAL_FUNCTION_PARAMETERS, RedisSoc
     efree(z_keys);
 
     if (IS_ATOMIC(redis_sock)) {
-        RETVAL_ZVAL(z_multi_result, 0, 1);
+        RETVAL_ZVAL(&z_multi_result, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_multi_result);
+        add_next_index_zval(z_tab, &z_multi_result);
     }
     return 0;
 }
@@ -2123,11 +2028,11 @@ PHP_REDIS_API void redis_free_socket(RedisSock *redis_sock)
 }
 
 PHP_REDIS_API int
-redis_pack(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len TSRMLS_DC)
+redis_pack(RedisSock *redis_sock, zval *z, char **val, size_t *val_len TSRMLS_DC)
 {
     char *buf;
     int valfree;
-    strlen_t len;
+    size_t len;
 #ifdef HAVE_REDIS_LZF
     char *data;
     uint32_t res;
@@ -2190,14 +2095,11 @@ redis_unpack(RedisSock *redis_sock, const char *val, int val_len, zval *z_ret TS
 }
 
 PHP_REDIS_API int
-redis_serialize(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len
+redis_serialize(RedisSock *redis_sock, zval *z, char **val, size_t *val_len
                 TSRMLS_DC)
 {
-#if ZEND_MODULE_API_NO >= 20100000
     php_serialize_data_t ht;
-#else
-    HashTable ht;
-#endif
+
     smart_str sstr = {0};
 #ifdef HAVE_REDIS_IGBINARY
     size_t sz;
@@ -2235,29 +2137,16 @@ redis_serialize(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len
             }
             break;
         case REDIS_SERIALIZER_PHP:
-
-#if ZEND_MODULE_API_NO >= 20100000
             PHP_VAR_SERIALIZE_INIT(ht);
-#else
-            zend_hash_init(&ht, 10, NULL, NULL, 0);
-#endif
             php_var_serialize(&sstr, z, &ht);
-#if (PHP_MAJOR_VERSION < 7)
-            *val = estrndup(sstr.c, sstr.len);
-            *val_len = sstr.len;
-#else
+
             *val = estrndup(ZSTR_VAL(sstr.s), ZSTR_LEN(sstr.s));
             *val_len = ZSTR_LEN(sstr.s);
-#endif
+
             smart_str_free(&sstr);
-#if ZEND_MODULE_API_NO >= 20100000
             PHP_VAR_SERIALIZE_DESTROY(ht);
-#else
-            zend_hash_destroy(&ht);
-#endif
 
             return 1;
-
         case REDIS_SERIALIZER_IGBINARY:
 #ifdef HAVE_REDIS_IGBINARY
             if(igbinary_serialize(&val8, (size_t *)&sz, z TSRMLS_CC) == 0) {
@@ -2281,21 +2170,19 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
 
     switch(redis_sock->serializer) {
         case REDIS_SERIALIZER_PHP:
-#if ZEND_MODULE_API_NO >= 20100000
             PHP_VAR_UNSERIALIZE_INIT(var_hash);
-#else
-            memset(&var_hash, 0, sizeof(var_hash));
-#endif
-            if (php_var_unserialize(z_ret, (const unsigned char**)&val,
-                    (const unsigned char*)val + val_len, &var_hash)
-            ) {
-                ret = 1;
-            }
-#if ZEND_MODULE_API_NO >= 20100000
+
+            ret = php_var_unserialize(z_ret, (const unsigned char **)&val,
+                                      (const unsigned char *)val + val_len, 
+                                       &var_hash);
+
+            //if (php_var_unserialize(z_ret, (const unsigned char**)&val,
+            //        (const unsigned char*)val + val_len, &var_hash)
+            //) {
+            //    ret = 1;
+            //}
+
             PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-#else
-            var_destroy(&var_hash);
-#endif
             break;
 
         case REDIS_SERIALIZER_IGBINARY:
@@ -2324,21 +2211,15 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
                 break;
             }
 
-#if (PHP_MAJOR_VERSION < 7)
-            INIT_PZVAL(z_ret);
-            ret = !igbinary_unserialize((const uint8_t *)val, (size_t)val_len, &z_ret TSRMLS_CC);
-#else
             ret = !igbinary_unserialize((const uint8_t *)val, (size_t)val_len, z_ret TSRMLS_CC);
 #endif
-
-#endif
             break;
     }
     return ret;
 }
 
 PHP_REDIS_API int
-redis_key_prefix(RedisSock *redis_sock, char **key, strlen_t *key_len) {
+redis_key_prefix(RedisSock *redis_sock, char **key, size_t *key_len) {
     int ret_len;
     char *ret;
 
@@ -2481,7 +2362,7 @@ redis_read_multibulk_recursive(RedisSock *redis_sock, int elements, int status_s
 {
     long reply_info;
     REDIS_REPLY_TYPE reply_type;
-    zval zv, *z_subelem = &zv;
+    zval z_subelem;
 
     // Iterate while we have elements
     while(elements > 0) {
@@ -2498,12 +2379,9 @@ redis_read_multibulk_recursive(RedisSock *redis_sock, int elements, int status_s
         switch(reply_type) {
             case TYPE_ERR:
             case TYPE_LINE:
-#if (PHP_MAJOR_VERSION < 7)
-                ALLOC_INIT_ZVAL(z_subelem);
-#endif
                 redis_read_variant_line(redis_sock, reply_type, status_strings,
-                    z_subelem TSRMLS_CC);
-                add_next_index_zval(z_ret, z_subelem);
+                                        &z_subelem TSRMLS_CC);
+                add_next_index_zval(z_ret, &z_subelem);
                 break;
             case TYPE_INT:
                 // Add our long value
@@ -2511,23 +2389,15 @@ redis_read_multibulk_recursive(RedisSock *redis_sock, int elements, int status_s
                 break;
             case TYPE_BULK:
                 // Init a zval for our bulk response, read and add it
-#if (PHP_MAJOR_VERSION < 7)
-                ALLOC_INIT_ZVAL(z_subelem);
-#endif
-                redis_read_variant_bulk(redis_sock, reply_info, z_subelem
-                    TSRMLS_CC);
-                add_next_index_zval(z_ret, z_subelem);
+                redis_read_variant_bulk(redis_sock, reply_info, &z_subelem TSRMLS_CC);
+                add_next_index_zval(z_ret, &z_subelem);
                 break;
             case TYPE_MULTIBULK:
-                // Construct an array for our sub element, and add it,
-                // and recurse
-#if (PHP_MAJOR_VERSION < 7)
-                ALLOC_INIT_ZVAL(z_subelem);
-#endif
-                array_init(z_subelem);
-                add_next_index_zval(z_ret, z_subelem);
-                redis_read_multibulk_recursive(redis_sock, reply_info,
-                    status_strings, z_subelem TSRMLS_CC);
+                // Construct an array for our sub element, and add it, and recurse
+                array_init(&z_subelem);
+                add_next_index_zval(z_ret, &z_subelem);
+                redis_read_multibulk_recursive(redis_sock, reply_info, status_strings, 
+                                               &z_subelem TSRMLS_CC);
                 break;
             default:
                 // Stop the compiler from whinging
@@ -2548,7 +2418,7 @@ variant_reply_generic(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     // Reply type, and reply size vars
     REDIS_REPLY_TYPE reply_type;
     long reply_info;
-    //char *bulk_resp;
+    zval z_ret;
 
     // Attempt to read our header
     if(redis_read_reply_type(redis_sock,&reply_type,&reply_info TSRMLS_CC) < 0)
@@ -2556,37 +2426,29 @@ variant_reply_generic(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         return -1;
     }
 
-    zval zv, *z_ret = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#endif
     /* Switch based on our top level reply type */
     switch(reply_type) {
         case TYPE_ERR:
         case TYPE_LINE:
-            redis_read_variant_line(redis_sock, reply_type, status_strings, z_ret TSRMLS_CC);
+            redis_read_variant_line(redis_sock, reply_type, status_strings, &z_ret TSRMLS_CC);
             break;
         case TYPE_INT:
-            ZVAL_LONG(z_ret, reply_info);
+            ZVAL_LONG(&z_ret, reply_info);
             break;
         case TYPE_BULK:
-            redis_read_variant_bulk(redis_sock, reply_info, z_ret TSRMLS_CC);
+            redis_read_variant_bulk(redis_sock, reply_info, &z_ret TSRMLS_CC);
             break;
         case TYPE_MULTIBULK:
             /* Initialize an array for our multi-bulk response */
-            array_init(z_ret);
+            array_init(&z_ret);
 
             // If we've got more than zero elements, parse our multi bulk
             // response recursively
             if (reply_info > -1) {
-                redis_read_multibulk_recursive(redis_sock, reply_info, status_strings, z_ret TSRMLS_CC);
+                redis_read_multibulk_recursive(redis_sock, reply_info, status_strings, &z_ret TSRMLS_CC);
             }
             break;
         default:
-#if (PHP_MAJOR_VERSION < 7)
-            efree(z_ret);
-#endif
-            // Protocol error
             zend_throw_exception_ex(redis_exception_ce, 0 TSRMLS_CC,
                 "protocol error, got '%c' as reply-type byte\n", reply_type);
             return FAILURE;
@@ -2594,9 +2456,9 @@ variant_reply_generic(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     if (IS_ATOMIC(redis_sock)) {
         /* Set our return value */
-        RETVAL_ZVAL(z_ret, 0, 1);
+        RETVAL_ZVAL(&z_ret, 0, 1);
     } else {
-        add_next_index_zval(z_tab, z_ret);
+        add_next_index_zval(z_tab, &z_ret);
     }
 
     /* Success */
diff --git a/library.h b/library.h
index 8e82081e..a7a2f060 100644
--- a/library.h
+++ b/library.h
@@ -21,7 +21,7 @@ int redis_cmd_append_sstr_long(smart_string *str, long append);
 int redis_cmd_append_sstr_i64(smart_string *str, int64_t append);
 int redis_cmd_append_sstr_dbl(smart_string *str, double value);
 int redis_cmd_append_sstr_zval(smart_string *str, zval *z, RedisSock *redis_sock TSRMLS_DC);
-int redis_cmd_append_sstr_key(smart_string *str, char *key, strlen_t len, RedisSock *redis_sock, short *slot);
+int redis_cmd_append_sstr_key(smart_string *str, char *key, size_t len, RedisSock *redis_sock, short *slot);
 int redis_cmd_append_sstr_arrkey(smart_string *cmd, zend_string *kstr, ulong idx);
 
 PHP_REDIS_API int redis_spprintf(RedisSock *redis_sock, short *slot TSRMLS_DC, char **ret, char *kw, char *fmt, ...);
@@ -85,14 +85,14 @@ PHP_REDIS_API void redis_free_socket(RedisSock *redis_sock);
 PHP_REDIS_API void redis_sock_set_err(RedisSock *redis_sock, const char *msg, int msg_len);
 
 PHP_REDIS_API int
-redis_serialize(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len TSRMLS_DC);
+redis_serialize(RedisSock *redis_sock, zval *z, char **val, size_t *val_len TSRMLS_DC);
 PHP_REDIS_API int
-redis_key_prefix(RedisSock *redis_sock, char **key, strlen_t *key_len);
+redis_key_prefix(RedisSock *redis_sock, char **key, size_t *key_len);
 
 PHP_REDIS_API int
 redis_unserialize(RedisSock *redis_sock, const char *val, int val_len, zval *z_ret TSRMLS_DC);
 
-PHP_REDIS_API int redis_pack(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len TSRMLS_DC);
+PHP_REDIS_API int redis_pack(RedisSock *redis_sock, zval *z, char **val, size_t *val_len TSRMLS_DC);
 PHP_REDIS_API int redis_unpack(RedisSock *redis_sock, const char *val, int val_len, zval *z_ret TSRMLS_DC);
 
 PHP_REDIS_API int
diff --git a/package.xml b/package.xml
index d2a790de..c331de77 100644
--- a/package.xml
+++ b/package.xml
@@ -127,7 +127,7 @@ http://pear.php.net/dtd/package-2.0.xsd">
  <dependencies>
   <required>
    <php>
-    <min>5.3.0</min>
+    <min>7.0.0</min>
     <max>7.9.99</max>
    </php>
    <pearinstaller>
diff --git a/redis.c b/redis.c
index 5e076a90..ec743733 100644
--- a/redis.c
+++ b/redis.c
@@ -486,11 +486,9 @@ static const zend_module_dep redis_deps[] = {
 };
 
 zend_module_entry redis_module_entry = {
-#if ZEND_MODULE_API_NO >= 20010901
      STANDARD_MODULE_HEADER_EX,
      NULL,
      redis_deps,
-#endif
      "redis",
      NULL,
      PHP_MINIT(redis),
@@ -498,9 +496,7 @@ zend_module_entry redis_module_entry = {
      NULL,
      NULL,
      PHP_MINFO(redis),
-#if ZEND_MODULE_API_NO >= 20010901
      PHP_REDIS_VERSION,
-#endif
      STANDARD_MODULE_PROPERTIES
 };
 
@@ -508,6 +504,8 @@ zend_module_entry redis_module_entry = {
 ZEND_GET_MODULE(redis)
 #endif
 
+zend_object_handlers redis_object_handlers;
+
 /* Send a static DISCARD in case we're in MULTI mode. */
 static int
 redis_send_discard(RedisSock *redis_sock TSRMLS_DC)
@@ -551,48 +549,6 @@ free_reply_callbacks(RedisSock *redis_sock)
     redis_sock->current = NULL;
 }
 
-#if (PHP_MAJOR_VERSION < 7)
-void
-free_redis_object(void *object TSRMLS_DC)
-{
-    redis_object *redis = (redis_object *)object;
-
-    zend_object_std_dtor(&redis->std TSRMLS_CC);
-    if (redis->sock) {
-        redis_sock_disconnect(redis->sock, 0 TSRMLS_CC);
-        redis_free_socket(redis->sock);
-    }
-    efree(redis);
-}
-
-zend_object_value
-create_redis_object(zend_class_entry *ce TSRMLS_DC)
-{
-    zend_object_value retval;
-    redis_object *redis = ecalloc(1, sizeof(redis_object));
-
-    memset(redis, 0, sizeof(redis_object));
-    zend_object_std_init(&redis->std, ce TSRMLS_CC);
-
-#if PHP_VERSION_ID < 50399
-    zval *tmp;
-    zend_hash_copy(redis->std.properties, &ce->default_properties,
-        (copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *));
-#else
-    object_properties_init(&redis->std, ce);
-#endif
-
-    retval.handle = zend_objects_store_put(redis,
-        (zend_objects_store_dtor_t)zend_objects_destroy_object,
-        (zend_objects_free_object_storage_t)free_redis_object,
-        NULL TSRMLS_CC);
-    retval.handlers = zend_get_std_object_handlers();
-
-    return retval;
-}
-#else
-zend_object_handlers redis_object_handlers;
-
 void
 free_redis_object(zend_object *object)
 {
@@ -622,7 +578,6 @@ create_redis_object(zend_class_entry *ce TSRMLS_DC)
 
     return &redis->std;
 }
-#endif
 
 static zend_always_inline RedisSock *
 redis_sock_get_instance(zval *id TSRMLS_DC, int no_throw)
@@ -782,35 +737,20 @@ PHP_MINIT_FUNCTION(redis)
     exception_ce = zend_hash_str_find_ptr(CG(class_table), "RuntimeException", sizeof("RuntimeException") - 1);
 #endif
     if (exception_ce == NULL) {
-#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION < 2)
-        exception_ce = zend_exception_get_default();
-#else
         exception_ce = zend_exception_get_default(TSRMLS_C);
-#endif
     }
 
     /* RedisException class */
     INIT_CLASS_ENTRY(redis_exception_class_entry, "RedisException", NULL);
     redis_exception_ce = zend_register_internal_class_ex(
         &redis_exception_class_entry,
-#if (PHP_MAJOR_VERSION < 7)
-        exception_ce, NULL TSRMLS_CC
-#else
-        exception_ce
-#endif
-    );
+        exception_ce);
 
     /* RedisClusterException class */
     INIT_CLASS_ENTRY(redis_cluster_exception_class_entry,
         "RedisClusterException", NULL);
     redis_cluster_exception_ce = zend_register_internal_class_ex(
-        &redis_cluster_exception_class_entry,
-#if (PHP_MAJOR_VERSION < 7)
-        exception_ce, NULL TSRMLS_CC
-#else
-        exception_ce
-#endif
-    );
+        &redis_cluster_exception_class_entry, exception_ce);
 
     /* Add shared class constants to Redis and RedisCluster objects */
     add_class_constants(redis_ce, 0 TSRMLS_CC);
@@ -921,7 +861,7 @@ redis_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
     zval *object;
     char *host = NULL, *persistent_id = "";
     zend_long port = -1, retry_interval = 0;
-    strlen_t host_len, persistent_id_len;
+    size_t host_len, persistent_id_len;
     double timeout = 0.0, read_timeout = 0.0;
     redis_object *redis;
 
@@ -1588,7 +1528,7 @@ generic_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, int desc, int alpha)
     RedisSock *redis_sock;
     zend_string *zpattern;
     char *key = NULL, *pattern = NULL, *store = NULL;
-    strlen_t keylen, patternlen, storelen;
+    size_t keylen, patternlen, storelen;
     zend_long offset = -1, count = -1;
     int argc = 1; /* SORT key is the simplest SORT command */
     smart_string cmd = {0};
@@ -1814,7 +1754,7 @@ PHP_METHOD(Redis, info) {
     zval *object;
     RedisSock *redis_sock;
     char *cmd, *opt = NULL;
-    strlen_t opt_len;
+    size_t opt_len;
     int cmd_len;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
@@ -1898,7 +1838,7 @@ void generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun)
     zval *zmem;
     char buf[64];
     size_t keylen;
-    ulong idx;
+    zend_ulong idx;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oa",
                                      &object, redis_ce, &z_array) == FAILURE)
@@ -1923,7 +1863,7 @@ void generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun)
             redis_cmd_append_sstr_key(&cmd, ZSTR_VAL(zkey), ZSTR_LEN(zkey), redis_sock, NULL);
         } else {
             keylen = snprintf(buf, sizeof(buf), "%ld", (long)idx);
-            redis_cmd_append_sstr_key(&cmd, buf, (strlen_t)keylen, redis_sock, NULL);
+            redis_cmd_append_sstr_key(&cmd, buf, keylen, redis_sock, NULL);
         }
 
         /* Append our value */
@@ -2434,6 +2374,8 @@ redis_response_enqueued(RedisSock *redis_sock TSRMLS_DC)
     return ret;
 }
 
+/* TODO:  Investigate/fix the odd logic going on in here.  Looks like previous abort
+ *        condidtions that are now simply empty if { } { } blocks. */
 PHP_REDIS_API int
 redis_sock_read_multibulk_multi_reply_loop(INTERNAL_FUNCTION_PARAMETERS,
                                            RedisSock *redis_sock, zval *z_tab,
@@ -2450,28 +2392,29 @@ redis_sock_read_multibulk_multi_reply_loop(INTERNAL_FUNCTION_PARAMETERS,
         }
         size_t len;
         char inbuf[255];
+
         if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len TSRMLS_CC) < 0) {
         } else if (strncmp(inbuf, "+OK", 3) != 0) {
         }
+
         while ((fi = fi->next) && fi->fun) {
             if (redis_response_enqueued(redis_sock TSRMLS_CC) == SUCCESS) {
             } else {
             }
         }
+
         if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len TSRMLS_CC) < 0) {
         }
-#if (PHP_MAJOR_VERSION < 7)
-        zval *z_ret;
-        MAKE_STD_ZVAL(z_ret);
-#else
-        zval zv, *z_ret = &zv;
-#endif
-        array_init(z_ret);
-        add_next_index_zval(z_tab, z_ret);
+
+        zval z_ret;
+        array_init(&z_ret);
+        add_next_index_zval(z_tab, &z_ret);
 
         int num = atol(inbuf + 1);
-        if (num > 0 && redis_read_multibulk_recursive(redis_sock, num, 0, z_ret TSRMLS_CC) < 0) {
+
+        if (num > 0 && redis_read_multibulk_recursive(redis_sock, num, 0, &z_ret TSRMLS_CC) < 0) {
         }
+
         if (fi) fi = fi->next;
     }
     redis_sock->current = fi;
@@ -2634,7 +2577,7 @@ PHP_METHOD(Redis, slaveof)
     zval *object;
     RedisSock *redis_sock;
     char *cmd = "", *host = NULL;
-    strlen_t host_len;
+    size_t host_len;
     zend_long port = 6379;
     int cmd_len;
 
@@ -2730,7 +2673,7 @@ PHP_METHOD(Redis, config)
     zval *object;
     RedisSock *redis_sock;
     char *key = NULL, *val = NULL, *cmd, *op = NULL;
-    strlen_t key_len, val_len, op_len;
+    size_t key_len, val_len, op_len;
     enum {CFG_GET, CFG_SET} mode;
     int cmd_len;
 
@@ -2785,7 +2728,7 @@ PHP_METHOD(Redis, slowlog) {
     RedisSock *redis_sock;
     char *arg, *cmd;
     int cmd_len;
-    strlen_t arg_len;
+    size_t arg_len;
     zend_long option = 0;
     enum {SLOWLOG_GET, SLOWLOG_LEN, SLOWLOG_RESET} mode;
 
@@ -2925,7 +2868,7 @@ PHP_METHOD(Redis, pubsub) {
     RedisSock *redis_sock;
     char *keyword, *cmd;
     int cmd_len;
-    strlen_t kw_len;
+    size_t kw_len;
     PUBSUB_TYPE type;
     zval *arg = NULL;
 
@@ -3295,7 +3238,7 @@ PHP_METHOD(Redis, client) {
     zval *object;
     RedisSock *redis_sock;
     char *cmd, *opt = NULL, *arg = NULL;
-    strlen_t opt_len, arg_len;
+    size_t opt_len, arg_len;
     int cmd_len;
 
     // Parse our method parameters
@@ -3444,7 +3387,7 @@ generic_scan_cmd(INTERNAL_FUNCTION_PARAMETERS, REDIS_SCAN_TYPE type) {
     HashTable *hash;
     char *pattern = NULL, *cmd, *key = NULL;
     int cmd_len, num_elements, key_free = 0;
-    strlen_t key_len = 0, pattern_len = 0;
+    size_t key_len = 0, pattern_len = 0;
     zend_long count = 0, iter;
 
     /* Different prototype depending on if this is a key based scan */
diff --git a/redis_array.c b/redis_array.c
index 79cf0804..1d989cb9 100644
--- a/redis_array.c
+++ b/redis_array.c
@@ -170,51 +170,6 @@ redis_array_free(RedisArray *ra)
     efree(ra);
 }
 
-#if (PHP_MAJOR_VERSION < 7)
-typedef struct {
-    zend_object std;
-    RedisArray *ra;
-} redis_array_object;
-
-void
-free_redis_array_object(void *object TSRMLS_DC)
-{
-    redis_array_object *obj = (redis_array_object *)object;
-
-    zend_object_std_dtor(&obj->std TSRMLS_CC);
-    if (obj->ra) {
-        if (obj->ra->prev) redis_array_free(obj->ra->prev);
-        redis_array_free(obj->ra);
-    }
-    efree(obj);
-}
-
-zend_object_value
-create_redis_array_object(zend_class_entry *ce TSRMLS_DC)
-{
-    zend_object_value retval;
-    redis_array_object *obj = ecalloc(1, sizeof(redis_array_object));
-    memset(obj, 0, sizeof(redis_array_object));
-
-    zend_object_std_init(&obj->std, ce TSRMLS_CC);
-
-#if PHP_VERSION_ID < 50399
-    zval *tmp;
-    zend_hash_copy(obj->std.properties, &ce->default_properties,
-        (copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *));
-#else
-    object_properties_init(&obj->std, ce);
-#endif
-
-    retval.handle = zend_objects_store_put(obj,
-        (zend_objects_store_dtor_t)zend_objects_destroy_object,
-        (zend_objects_free_object_storage_t)free_redis_array_object,
-        NULL TSRMLS_CC);
-    retval.handlers = zend_get_std_object_handlers();
-
-    return retval;
-}
-#else
 typedef struct {
     RedisArray *ra;
     zend_object std;
@@ -251,7 +206,6 @@ create_redis_array_object(zend_class_entry *ce TSRMLS_DC)
 
     return &obj->std;
 }
-#endif
 
 /**
  * redis_array_get
@@ -505,7 +459,7 @@ PHP_METHOD(RedisArray, __call)
     zval *z_args;
 
     char *cmd;
-    strlen_t cmd_len;
+    size_t cmd_len;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osa",
                 &object, redis_array_ce, &cmd, &cmd_len, &z_args) == FAILURE) {
@@ -545,7 +499,7 @@ PHP_METHOD(RedisArray, _target)
     zval *object;
     RedisArray *ra;
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zval *redis_inst;
     int i;
 
@@ -571,7 +525,7 @@ PHP_METHOD(RedisArray, _instance)
     zval *object;
     RedisArray *ra;
     char *target;
-    strlen_t target_len;
+    size_t target_len;
     zval *z_redis;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os",
@@ -653,7 +607,7 @@ PHP_METHOD(RedisArray, _rehash)
 PHP_METHOD(RedisArray, _continuum)
 {
     int i;
-    zval *object;
+    zval *object, z_ret;
     RedisArray *ra;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
@@ -668,15 +622,10 @@ PHP_METHOD(RedisArray, _continuum)
     array_init(return_value);
     if (ra->continuum) {
         for (i = 0; i < ra->continuum->nb_points; ++i) {
-            zval zv, *z_tmp = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#endif
-
-            array_init(z_tmp);
-            add_assoc_long(z_tmp, "index", ra->continuum->points[i].index);
-            add_assoc_long(z_tmp, "value", ra->continuum->points[i].value);
-            add_next_index_zval(return_value, z_tmp);
+            array_init(&z_ret);
+            add_assoc_long(&z_ret, "index", ra->continuum->points[i].index);
+            add_assoc_long(&z_ret, "value", ra->continuum->points[i].value);
+            add_next_index_zval(return_value, &z_ret);
         }
     }
 }
@@ -685,6 +634,7 @@ PHP_METHOD(RedisArray, _continuum)
 static void
 multihost_distribute_call(RedisArray *ra, zval *return_value, zval *z_fun, int argc, zval *argv TSRMLS_DC)
 {
+    zval z_arg;
     int i;
 
     /* Init our array return */
@@ -692,15 +642,11 @@ multihost_distribute_call(RedisArray *ra, zval *return_value, zval *z_fun, int a
 
     /* Iterate our RedisArray nodes */
     for (i = 0; i < ra->count; ++i) {
-        zval zv, *z_tmp = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-        MAKE_STD_ZVAL(z_tmp);
-#endif
         /* Call each node in turn */
-        call_user_function(&redis_array_ce->function_table, &ra->redis[i], z_fun, z_tmp, argc, argv);
+        call_user_function(&redis_array_ce->function_table, &ra->redis[i], z_fun, &z_arg, argc, argv);
 
         /* Add the result for this host */
-        add_assoc_zval_ex(return_value, ZSTR_VAL(ra->hosts[i]), ZSTR_LEN(ra->hosts[i]), z_tmp);
+        add_assoc_zval_ex(return_value, ZSTR_VAL(ra->hosts[i]), ZSTR_LEN(ra->hosts[i]), &z_arg);
     }
 }
 
@@ -788,7 +734,7 @@ PHP_METHOD(RedisArray, keys)
     zval *object, z_fun, z_args[1];
     RedisArray *ra;
     char *pattern;
-    strlen_t pattern_len;
+    size_t pattern_len;
 
     /* Make sure the prototype is correct */
     if(zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os",
@@ -846,7 +792,7 @@ PHP_METHOD(RedisArray, setOption)
     RedisArray *ra;
     zend_long opt;
     char *val_str;
-    strlen_t val_len;
+    size_t val_len;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ols",
                 &object, redis_array_ce, &opt, &val_str, &val_len) == FAILURE) {
@@ -896,34 +842,6 @@ PHP_METHOD(RedisArray, select)
     zval_dtor(&z_fun);
 }
 
-#if (PHP_MAJOR_VERSION < 7)
-#define HANDLE_MULTI_EXEC(ra, cmd, cmdlen) do { \
-    if (ra && ra->z_multi_exec) { \
-        int i, num_varargs;\
-        zval ***varargs = NULL, *z_arg_array; \
-        if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O*",\
-                                &object, redis_array_ce, &varargs, &num_varargs) == FAILURE) {\
-                RETURN_FALSE;\
-        }\
-        /* copy all args into a zval hash table */\
-        MAKE_STD_ZVAL(z_arg_array); \
-        array_init(z_arg_array);\
-        for(i = 0; i < num_varargs; ++i) {\
-            zval *z_tmp;\
-            MAKE_STD_ZVAL(z_tmp); \
-            ZVAL_ZVAL(z_tmp, *varargs[i], 1, 0); \
-            add_next_index_zval(z_arg_array, z_tmp); \
-        }\
-        /* call */\
-        ra_forward_call(INTERNAL_FUNCTION_PARAM_PASSTHRU, ra, cmd, cmdlen, z_arg_array, NULL); \
-        zval_ptr_dtor(&z_arg_array); \
-        if(varargs) {\
-            efree(varargs);\
-        }\
-        return;\
-    }\
-}while(0)
-#else
 #define HANDLE_MULTI_EXEC(ra, cmd, cmdlen) do { \
     if (ra && ra->z_multi_exec) { \
         int i, num_varargs; \
@@ -945,12 +863,11 @@ PHP_METHOD(RedisArray, select)
         return; \
     } \
 } while(0)
-#endif
 
 /* MGET will distribute the call to several nodes and regroup the values. */
 PHP_METHOD(RedisArray, mget)
 {
-    zval *object, *z_keys, z_argarray, *data, z_ret, *z_cur, z_tmp_array, *z_tmp;
+    zval *object, *z_keys, z_argarray, *data, z_ret, *z_cur, z_tmp_array;
     int i, j, n;
     RedisArray *ra;
     int *pos, argc, *argc_each;
@@ -1027,14 +944,9 @@ PHP_METHOD(RedisArray, mget)
         for(i = 0; i < argc; ++i) {
             if(pos[i] != n) continue;
 
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#else
-            zval zv;
-            z_tmp = &zv;
-#endif
-            ZVAL_ZVAL(z_tmp, argv[i], 1, 0);
-            add_next_index_zval(&z_argarray, z_tmp);
+            zval z_ret;
+            ZVAL_ZVAL(&z_ret, argv[i], 1, 0);
+            add_next_index_zval(&z_argarray, &z_ret);
         }
 
         zval z_fun;
@@ -1063,14 +975,9 @@ PHP_METHOD(RedisArray, mget)
         for(i = 0, j = 0; i < argc; ++i) {
             if (pos[i] != n || (z_cur = zend_hash_index_find(Z_ARRVAL(z_ret), j++)) == NULL) continue;
 
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#else
-            zval zv;
-            z_tmp = &zv;
-#endif
-            ZVAL_ZVAL(z_tmp, z_cur, 1, 0);
-            add_index_zval(&z_tmp_array, i, z_tmp);
+            zval z_ret;
+            ZVAL_ZVAL(&z_ret, z_cur, 1, 0);
+            add_index_zval(&z_tmp_array, i, &z_ret);
         }
         zval_dtor(&z_ret);
     }
@@ -1080,14 +987,9 @@ PHP_METHOD(RedisArray, mget)
     for(i = 0; i < argc; ++i) {
         if ((z_cur = zend_hash_index_find(Z_ARRVAL(z_tmp_array), i)) == NULL) continue;
 
-#if (PHP_MAJOR_VERSION < 7)
-        MAKE_STD_ZVAL(z_tmp);
-#else
-        zval zv;
-        z_tmp = &zv;
-#endif
-        ZVAL_ZVAL(z_tmp, z_cur, 1, 0);
-        add_next_index_zval(return_value, z_tmp);
+        zval z_ret;
+        ZVAL_ZVAL(&z_ret, z_cur, 1, 0);
+        add_next_index_zval(return_value, &z_ret);
     }
 
     /* cleanup */
@@ -1170,16 +1072,13 @@ PHP_METHOD(RedisArray, mset)
         for(i = 0; i < argc; ++i) {
             if(pos[i] != n) continue;
 
-            zval zv, *z_tmp = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#endif
+            zval z_ret;
             if (argv[i] == NULL) {
-                ZVAL_NULL(z_tmp);
+                ZVAL_NULL(&z_ret);
             } else {
-                ZVAL_ZVAL(z_tmp, argv[i], 1, 0);
+                ZVAL_ZVAL(&z_ret, argv[i], 1, 0);
             }
-            add_assoc_zval_ex(&z_argarray, ZSTR_VAL(keys[i]), ZSTR_LEN(keys[i]), z_tmp);
+            add_assoc_zval_ex(&z_argarray, ZSTR_VAL(keys[i]), ZSTR_LEN(keys[i]), &z_ret);
             found++;
         }
 
@@ -1257,15 +1156,10 @@ static void ra_generic_del(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len) {
         array_init(&z_keys);
         for (i = 0; i < argc; ++i) {
             zval *z_arg = &z_args[i];
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#else
-            zval zv;
-            z_tmp = &zv;
-#endif
-            ZVAL_ZVAL(z_tmp, z_arg, 1, 0);
+            zval z_ret;
+            ZVAL_ZVAL(&z_ret, z_arg, 1, 0);
             /* add copy to z_keys */
-            add_next_index_zval(&z_keys, z_tmp);
+            add_next_index_zval(&z_keys, &z_ret);
         }
         free_zkeys = 1;
     }
@@ -1319,14 +1213,9 @@ static void ra_generic_del(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len) {
         for(i = 0; i < argc; ++i) {
             if(pos[i] != n) continue;
 
-#if (PHP_MAJOR_VERSION < 7)
-            MAKE_STD_ZVAL(z_tmp);
-#else
-            zval zv;
-            z_tmp = &zv;
-#endif
-            ZVAL_ZVAL(z_tmp, argv[i], 1, 0);
-            add_next_index_zval(&z_argarray, z_tmp);
+            zval z_ret;
+            ZVAL_ZVAL(&z_ret, argv[i], 1, 0);
+            add_next_index_zval(&z_argarray, &z_ret);
             found++;
         }
 
@@ -1383,7 +1272,7 @@ PHP_METHOD(RedisArray, multi)
     RedisArray *ra;
     zval *z_redis;
     char *host;
-    strlen_t host_len;
+    size_t host_len;
     zend_long multi_value = MULTI;
 
     if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l",
diff --git a/redis_array.h b/redis_array.h
index de444654..1ee192fa 100644
--- a/redis_array.h
+++ b/redis_array.h
@@ -49,7 +49,6 @@ typedef struct {
 } Continuum;
 
 typedef struct RedisArray_ {
-
     int count;
     zend_string **hosts;    /* array of host:port strings */
     zval *redis;            /* array of Redis instances */
@@ -67,13 +66,7 @@ typedef struct RedisArray_ {
     struct RedisArray_ *prev;
 } RedisArray;
 
-#if (PHP_MAJOR_VERSION < 7)
-zend_object_value create_redis_array_object(zend_class_entry *ce TSRMLS_DC);
-void free_redis_array_object(void *object TSRMLS_DC);
-#else
 zend_object *create_redis_array_object(zend_class_entry *ce TSRMLS_DC);
 void free_redis_array_object(zend_object *object);
-#endif
-
 
 #endif
diff --git a/redis_array_impl.c b/redis_array_impl.c
index 4ee72d8a..aeb08e20 100644
--- a/redis_array_impl.c
+++ b/redis_array_impl.c
@@ -65,9 +65,6 @@ ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b
         }
 
         /* create Redis object */
-#if (PHP_MAJOR_VERSION < 7)
-        INIT_PZVAL(&ra->redis[i]);
-#endif
         object_init_ex(&ra->redis[i], redis_ce);
         call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL);
         zval_dtor(&z_ret);
@@ -465,11 +462,7 @@ ra_call_extractor(RedisArray *ra, const char *key, int key_len TSRMLS_DC)
     zval z_ret, z_argv;
 
     /* check that we can call the extractor function */
-#if (PHP_MAJOR_VERSION < 7)
-    if (!zend_is_callable_ex(&ra->z_fun, NULL, 0, NULL, NULL, NULL, NULL TSRMLS_CC)) {
-#else
     if (!zend_is_callable_ex(&ra->z_fun, NULL, 0, NULL, NULL, NULL)) {
-#endif
         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call extractor function");
         return NULL;
     }
@@ -480,11 +473,7 @@ ra_call_extractor(RedisArray *ra, const char *key, int key_len TSRMLS_DC)
     call_user_function(EG(function_table), NULL, &ra->z_fun, &z_ret, 1, &z_argv);
 
     if (Z_TYPE(z_ret) == IS_STRING) {
-#if (PHP_MAJOR_VERSION < 7)
-        out = zend_string_init(Z_STRVAL(z_ret), Z_STRLEN(z_ret), 0);
-#else
         out = zval_get_string(&z_ret);
-#endif
     }
 
     zval_dtor(&z_argv);
@@ -514,11 +503,7 @@ ra_call_distributor(RedisArray *ra, const char *key, int key_len TSRMLS_DC)
     zval z_ret, z_argv;
 
     /* check that we can call the extractor function */
-#if (PHP_MAJOR_VERSION < 7)
-    if (!zend_is_callable_ex(&ra->z_dist, NULL, 0, NULL, NULL, NULL, NULL TSRMLS_CC)) {
-#else
     if (!zend_is_callable_ex(&ra->z_dist, NULL, 0, NULL, NULL, NULL)) {
-#endif
         php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call distributor function");
         return -1;
     }
@@ -672,28 +657,23 @@ ra_index_keys(zval *z_pairs, zval *z_redis TSRMLS_DC) {
 
     zval z_keys, *z_val;
     zend_string *zkey;
-    ulong idx;
+    zend_ulong idx;
+
     /* Initialize key array */
-#if PHP_VERSION_ID > 50300
     array_init_size(&z_keys, zend_hash_num_elements(Z_ARRVAL_P(z_pairs)));
-#else
-    array_init(&z_keys);
-#endif
 
     /* Go through input array and add values to the key array */
     ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(z_pairs), idx, zkey, z_val) {
-        zval zv, *z_new = &zv;
-#if (PHP_MAJOR_VERSION < 7)
-        MAKE_STD_ZVAL(z_new);
-#endif
+        zval z_new;
+
         PHPREDIS_NOTUSED(z_val);
 
         if (zkey) {
-            ZVAL_STRINGL(z_new, ZSTR_VAL(zkey), ZSTR_LEN(zkey));
+            ZVAL_STRINGL(&z_new, ZSTR_VAL(zkey), ZSTR_LEN(zkey));
         } else {
-            ZVAL_LONG(z_new, idx);
+            ZVAL_LONG(&z_new, idx);
         }
-        zend_hash_next_index_insert(Z_ARRVAL(z_keys), z_new);
+        zend_hash_next_index_insert(Z_ARRVAL(z_keys), &z_new);
     } ZEND_HASH_FOREACH_END();
 
     /* add keys to index */
@@ -1192,20 +1172,7 @@ zval_rehash_callback(zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache,
     zval zv, *z_ret = &zv;
 
     ZVAL_NULL(z_ret);
-#if (PHP_MAJOR_VERSION < 7)
-    zval *z_host, *z_count, **z_args_pp[2];
-
-    MAKE_STD_ZVAL(z_host);
-    ZVAL_STRINGL(z_host, ZSTR_VAL(hostname), ZSTR_LEN(hostname));
-    z_args_pp[0] = &z_host;
-
-    MAKE_STD_ZVAL(z_count);
-    ZVAL_LONG(z_count, count);
-    z_args_pp[1] = &z_count;
 
-    z_cb->params = z_args_pp;
-    z_cb->retval_ptr_ptr = &z_ret;
-#else
     zval z_args[2];
 
     ZVAL_STRINGL(&z_args[0], ZSTR_VAL(hostname), ZSTR_LEN(hostname));
@@ -1213,7 +1180,7 @@ zval_rehash_callback(zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache,
 
     z_cb->params = z_args;
     z_cb->retval = z_ret;
-#endif
+    
     z_cb->no_separation = 0;
     z_cb->param_count = 2;
 
@@ -1221,12 +1188,7 @@ zval_rehash_callback(zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache,
     zend_call_function(z_cb, z_cb_cache TSRMLS_CC);
 
     /* cleanup */
-#if (PHP_MAJOR_VERSION < 7)
-    zval_ptr_dtor(&z_host);
-    zval_ptr_dtor(&z_count);
-#else
     zval_dtor(&z_args[0]);
-#endif
     zval_dtor(z_ret);
 }
 
diff --git a/redis_cluster.c b/redis_cluster.c
index 9bc42547..fd42db36 100644
--- a/redis_cluster.c
+++ b/redis_cluster.c
@@ -291,43 +291,23 @@ zend_function_entry redis_cluster_functions[] = {
 };
 
 /* Our context seeds will be a hash table with RedisSock* pointers */
-#if (PHP_MAJOR_VERSION < 7)
-static void ht_free_seed(void *data)
-#else
-static void ht_free_seed(zval *data)
-#endif
-{
+static void ht_free_seed(zval *data) {
     RedisSock *redis_sock = *(RedisSock**)data;
     if (redis_sock) redis_free_socket(redis_sock);
 }
 
 /* Free redisClusterNode objects we've stored */
-#if (PHP_MAJOR_VERSION < 7)
-static void ht_free_node(void *data)
-#else
-static void ht_free_node(zval *data)
-#endif
-{
+static void ht_free_node(zval *data) {
     redisClusterNode *node = *(redisClusterNode**)data;
     cluster_free_node(node);
 }
 
 /* Create redisCluster context */
-#if (PHP_MAJOR_VERSION < 7)
-zend_object_value
-create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
-    redisCluster *cluster;
-
-    // Allocate our actual struct
-    cluster = ecalloc(1, sizeof(redisCluster));
-#else
-zend_object *
-create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
+zend_object * create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
     redisCluster *cluster;
 
     // Allocate our actual struct
     cluster = ecalloc(1, sizeof(redisCluster) + sizeof(zval) * (class_type->default_properties_count - 1));
-#endif
 
     // We're not currently subscribed anywhere
     cluster->subscribed_slot = -1;
@@ -345,25 +325,7 @@ create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
 
     // Initialize it
     zend_object_std_init(&cluster->std, class_type TSRMLS_CC);
-#if (PHP_MAJOR_VERSION < 7)
-    zend_object_value retval;
-#if PHP_VERSION_ID < 50399
-    zval *tmp;
 
-    zend_hash_copy(cluster->std.properties, &class_type->default_properties,
-        (copy_ctor_func_t)zval_add_ref, (void*)&tmp, sizeof(zval*));
-#else
-    object_properties_init(&cluster->std, class_type);
-#endif
-
-    retval.handle = zend_objects_store_put(cluster,
-        (zend_objects_store_dtor_t)zend_objects_destroy_object,
-        free_cluster_context, NULL TSRMLS_CC);
-
-    retval.handlers = zend_get_std_object_handlers();
-
-    return retval;
-#else
     object_properties_init(&cluster->std, class_type);
     memcpy(&RedisCluster_handlers, zend_get_std_object_handlers(), sizeof(RedisCluster_handlers));
     RedisCluster_handlers.offset = XtOffsetOf(redisCluster, std);
@@ -372,36 +334,20 @@ create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
     cluster->std.handlers = &RedisCluster_handlers;
 
     return &cluster->std;
-#endif
 }
 
 /* Free redisCluster context */
-#if (PHP_MAJOR_VERSION < 7)
-void
-free_cluster_context(void *object TSRMLS_DC)
-{
-    redisCluster *cluster = (redisCluster*)object;
-
-    cluster_free(cluster, 0 TSRMLS_CC);
-    zend_object_std_dtor(&cluster->std TSRMLS_CC);
-    efree(cluster);
-}
-#else
-void
-free_cluster_context(zend_object *object)
-{
+void free_cluster_context(zend_object *object) {
     redisCluster *cluster = (redisCluster*)((char*)(object) - XtOffsetOf(redisCluster, std));
 
     cluster_free(cluster, 0 TSRMLS_CC);
     zend_object_std_dtor(&cluster->std TSRMLS_CC);
 }
-#endif
 
 /* Attempt to connect to a Redis cluster provided seeds and timeout options */
-static void
-redis_cluster_init(redisCluster *c, HashTable *ht_seeds,
-                   double timeout, double read_timeout, int persistent,
-                   char *auth, strlen_t auth_len TSRMLS_DC)
+static void redis_cluster_init(redisCluster *c, HashTable *ht_seeds, double timeout, 
+                               double read_timeout, int persistent, char *auth, 
+                               size_t auth_len TSRMLS_DC)
 {
     // Validate timeout
     if (timeout < 0L || timeout > INT_MAX) {
@@ -448,7 +394,7 @@ redis_cluster_init(redisCluster *c, HashTable *ht_seeds,
 void redis_cluster_load(redisCluster *c, char *name, int name_len TSRMLS_DC) {
     zval z_seeds, z_timeout, z_read_timeout, z_persistent, z_auth, *z_value;
     char *iptr, *auth = NULL;
-    strlen_t auth_len = 0;
+    size_t auth_len = 0;
     double timeout = 0, read_timeout = 0;
     int persistent = 0;
     HashTable *ht_seeds = NULL;
@@ -540,7 +486,7 @@ void redis_cluster_load(redisCluster *c, char *name, int name_len TSRMLS_DC) {
 PHP_METHOD(RedisCluster, __construct) {
     zval *object, *z_seeds = NULL;
     char *name, *auth = NULL;
-    strlen_t name_len, auth_len = 0;
+    size_t name_len, auth_len = 0;
     double timeout = 0.0, read_timeout = 0.0;
     zend_bool persistent = 0;
     redisCluster *context = GET_CONTEXT();
@@ -637,12 +583,12 @@ typedef struct clusterKeyValHT {
     char kbuf[22];
 
     char  *key;
-    strlen_t key_len;
+    size_t key_len;
     int key_free;
     short slot;
 
     char *val;
-    strlen_t val_len;
+    size_t val_len;
     int val_free;
 } clusterKeyValHT;
 
@@ -655,18 +601,11 @@ static int get_key_val_ht(redisCluster *c, HashTable *ht, HashPosition *ptr,
 
     // Grab the key, convert it to a string using provided kbuf buffer if it's
     // a LONG style key
-#if (PHP_MAJOR_VERSION < 7)
-    uint key_len;
-    switch(zend_hash_get_current_key_ex(ht, &(kv->key), &key_len, &idx, 0, ptr)) {
-        case HASH_KEY_IS_STRING:
-            kv->key_len = (int)(key_len-1);
-#else
     zend_string *zkey;
     switch (zend_hash_get_current_key_ex(ht, &zkey, &idx, ptr)) {
         case HASH_KEY_IS_STRING:
             kv->key_len = ZSTR_LEN(zkey);
             kv->key = ZSTR_VAL(zkey);
-#endif
             break;
         case HASH_KEY_IS_LONG:
             kv->key_len = snprintf(kv->kbuf,sizeof(kv->kbuf),"%ld",(long)idx);
@@ -973,14 +912,8 @@ static int cluster_mset_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len,
 static void cluster_generic_delete(INTERNAL_FUNCTION_PARAMETERS,
                                    char *kw, int kw_len)
 {
-    zval *z_ret;
-
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#else
-    z_ret = emalloc(sizeof(zval));
-#endif
-
+    zval *z_ret = emalloc(sizeof(*z_ret));
+    
     // Initialize a LONG value to zero for our return
     ZVAL_LONG(z_ret, 0);
 
@@ -1005,14 +938,8 @@ PHP_METHOD(RedisCluster, unlink) {
 
 /* {{{ proto array RedisCluster::mget(array keys) */
 PHP_METHOD(RedisCluster, mget) {
-    zval *z_ret;
+    zval *z_ret = emalloc(sizeof(*z_ret));
 
-    // Array response
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#else
-    z_ret = emalloc(sizeof(zval));
-#endif
     array_init(z_ret);
 
     // Parse args, process
@@ -1027,14 +954,8 @@ PHP_METHOD(RedisCluster, mget) {
 
 /* {{{ proto bool RedisCluster::mset(array keyvalues) */
 PHP_METHOD(RedisCluster, mset) {
-    zval *z_ret;
+    zval *z_ret = emalloc(sizeof(*z_ret));
 
-    // Response, defaults to TRUE
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#else
-    z_ret = emalloc(sizeof(zval));
-#endif
     ZVAL_TRUE(z_ret);
 
     // Parse args and process.  If we get a failure, free zval and return FALSE.
@@ -1048,19 +969,13 @@ PHP_METHOD(RedisCluster, mset) {
 
 /* {{{ proto array RedisCluster::msetnx(array keyvalues) */
 PHP_METHOD(RedisCluster, msetnx) {
-    zval *z_ret;
+    zval *z_ret = emalloc(sizeof(*z_ret));
 
-    // Array response
-#if (PHP_MAJOR_VERSION < 7)
-    MAKE_STD_ZVAL(z_ret);
-#else
-    z_ret = emalloc(sizeof(zval));
-#endif
     array_init(z_ret);
 
     // Parse args and process.  If we get a failure, free mem and return FALSE
     if (cluster_mset_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "MSETNX",
-                        sizeof("MSETNX")-1, z_ret, cluster_msetnx_resp) ==-1)
+                         sizeof("MSETNX")-1, z_ret, cluster_msetnx_resp) ==-1)
     {
         zval_dtor(z_ret);
         efree(z_ret);
@@ -1103,7 +1018,7 @@ PHP_METHOD(RedisCluster, exists) {
 PHP_METHOD(RedisCluster, keys) {
     redisCluster *c = GET_CONTEXT();
     redisClusterNode *node;
-    strlen_t pat_len;
+    size_t pat_len;
     char *pat, *cmd;
     clusterReply *resp;
     int i, cmd_len;
@@ -2051,14 +1966,13 @@ PHP_METHOD(RedisCluster, _masters) {
     ZEND_HASH_FOREACH_PTR(c->nodes, node) {
         if (node == NULL) break;
 
-        zval z, *z_sub = &z;
+        zval z_sub;
 
-        REDIS_MAKE_STD_ZVAL(z_sub);
-        array_init(z_sub);
+        array_init(&z_sub);
 
-        add_next_index_stringl(z_sub, ZSTR_VAL(node->sock->host), ZSTR_LEN(node->sock->host));
-        add_next_index_long(z_sub, node->sock->port);
-        add_next_index_zval(return_value, z_sub);
+        add_next_index_stringl(&z_sub, ZSTR_VAL(node->sock->host), ZSTR_LEN(node->sock->host));
+        add_next_index_long(&z_sub, node->sock->port);
+        add_next_index_zval(return_value, &z_sub);
     } ZEND_HASH_FOREACH_END();
 }
 
@@ -2273,7 +2187,7 @@ PHP_METHOD(RedisCluster, discard) {
 static short
 cluster_cmd_get_slot(redisCluster *c, zval *z_arg TSRMLS_DC)
 {
-    strlen_t key_len;
+    size_t key_len;
     int key_free;
     zval *z_host, *z_port;
     short slot;
@@ -2475,7 +2389,7 @@ static void cluster_kscan_cmd(INTERNAL_FUNCTION_PARAMETERS,
 {
     redisCluster *c = GET_CONTEXT();
     char *cmd, *pat = NULL, *key = NULL;
-    strlen_t key_len = 0, pat_len = 0;
+    size_t key_len = 0, pat_len = 0;
     int cmd_len, key_free = 0;
     short slot;
     zval *z_it;
@@ -2568,7 +2482,7 @@ static void cluster_kscan_cmd(INTERNAL_FUNCTION_PARAMETERS,
 PHP_METHOD(RedisCluster, scan) {
     redisCluster *c = GET_CONTEXT();
     char *cmd, *pat = NULL;
-    strlen_t pat_len = 0;
+    size_t pat_len = 0;
     int cmd_len;
     short slot;
     zval *z_it, *z_node;
@@ -2727,7 +2641,7 @@ PHP_METHOD(RedisCluster, info) {
     REDIS_REPLY_TYPE rtype;
     char *cmd, *opt = NULL;
     int cmd_len;
-    strlen_t opt_len = 0;
+    size_t opt_len = 0;
     void *ctx = NULL;
 
     zval *z_arg;
@@ -2780,7 +2694,7 @@ PHP_METHOD(RedisCluster, client) {
     redisCluster *c = GET_CONTEXT();
     char *cmd, *opt = NULL, *arg = NULL;
     int cmd_len;
-    strlen_t opt_len, arg_len = 0;
+    size_t opt_len, arg_len = 0;
     REDIS_REPLY_TYPE rtype;
     zval *z_node;
     short slot;
@@ -3059,7 +2973,7 @@ PHP_METHOD(RedisCluster, echo) {
     zval *z_arg;
     char *cmd, *msg;
     int cmd_len;
-    strlen_t msg_len;
+    size_t msg_len;
     short slot;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &z_arg, &msg,
diff --git a/redis_cluster.h b/redis_cluster.h
index b4d0a8ba..9e536678 100644
--- a/redis_cluster.h
+++ b/redis_cluster.h
@@ -10,13 +10,8 @@
 #define REDIS_CLUSTER_MOD   (REDIS_CLUSTER_SLOTS-1)
 
 /* Get attached object context */
-#if (PHP_MAJOR_VERSION < 7)
-#define GET_CONTEXT() \
-    ((redisCluster*)zend_object_store_get_object(getThis() TSRMLS_CC))
-#else
 #define GET_CONTEXT() \
     ((redisCluster *)((char *)Z_OBJ_P(getThis()) - XtOffsetOf(redisCluster, std)))
-#endif
 
 /* Command building/processing is identical for every command */
 #define CLUSTER_BUILD_CMD(name, c, cmd, cmd_len, slot) \
@@ -104,17 +99,11 @@
 /* For the creation of RedisCluster specific exceptions */
 PHP_REDIS_API zend_class_entry *rediscluster_get_exception_base(int root TSRMLS_DC);
 
-#if (PHP_MAJOR_VERSION < 7)
-/* Create cluster context */
-zend_object_value create_cluster_context(zend_class_entry *class_type TSRMLS_DC);
-/* Free cluster context struct */
-void free_cluster_context(void *object TSRMLS_DC);
-#else
 /* Create cluster context */
 zend_object *create_cluster_context(zend_class_entry *class_type TSRMLS_DC);
+
 /* Free cluster context struct */
 void free_cluster_context(zend_object *object);
-#endif
 
 
 /* Inittialize our class with PHP */
diff --git a/redis_commands.c b/redis_commands.c
index 9dbb40f7..078d12c0 100644
--- a/redis_commands.c
+++ b/redis_commands.c
@@ -173,7 +173,7 @@ int redis_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw,
                   char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *arg;
-    strlen_t arg_len;
+    size_t arg_len;
 
     // Parse args
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len)
@@ -194,7 +194,7 @@ int redis_key_long_val_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                            void **ctx)
 {
     char *key = NULL;
-    strlen_t key_len;
+    size_t key_len;
     zend_long expire;
     zval *z_val;
 
@@ -215,7 +215,7 @@ int redis_key_long_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                            void **ctx)
 {
     char *key, *val;
-    strlen_t key_len, val_len;
+    size_t key_len, val_len;
     zend_long lval;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sls", &key, &key_len,
@@ -235,7 +235,7 @@ int redis_kv_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                  void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zval *z_val;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &key, &key_len,
@@ -255,7 +255,7 @@ int redis_key_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       void **ctx)
 {
     char *key, *val;
-    strlen_t key_len, val_len;
+    size_t key_len, val_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_len,
                              &val, &val_len) == FAILURE)
@@ -275,7 +275,7 @@ int redis_key_str_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                           void **ctx)
 {
     char *k, *v1, *v2;
-    strlen_t klen, v1len, v2len;
+    size_t klen, v1len, v2len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &k, &klen,
                              &v1, &v1len, &v2, &v2len) == FAILURE)
@@ -295,7 +295,7 @@ int redis_key_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       void **ctx)
 {
     char *k1, *k2;
-    strlen_t k1len, k2len;
+    size_t k1len, k2len;
     int k1free, k2free;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &k1, &k1len,
@@ -343,7 +343,7 @@ int redis_key_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                        void **ctx)
 {
     char *key;
-    strlen_t keylen;
+    size_t keylen;
     zend_long lval;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &key, &keylen, &lval)
@@ -382,7 +382,7 @@ int redis_key_long_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                             void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long val1, val2;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll", &key, &key_len,
@@ -402,7 +402,7 @@ int redis_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                   void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len)
                              ==FAILURE)
@@ -439,7 +439,7 @@ int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     double val;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sd", &key, &key_len,
@@ -497,7 +497,7 @@ int redis_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long start, end;
     zend_bool ws = 0;
 
@@ -533,7 +533,7 @@ int redis_zrangebyscore_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *key, *start, *end;
     int has_limit = 0;
     long offset, count;
-    strlen_t key_len, start_len, end_len;
+    size_t key_len, start_len, end_len;
     zval *z_opt=NULL, *z_ele;
     zend_string *zkey;
     ulong idx;
@@ -605,7 +605,7 @@ int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *key, *agg_op=NULL;
     int key_free, argc = 2, keys_count;
-    strlen_t key_len, agg_op_len = 0;
+    size_t key_len, agg_op_len = 0;
     zval *z_keys, *z_weights=NULL, *z_ele;
     HashTable *ht_keys, *ht_weights=NULL;
     smart_string cmdstr = {0};
@@ -672,7 +672,7 @@ int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     ZEND_HASH_FOREACH_VAL(ht_keys, z_ele) {
         zend_string *zstr = zval_get_string(z_ele);
         char *key = ZSTR_VAL(zstr);
-        strlen_t key_len = ZSTR_LEN(zstr);
+        size_t key_len = ZSTR_LEN(zstr);
 
         // Prefix key if necissary
         int key_free = redis_key_prefix(redis_sock, &key, &key_len);
@@ -760,7 +760,7 @@ int redis_subscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_chan;
     smart_string cmdstr = {0};
     subscribeContext *sctx = emalloc(sizeof(subscribeContext));
-    strlen_t key_len;
+    size_t key_len;
     int key_free;
     char *key;
 
@@ -839,7 +839,7 @@ int redis_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     ZEND_HASH_FOREACH_VAL(ht_arr, z_chan) {
         char *key = Z_STRVAL_P(z_chan);
-        strlen_t key_len = Z_STRLEN_P(z_chan);
+        size_t key_len = Z_STRLEN_P(z_chan);
         int key_free;
 
         key_free = redis_key_prefix(redis_sock, &key, &key_len);
@@ -861,7 +861,7 @@ int redis_zrangebylex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                           void **ctx)
 {
     char *key, *min, *max;
-    strlen_t key_len, min_len, max_len;
+    size_t key_len, min_len, max_len;
     int argc = ZEND_NUM_ARGS();
     zend_long offset, count;
 
@@ -902,7 +902,7 @@ int redis_zrangebylex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 }
 
 /* Validate ZLEX* min/max argument strings */
-static int validate_zlex_arg(const char *arg, strlen_t len) {
+static int validate_zlex_arg(const char *arg, size_t len) {
     return (len  > 1 && (*arg == '[' || *arg == '(')) ||
            (len == 1 && (*arg == '+' || *arg == '-'));
 }
@@ -913,7 +913,7 @@ int redis_gen_zlex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                        void **ctx)
 {
     char *key, *min, *max;
-    strlen_t key_len, min_len, max_len;
+    size_t key_len, min_len, max_len;
 
     /* Parse args */
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &key, &key_len,
@@ -946,7 +946,7 @@ int redis_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw
     HashTable *ht_arr;
     zend_long num_keys = 0;
     smart_string cmdstr = {0};
-    strlen_t lua_len;
+    size_t lua_len;
     zend_string *zstr;
     short prevslot = -1;
 
@@ -1010,7 +1010,7 @@ int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_args;
     smart_string cmdstr = {0};
-    strlen_t i;
+    size_t i;
     int argc = ZEND_NUM_ARGS();
 
     // We at least need a key and one value
@@ -1061,7 +1061,7 @@ static int gen_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     smart_string cmdstr = {0};
     zend_string *zstr;
     int key_free, val_free, argc = 1;
-    strlen_t val_len, key_len;
+    size_t val_len, key_len;
     char *key, *val;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &key_len,
@@ -1129,7 +1129,7 @@ static int gen_varkey_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_arr;
     char *key;
     int key_free, i, tail;
-    strlen_t key_len;
+    size_t key_len;
     int single_array = 0, argc = ZEND_NUM_ARGS();
     smart_string cmdstr = {0};
     long timeout = 0;
@@ -1263,7 +1263,7 @@ int redis_set_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     zval *z_value, *z_opts=NULL;
     char *key = NULL, *exp_type = NULL, *set_type = NULL;
     long expire = -1;
-    strlen_t key_len;
+    size_t key_len;
 
     // Make sure the function is being called correctly
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|z", &key, &key_len,
@@ -1350,7 +1350,7 @@ int redis_brpoplpush_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                          char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key1, *key2;
-    strlen_t key1_len, key2_len;
+    size_t key1_len, key2_len;
     int key1_free, key2_free;
     short slot1, slot2;
     zend_long timeout;
@@ -1408,7 +1408,7 @@ redis_atomic_increment(INTERNAL_FUNCTION_PARAMETERS, int type,
                        short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long val = 1;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &key, &key_len,
@@ -1458,7 +1458,7 @@ int redis_hincrby_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *mem;
-    strlen_t key_len, mem_len;
+    size_t key_len, mem_len;
     zend_long byval;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &key, &key_len,
@@ -1479,7 +1479,7 @@ int redis_hincrbyfloat_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                            char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *mem;
-    strlen_t key_len, mem_len;
+    size_t key_len, mem_len;
     double byval;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssd", &key, &key_len,
@@ -1503,7 +1503,7 @@ int redis_hmget_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *key;
     zval *z_arr, *z_mems, *z_mem;
     int i, count, valid = 0, key_free;
-    strlen_t key_len;
+    size_t key_len;
     HashTable *ht_arr;
     smart_string cmdstr = {0};
 
@@ -1586,7 +1586,7 @@ int redis_hmset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *key;
     int key_free, count;
-    strlen_t key_len;
+    size_t key_len;
     ulong idx;
     zval *z_arr;
     HashTable *ht_vals;
@@ -1619,7 +1619,7 @@ int redis_hmset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     // Start traversing our key => value array
     ZEND_HASH_FOREACH_KEY_VAL(ht_vals, idx, zkey, z_val) {
         char *mem, *val, kbuf[40];
-        strlen_t val_len;
+        size_t val_len;
         int val_free;
         unsigned int mem_len;
 
@@ -1663,7 +1663,7 @@ redis_hstrlen_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                   char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *field;
-    strlen_t key_len, field_len;
+    size_t key_len, field_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_len,
                               &field, &field_len) == FAILURE
@@ -1683,7 +1683,7 @@ int redis_bitpos_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *key;
     int argc;
     zend_long bit, start, end;
-    strlen_t key_len;
+    size_t key_len;
 
     argc = ZEND_NUM_ARGS();
     if (zend_parse_parameters(argc TSRMLS_CC, "sl|ll", &key, &key_len, &bit,
@@ -1717,7 +1717,7 @@ int redis_bitop_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_args;
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     int i, key_free, argc = ZEND_NUM_ARGS();
     smart_string cmdstr = {0};
     short kslot;
@@ -1785,7 +1785,7 @@ int redis_bitcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long start = 0, end = -1;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &key, &key_len,
@@ -1811,7 +1811,7 @@ static int redis_gen_pf_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     smart_string cmdstr = {0};
     char *mem, *key;
     int key_free, mem_free, argc=1;
-    strlen_t key_len, mem_len;
+    size_t key_len, mem_len;
     zend_string *zstr;
 
     // Parse arguments
@@ -1910,7 +1910,7 @@ int redis_pfcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_keys;
     smart_string cmdstr = {0};
     int num_keys, key_free;
-    strlen_t key_len;
+    size_t key_len;
     char *key;
     short kslot=-1;
     zend_string *zstr;
@@ -1995,7 +1995,7 @@ int redis_auth_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                    char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *pw;
-    strlen_t pw_len;
+    size_t pw_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &pw, &pw_len)
                              ==FAILURE)
@@ -2019,7 +2019,7 @@ int redis_setbit_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long offset;
     zend_bool val;
 
@@ -2046,7 +2046,7 @@ int redis_linsert_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *pos;
-    strlen_t key_len, pos_len;
+    size_t key_len, pos_len;
     zval *z_val, *z_pivot;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sszz", &key, &key_len,
@@ -2075,7 +2075,7 @@ int redis_lrem_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                    char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long count = 0;
     zval *z_val;
 
@@ -2096,7 +2096,7 @@ int redis_smove_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                     char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *src, *dst;
-    strlen_t src_len, dst_len;
+    size_t src_len, dst_len;
     int src_free, dst_free;
     zval *z_val;
 
@@ -2140,7 +2140,7 @@ static int gen_hset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                         char *kw, char **cmd, int *cmd_len, short *slot)
 {
     char *key, *mem;
-    strlen_t key_len, mem_len;
+    size_t key_len, mem_len;
     zval *z_val;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &key, &key_len,
@@ -2178,7 +2178,7 @@ int redis_srandmember_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                           short *have_count)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     zend_long count;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &key, &key_len,
@@ -2205,7 +2205,7 @@ int redis_zincrby_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
     double incrby;
     zval *z_val;
 
@@ -2229,7 +2229,7 @@ int redis_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *key;
     HashTable *ht_opts;
     smart_string cmdstr = {0};
-    strlen_t key_len;
+    size_t key_len;
     int key_free;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &key, &key_len,
@@ -2446,7 +2446,7 @@ int redis_hdel_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     smart_string cmdstr = {0};
     char *arg;
     int arg_free, i;
-    strlen_t arg_len;
+    size_t arg_len;
     int argc = ZEND_NUM_ARGS();
     zend_string *zstr;
 
@@ -2503,7 +2503,7 @@ int redis_zadd_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_args;
     char *key, *val, *exp_type = NULL;
-    strlen_t key_len, val_len;
+    size_t key_len, val_len;
     int key_free, val_free;
     int num = ZEND_NUM_ARGS(), i = 1, argc;
     zend_bool ch = 0, incr = 0;
@@ -2611,7 +2611,7 @@ int redis_object_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      short *slot, void **ctx)
 {
     char *key, *subcmd;
-    strlen_t key_len, subcmd_len;
+    size_t key_len, subcmd_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &subcmd,
                              &subcmd_len, &key, &key_len) == FAILURE)
@@ -2645,7 +2645,7 @@ int redis_geodist_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *source, *dest, *unit = NULL;
-    strlen_t keylen, sourcelen, destlen, unitlen;
+    size_t keylen, sourcelen, destlen, unitlen;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|s", &key, &keylen,
                               &source, &sourcelen, &dest, &destlen, &unit,
@@ -2745,7 +2745,7 @@ void append_georadius_opts(RedisSock *redis_sock, smart_string *str, short *slot
                            geoOptions *opt)
 {
     char *key;
-    strlen_t keylen;
+    size_t keylen;
     int keyfree;
 
     if (opt->withcoord)
@@ -2794,7 +2794,7 @@ int redis_georadius_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *key, *unit;
     short store_slot = 0;
-    strlen_t keylen, unitlen;
+    size_t keylen, unitlen;
     int argc = 5, keyfree;
     double lng, lat, radius;
     zval *opts = NULL;
@@ -2863,7 +2863,7 @@ int redis_georadiusbymember_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_s
                                 char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *mem, *unit;
-    strlen_t keylen, memlen, unitlen;
+    size_t keylen, memlen, unitlen;
     short store_slot = 0;
     int keyfree, argc = 4;
     double radius;
@@ -2931,7 +2931,7 @@ int redis_migrate_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *host, *key;
     int argc, keyfree;
     zval *z_keys, *z_key;
-    strlen_t hostlen, keylen;
+    size_t hostlen, keylen;
     zend_long destdb, port, timeout;
     zend_bool copy = 0, replace = 0;
     zend_string *zstr;
@@ -3111,7 +3111,7 @@ int redis_command_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *kw=NULL;
     zval *z_arg;
-    strlen_t kw_len;
+    size_t kw_len;
 
     /* Parse our args */
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &kw, &kw_len,
@@ -3186,7 +3186,7 @@ int redis_xadd_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_fields;
     int fcount, argc;
     char *key, *id;
-    strlen_t keylen, idlen;
+    size_t keylen, idlen;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssa|lb", &key, &keylen,
                               &id, &idlen, &z_fields, &maxlen, &approx) == FAILURE)
@@ -3240,7 +3240,7 @@ int redis_xpending_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     smart_string cmdstr = {0};
     char *key, *group, *start = NULL, *end = NULL, *consumer = NULL;
-    strlen_t keylen, grouplen, startlen, endlen, consumerlen;
+    size_t keylen, grouplen, startlen, endlen, consumerlen;
     int argc;
     zend_long count = -1;
 
@@ -3288,7 +3288,7 @@ int redis_xrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     smart_string cmdstr = {0};
     char *key, *start, *end;
-    strlen_t keylen, startlen, endlen;
+    size_t keylen, startlen, endlen;
     zend_long count = -1;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &key, &keylen,
@@ -3432,7 +3432,7 @@ int redis_xreadgroup_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     zval *z_streams;
     HashTable *kt;
     char *group, *consumer;
-    strlen_t grouplen, consumerlen;
+    size_t grouplen, consumerlen;
     int scount, argc;
     zend_long count = -1, block = -1;
 
@@ -3487,7 +3487,7 @@ int redis_xack_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     smart_string cmdstr = {0};
     char *key, *group;
-    strlen_t keylen, grouplen;
+    size_t keylen, grouplen;
     zend_string *idstr;
     zval *z_ids, *z_id;
     HashTable *ht_ids;
@@ -3579,7 +3579,7 @@ static void get_xclaim_options(zval *z_arr, xclaimOptions *opt TSRMLS_DC) {
     HashTable *ht;
     zend_string *zkey;
     char *kval;
-    strlen_t klen;
+    size_t klen;
     ulong idx;
     zval *zv;
 
@@ -3671,7 +3671,7 @@ int redis_xclaim_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     smart_string cmdstr = {0};
     char *key, *group, *consumer;
-    strlen_t keylen, grouplen, consumerlen;
+    size_t keylen, grouplen, consumerlen;
     zend_long min_idle;
     int argc, id_count;
     zval *z_ids, *z_id, *z_opts = NULL;
@@ -3730,7 +3730,7 @@ int redis_xgroup_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *op, *key = NULL, *arg1 = NULL, *arg2 = NULL;
-    strlen_t oplen, keylen, arg1len, arg2len;
+    size_t oplen, keylen, arg1len, arg2len;
     zend_bool mkstream = 0;
     int argc = ZEND_NUM_ARGS();
 
@@ -3780,7 +3780,7 @@ int redis_xinfo_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                      char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *op, *key, *arg;
-    strlen_t oplen, keylen, arglen;
+    size_t oplen, keylen, arglen;
     char fmt[4];
     int argc = ZEND_NUM_ARGS();
 
@@ -3805,7 +3805,7 @@ int redis_xtrim_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                     char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key;
-    strlen_t keylen;
+    size_t keylen;
     zend_long maxlen;
     zend_bool approx = 0;
 
@@ -3874,7 +3874,7 @@ void redis_setoption_handler(INTERNAL_FUNCTION_PARAMETERS,
     zend_long option;
     char *val_str;
     struct timeval read_tv;
-    strlen_t val_len;
+    size_t val_len;
     int tcp_keepalive = 0;
     php_netstream_data_t *sock;
 
@@ -3972,7 +3972,7 @@ void redis_setoption_handler(INTERNAL_FUNCTION_PARAMETERS,
 
 void redis_prefix_handler(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock) {
     char *key;
-    strlen_t key_len;
+    size_t key_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len)
                              ==FAILURE)
@@ -3994,7 +3994,7 @@ void redis_serialize_handler(INTERNAL_FUNCTION_PARAMETERS,
 {
     zval *z_val;
     char *val;
-    strlen_t val_len;
+    size_t val_len;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &z_val) == FAILURE) {
         RETURN_FALSE;
@@ -4010,7 +4010,7 @@ void redis_unserialize_handler(INTERNAL_FUNCTION_PARAMETERS,
                                RedisSock *redis_sock, zend_class_entry *ex)
 {
     char *value;
-    strlen_t value_len;
+    size_t value_len;
 
     // Parse our arguments
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len)
diff --git a/redis_session.c b/redis_session.c
index a02c1897..f43021e7 100644
--- a/redis_session.c
+++ b/redis_session.c
@@ -52,11 +52,7 @@
 #define NEGATIVE_LOCK_RESPONSE 1
 
 ps_module ps_mod_redis = {
-#if (PHP_MAJOR_VERSION < 7)
-    PS_MOD_SID(redis)
-#else
     PS_MOD_UPDATE_TIMESTAMP(redis)
-#endif
 };
 
 ps_module ps_mod_redis_cluster = {
@@ -586,52 +582,33 @@ PS_CREATE_SID_FUNC(redis)
     redis_pool *pool = PS_GET_MOD_DATA();
 
     if (!pool) {
-#if (PHP_MAJOR_VERSION < 7)
-        return php_session_create_id(NULL, newlen TSRMLS_CC);
-#else
         return php_session_create_id(NULL TSRMLS_CC);
-#endif
     }
 
     while (retries-- > 0) {
-#if (PHP_MAJOR_VERSION < 7)
-        char* sid = php_session_create_id((void **) &pool, newlen TSRMLS_CC);
-        redis_pool_member *rpm = redis_pool_get_sock(pool, sid TSRMLS_CC);
-#else
         zend_string* sid = php_session_create_id((void **) &pool TSRMLS_CC);
         redis_pool_member *rpm = redis_pool_get_sock(pool, ZSTR_VAL(sid) TSRMLS_CC);
-#endif
+
         RedisSock *redis_sock = rpm?rpm->redis_sock:NULL;
 
         if (!rpm || !redis_sock) {
             php_error_docref(NULL TSRMLS_CC, E_NOTICE,
                 "Redis not available while creating session_id");
 
-#if (PHP_MAJOR_VERSION < 7)
-            efree(sid);
-            return php_session_create_id(NULL, newlen TSRMLS_CC);
-#else
             zend_string_release(sid);
             return php_session_create_id(NULL TSRMLS_CC);
-#endif
         }
 
         if (pool->lock_status.session_key) zend_string_release(pool->lock_status.session_key);
-#if (PHP_MAJOR_VERSION < 7)
-        pool->lock_status.session_key = redis_session_key(rpm, sid, strlen(sid));
-#else
         pool->lock_status.session_key = redis_session_key(rpm, ZSTR_VAL(sid), ZSTR_LEN(sid));
-#endif
+        
         if (lock_acquire(redis_sock, &pool->lock_status TSRMLS_CC) == SUCCESS) {
             return sid;
         }
 
         zend_string_release(pool->lock_status.session_key);
-#if (PHP_MAJOR_VERSION < 7)
-        efree(sid);
-#else
         zend_string_release(sid);
-#endif
+
         sid = NULL;
     }
 
@@ -642,7 +619,6 @@ PS_CREATE_SID_FUNC(redis)
 }
 /* }}} */
 
-#if (PHP_MAJOR_VERSION >= 7)
 /* {{{ PS_VALIDATE_SID_FUNC
  */
 PS_VALIDATE_SID_FUNC(redis)
@@ -686,9 +662,7 @@ PS_VALIDATE_SID_FUNC(redis)
     }
 }
 /* }}} */
-#endif
 
-#if (PHP_MAJOR_VERSION >= 7)
 /* {{{ PS_UPDATE_TIMESTAMP_FUNC
  */
 PS_UPDATE_TIMESTAMP_FUNC(redis)
@@ -733,7 +707,6 @@ PS_UPDATE_TIMESTAMP_FUNC(redis)
     }
 }
 /* }}} */
-#endif
 
 /* {{{ PS_READ_FUNC
  */
@@ -741,13 +714,8 @@ PS_READ_FUNC(redis)
 {
     char *resp, *cmd;
     int resp_len, cmd_len;
-#if (PHP_MAJOR_VERSION < 7)
-    const char *skey = key;
-    size_t skeylen = strlen(key);
-#else
     const char *skey = ZSTR_VAL(key);
     size_t skeylen = ZSTR_LEN(key);
-#endif
 
     if (!skeylen) return FAILURE;
 
@@ -780,22 +748,13 @@ PS_READ_FUNC(redis)
     if ((resp = redis_sock_read(redis_sock, &resp_len TSRMLS_CC)) == NULL && resp_len != -1) {
         return FAILURE;
     }
-#if (PHP_MAJOR_VERSION < 7)
-    if (resp_len < 0) {
-        *val = STR_EMPTY_ALLOC();
-        *vallen = 0;
-    } else {
-        *val = resp;
-        *vallen = resp_len;
-    }
-#else
+
     if (resp_len < 0) {
         *val = ZSTR_EMPTY_ALLOC();
     } else {
         *val = zend_string_init(resp, resp_len, 0);
     }
     efree(resp);
-#endif
 
     return SUCCESS;
 }
@@ -807,13 +766,8 @@ PS_WRITE_FUNC(redis)
 {
     char *cmd, *response;
     int cmd_len, response_len;
-#if (PHP_MAJOR_VERSION < 7)
-    const char *skey = key, *sval = val;
-    size_t skeylen = strlen(key), svallen = vallen;
-#else
     const char *skey = ZSTR_VAL(key), *sval = ZSTR_VAL(val);
     size_t skeylen = ZSTR_LEN(key), svallen = ZSTR_LEN(val);
-#endif
 
     if (!skeylen) return FAILURE;
 
@@ -826,18 +780,7 @@ PS_WRITE_FUNC(redis)
 
     /* send SET command */
     zend_string *session = redis_session_key(rpm, skey, skeylen);
-#if (PHP_MAJOR_VERSION < 7)
-    /* We need to check for PHP5 if the session key changes (a bug with session_regenerate_id() is causing a missing PS_CREATE_SID call)*/
-    if (!zend_string_equals(pool->lock_status.session_key, session)) {
-        zend_string_release(pool->lock_status.session_key);
-        pool->lock_status.session_key = zend_string_init(ZSTR_VAL(session), ZSTR_LEN(session), 0);
-        if (lock_acquire(redis_sock, &pool->lock_status TSRMLS_CC) != SUCCESS) {
-            zend_string_release(pool->lock_status.session_key);
-            zend_string_release(session);
-            return FAILURE;
-        }
-    }
-#endif
+
     cmd_len = REDIS_SPPRINTF(&cmd, "SETEX", "Sds", session, INI_INT("session.gc_maxlifetime"), sval, svallen);
     zend_string_release(session);
 
@@ -868,13 +811,8 @@ PS_DESTROY_FUNC(redis)
 {
     char *cmd, *response;
     int cmd_len, response_len;
-#if (PHP_MAJOR_VERSION < 7)
-    const char *skey = key;
-    size_t skeylen = strlen(key);
-#else
     const char *skey = ZSTR_VAL(key);
     size_t skeylen = ZSTR_LEN(key);
-#endif
 
     redis_pool *pool = PS_GET_MOD_DATA();
     redis_pool_member *rpm = redis_pool_get_sock(pool, skey TSRMLS_CC);
@@ -982,7 +920,7 @@ PS_OPEN_FUNC(rediscluster) {
     HashTable *ht_conf, *ht_seeds;
     double timeout = 0, read_timeout = 0;
     int retval, persistent = 0, failover = REDIS_FAILOVER_NONE;
-    strlen_t prefix_len, auth_len = 0;
+    size_t prefix_len, auth_len = 0;
     char *prefix, *auth = NULL;
 
     /* Parse configuration for session handler */
@@ -1078,11 +1016,8 @@ PS_READ_FUNC(rediscluster) {
     short slot;
 
     /* Set up our command and slot information */
-#if (PHP_MAJOR_VERSION < 7)
-    skey = cluster_session_key(c, key, strlen(key), &skeylen, &slot);
-#else
     skey = cluster_session_key(c, ZSTR_VAL(key), ZSTR_LEN(key), &skeylen, &slot);
-#endif
+
     cmdlen = redis_spprintf(NULL, NULL TSRMLS_CC, &cmd, "GET", "s", skey, skeylen);
     efree(skey);
 
@@ -1104,17 +1039,6 @@ PS_READ_FUNC(rediscluster) {
     }
 
     /* Push reply value to caller */
-#if (PHP_MAJOR_VERSION < 7)
-    if (reply->str == NULL) {
-        *val = STR_EMPTY_ALLOC();
-        *vallen = 0;
-    } else {
-        *val = reply->str;
-        *vallen = reply->len;
-    }
-
-    free_flag = 0;
-#else
     if (reply->str == NULL) {
         *val = ZSTR_EMPTY_ALLOC();
     } else {
@@ -1122,7 +1046,6 @@ PS_READ_FUNC(rediscluster) {
     }
 
     free_flag = 1;
-#endif
 
     /* Clean up */
     cluster_free_reply(reply, free_flag);
@@ -1141,17 +1064,10 @@ PS_WRITE_FUNC(rediscluster) {
     short slot;
 
     /* Set up command and slot info */
-#if (PHP_MAJOR_VERSION < 7)
-    skey = cluster_session_key(c, key, strlen(key), &skeylen, &slot);
-    cmdlen = redis_spprintf(NULL, NULL TSRMLS_CC, &cmd, "SETEX", "sds", skey,
-                            skeylen, INI_INT("session.gc_maxlifetime"), val,
-                            vallen);
-#else
     skey = cluster_session_key(c, ZSTR_VAL(key), ZSTR_LEN(key), &skeylen, &slot);
     cmdlen = redis_spprintf(NULL, NULL TSRMLS_CC, &cmd, "SETEX", "sds", skey,
                             skeylen, INI_INT("session.gc_maxlifetime"),
                             ZSTR_VAL(val), ZSTR_LEN(val));
-#endif
     efree(skey);
 
     /* Attempt to send command */
@@ -1187,11 +1103,8 @@ PS_DESTROY_FUNC(rediscluster) {
     short slot;
 
     /* Set up command and slot info */
-#if (PHP_MAJOR_VERSION < 7)
-    skey = cluster_session_key(c, key, strlen(key), &skeylen, &slot);
-#else
     skey = cluster_session_key(c, ZSTR_VAL(key), ZSTR_LEN(key), &skeylen, &slot);
-#endif
+
     cmdlen = redis_spprintf(NULL, NULL TSRMLS_CC, &cmd, "DEL", "s", skey, skeylen);
     efree(skey);
 
diff --git a/redis_session.h b/redis_session.h
index 6c6b101f..1529c05d 100644
--- a/redis_session.h
+++ b/redis_session.h
@@ -11,10 +11,8 @@ PS_DESTROY_FUNC(redis);
 PS_GC_FUNC(redis);
 PS_CREATE_SID_FUNC(redis);
 
-#if (PHP_MAJOR_VERSION >= 7)
 PS_VALIDATE_SID_FUNC(redis);
 PS_UPDATE_TIMESTAMP_FUNC(redis);
-#endif
 
 PS_OPEN_FUNC(rediscluster);
 PS_CLOSE_FUNC(rediscluster);