Use ZSTR_VAL and ZSTR_LEN macroses to access zend_string fields

9 files changed, 91 insertions, 87 deletions

diff --git a/cluster_library.c b/cluster_library.c
index 1b4eb35b..987142e8 100644
--- a/cluster_library.c
+++ b/cluster_library.c
@@ -2431,7 +2431,7 @@ int mbulk_resp_loop_zipdbl(RedisSock *redis_sock, zval *z_result,
                 zval zv, *z = &zv;
                 if (redis_unserialize(redis_sock,key,key_len, z TSRMLS_CC)) {
                     zend_string *zstr = zval_get_string(z);
-                    add_assoc_double_ex(z_result, zstr->val, zstr->len, atof(line));
+                    add_assoc_double_ex(z_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), atof(line));
                     zend_string_release(zstr);
                     zval_dtor(z);
                 } else {
diff --git a/common.h b/common.h
index ce7383e6..ed47b92d 100644
--- a/common.h
+++ b/common.h
@@ -22,9 +22,12 @@ typedef struct {
     char *val;
 } zend_string;
 
+#define ZSTR_VAL(s) (s)->val
+#define ZSTR_LEN(s) (s)->len
+
 #define zend_string_release(s) do { \
     if ((s) && (s)->gc) { \
-        if ((s)->gc & 0x10 && (s)->val) efree((s)->val); \
+        if ((s)->gc & 0x10 && ZSTR_VAL(s)) efree(ZSTR_VAL(s)); \
         if ((s)->gc & 0x01) efree((s)); \
     } \
 } while (0)
@@ -210,21 +213,22 @@ extern int (*_add_next_index_stringl)(zval *, const char *, uint, int);
 
 #undef ZVAL_STRING
 #define ZVAL_STRING(z, s) do { \
-    const char *_s=(s); \
+    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; \
+    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)
+} while (0)
 #undef RETVAL_STRINGL
 #define RETVAL_STRINGL(s, l) ZVAL_STRINGL(return_value, s, l)
 #undef RETURN_STRINGL
@@ -335,27 +339,27 @@ zval_get_string(zval *op)
     zend_string *zstr = ecalloc(1, sizeof(zend_string));
 
     zstr->gc = 0;
-    zstr->val = "";
-    zstr->len = 0;
+    ZSTR_VAL(zstr) = "";
+    ZSTR_LEN(zstr) = 0;
     switch (Z_TYPE_P(op)) {
         case IS_STRING:
-            zstr->val = Z_STRVAL_P(op);
-            zstr->len = Z_STRLEN_P(op);
+            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 = "1";
-                zstr->len = 1;
+                ZSTR_VAL(zstr) = "1";
+                ZSTR_LEN(zstr) = 1;
             }
             break;
         case IS_LONG: {
             zstr->gc = 0x10;
-            zstr->len = spprintf(&zstr->val, 0, "%ld", Z_LVAL_P(op));
+            ZSTR_LEN(zstr) = spprintf(&ZSTR_VAL(zstr), 0, "%ld", Z_LVAL_P(op));
             break;
         }
         case IS_DOUBLE: {
             zstr->gc = 0x10;
-            zstr->len = spprintf(&zstr->val, 0, "%.16g", Z_DVAL_P(op));
+            ZSTR_LEN(zstr) = spprintf(&ZSTR_VAL(zstr), 0, "%.16g", Z_DVAL_P(op));
             break;
         }
         EMPTY_SWITCH_DEFAULT_CASE()
diff --git a/library.c b/library.c
index 957d6251..62312c0c 100644
--- a/library.c
+++ b/library.c
@@ -590,7 +590,7 @@ redis_spprintf(RedisSock *redis_sock, short *slot TSRMLS_DC, char **ret, char *k
                 break;
             case 'S':
                 arg.zstr = va_arg(ap, zend_string*);
-                redis_cmd_append_sstr(&cmd, arg.zstr->val, arg.zstr->len);
+                redis_cmd_append_sstr(&cmd, ZSTR_VAL(arg.zstr), ZSTR_LEN(arg.zstr));
                 break;
             case 'k':
                 arg.str = va_arg(ap, char*);
@@ -1119,16 +1119,16 @@ 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, hkey->val, hkey->len, 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, hkey->val, hkey->len, 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, hkey->val, hkey->len, z);
+            add_assoc_zval_ex(z_ret, ZSTR_VAL(hkey), ZSTR_LEN(hkey), z);
         }
         zend_string_release(hkey);
     }
@@ -1814,8 +1814,8 @@ redis_serialize(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len
 
                 default: { /* copy */
                     zend_string *zstr = zval_get_string(z);
-                    *val = estrndup(zstr->val, zstr->len);
-                    *val_len = zstr->len;
+                    *val = estrndup(ZSTR_VAL(zstr), ZSTR_LEN(zstr));
+                    *val_len = ZSTR_LEN(zstr);
                     zend_string_release(zstr);
                     return 1;
                 }
@@ -1833,8 +1833,8 @@ redis_serialize(RedisSock *redis_sock, zval *z, char **val, strlen_t *val_len
             *val = estrndup(sstr.c, sstr.len);
             *val_len = sstr.len;
 #else
-            *val = estrndup(sstr.s->val, sstr.s->len);
-            *val_len = sstr.s->len;
+            *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
diff --git a/redis.c b/redis.c
index 6b178216..9d6d535f 100644
--- a/redis.c
+++ b/redis.c
@@ -1547,7 +1547,7 @@ PHP_METHOD(Redis, getMultiple)
     /* Iterate through and grab our keys */
     ZEND_HASH_FOREACH_VAL(hash, z_ele) {
         zend_string *zstr = zval_get_string(z_ele);
-        redis_cmd_append_sstr_key(&cmd, zstr->val, zstr->len, redis_sock, NULL);
+        redis_cmd_append_sstr_key(&cmd, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, NULL);
         zend_string_release(zstr);
     } ZEND_HASH_FOREACH_END();
 
@@ -2004,13 +2004,13 @@ generic_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, int desc, int alpha)
             ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zget), zele) {
                 zpattern = zval_get_string(zele);
                 redis_cmd_append_sstr(&cmd, "GET", sizeof("GET") - 1);
-                redis_cmd_append_sstr(&cmd, zpattern->val, zpattern->len);
+                redis_cmd_append_sstr(&cmd, ZSTR_VAL(zpattern), ZSTR_LEN(zpattern));
                 zend_string_release(zpattern);
             } ZEND_HASH_FOREACH_END();
         } else {
             zpattern = zval_get_string(zget);
             redis_cmd_append_sstr(&cmd, "GET", sizeof("GET") - 1);
-            redis_cmd_append_sstr(&cmd, zpattern->val, zpattern->len);
+            redis_cmd_append_sstr(&cmd, ZSTR_VAL(zpattern), ZSTR_LEN(zpattern));
             zend_string_release(zpattern);
         }
     }
@@ -2273,7 +2273,7 @@ void generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun)
     ZEND_HASH_FOREACH_KEY_VAL(htargs, idx, zkey,  zmem) {
         /* Handle string or numeric keys */
         if (zkey) {
-            redis_cmd_append_sstr_key(&cmd, zkey->val, zkey->len, redis_sock, NULL);
+            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);
@@ -3197,7 +3197,7 @@ redis_build_pubsub_cmd(RedisSock *redis_sock, char **ret, PUBSUB_TYPE type,
         /* Iterate our elements */
         ZEND_HASH_FOREACH_VAL(ht_chan, z_ele) {
             zend_string *zstr = zval_get_string(z_ele);
-            redis_cmd_append_sstr_key(&cmd, zstr->val, zstr->len, redis_sock, NULL);
+            redis_cmd_append_sstr_key(&cmd, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, NULL);
             zend_string_release(zstr);
         } ZEND_HASH_FOREACH_END();
 
@@ -3310,7 +3310,7 @@ redis_build_script_exists_cmd(char **ret, zval *argv, int argc) {
 
     for (i = 0; i < argc; i++) {
         zstr = zval_get_string(&argv[i]);
-        redis_cmd_append_sstr(&cmd, zstr->val, zstr->len);
+        redis_cmd_append_sstr(&cmd, ZSTR_VAL(zstr), ZSTR_LEN(zstr));
         zend_string_release(zstr);
     }
 
diff --git a/redis_array.c b/redis_array.c
index d88bd2d0..bdb65cad 100644
--- a/redis_array.c
+++ b/redis_array.c
@@ -1054,8 +1054,8 @@ PHP_METHOD(RedisArray, mset)
     ZEND_HASH_FOREACH_KEY_VAL(h_keys, idx, zkey, data) {
         /* If the key isn't a string, make a string representation of it */
         if (zkey) {
-            key_len = zkey->len;
-            key = zkey->val;
+            key_len = ZSTR_LEN(zkey);
+            key = ZSTR_VAL(zkey);
         } else {
             key_len = snprintf(kbuf, sizeof(kbuf), "%lu", idx);
             key = kbuf;
diff --git a/redis_array_impl.c b/redis_array_impl.c
index a551c9ab..a929fa20 100644
--- a/redis_array_impl.c
+++ b/redis_array_impl.c
@@ -590,7 +590,7 @@ ra_index_keys(zval *z_pairs, zval *z_redis TSRMLS_DC) {
 #endif
 
         if (zkey) {
-            ZVAL_STRINGL(z_new, zkey->val, zkey->len);
+            ZVAL_STRINGL(z_new, ZSTR_VAL(zkey), ZSTR_LEN(zkey));
         } else {
             ZVAL_LONG(z_new, idx);
         }
@@ -898,7 +898,7 @@ ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TS
 
 		/* add value */
         if (zkey) {
-            ZVAL_STRINGL(&z_zadd_args[i+1], zkey->val, zkey->len);
+            ZVAL_STRINGL(&z_zadd_args[i+1], ZSTR_VAL(zkey), ZSTR_LEN(zkey));
         } else {
             ZVAL_LONG(&z_zadd_args[i+1], (long)idx);
         }
diff --git a/redis_cluster.c b/redis_cluster.c
index ca67a570..299eef9e 100644
--- a/redis_cluster.c
+++ b/redis_cluster.c
@@ -589,8 +589,8 @@ static int get_key_val_ht(redisCluster *c, HashTable *ht, HashPosition *ptr,
 	zend_string *zkey;
 	switch (zend_hash_get_current_key_ex(ht, &zkey, &idx, ptr)) {
 		case HASH_KEY_IS_STRING:
-			kv->key_len = zkey->len;
-			kv->key = zkey->val;
+			kv->key_len = ZSTR_LEN(zkey);
+			kv->key = ZSTR_VAL(zkey);
 #endif
             break;
         case HASH_KEY_IS_LONG:
@@ -2062,7 +2062,7 @@ PHP_METHOD(RedisCluster, watch) {
         zstr = zval_get_string(&z_args[i]);
 
         // Add this key to our distribution handler
-        if (cluster_dist_add_key(c, ht_dist, zstr->val, zstr->len, NULL) == FAILURE) {
+        if (cluster_dist_add_key(c, ht_dist, ZSTR_VAL(zstr), ZSTR_LEN(zstr), NULL) == FAILURE) {
             zend_throw_exception(redis_cluster_exception_ce,
                 "Can't issue WATCH command as the keyspace isn't fully mapped",
                 0 TSRMLS_CC);
@@ -2216,8 +2216,8 @@ cluster_cmd_get_slot(redisCluster *c, zval *z_arg TSRMLS_DC)
     {
         /* Allow for any scalar here */
         zstr = zval_get_string(z_arg);
-        key = zstr->val;
-        key_len = zstr->len;
+        key = ZSTR_VAL(zstr);
+        key_len = ZSTR_LEN(zstr);
 
         /* Hash it */
         key_free = redis_key_prefix(c->flags, &key, &key_len);
@@ -2333,7 +2333,7 @@ static void cluster_raw_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len)
     /* Iterate, appending args */
     for(i=1;i<argc;i++) {
         zend_string *zstr = zval_get_string(&z_args[i]);
-        redis_cmd_append_sstr(&cmd, zstr->val, zstr->len);
+        redis_cmd_append_sstr(&cmd, ZSTR_VAL(zstr), ZSTR_LEN(zstr));
         zend_string_release(zstr);
     }
 
diff --git a/redis_commands.c b/redis_commands.c
index 70689a9b..2564c0f5 100644
--- a/redis_commands.c
+++ b/redis_commands.c
@@ -441,9 +441,9 @@ int redis_zrangebyscore_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
            if (!zkey) continue;
            ZVAL_DEREF(z_ele);
            /* Check for withscores and limit */
-           if (IS_WITHSCORES_ARG(zkey->val, zkey->len)) {
+           if (IS_WITHSCORES_ARG(ZSTR_VAL(zkey), ZSTR_LEN(zkey))) {
                *withscores = zval_is_true(z_ele);
-           } else if (IS_LIMIT_ARG(zkey->val, zkey->len) && Z_TYPE_P(z_ele) == IS_ARRAY) {
+           } else if (IS_LIMIT_ARG(ZSTR_VAL(zkey), ZSTR_LEN(zkey)) && Z_TYPE_P(z_ele) == IS_ARRAY) {
                 HashTable *htlimit = Z_ARRVAL_P(z_ele);
                 zval *zoff, *zcnt;
 
@@ -556,8 +556,8 @@ int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     // Process input keys
     ZEND_HASH_FOREACH_VAL(ht_keys, z_ele) {
         zend_string *zstr = zval_get_string(z_ele);
-        char *key = zstr->val;
-        strlen_t key_len = zstr->len;
+        char *key = ZSTR_VAL(zstr);
+        strlen_t key_len = ZSTR_LEN(zstr);
 
         // Prefix key if necissary
         int key_free = redis_key_prefix(redis_sock, &key, &key_len);
@@ -674,8 +674,8 @@ int redis_subscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zend_string *zstr = zval_get_string(z_chan);
 
         // Grab channel name, prefix if required
-        key = zstr->val;
-        key_len = zstr->len;
+        key = ZSTR_VAL(zstr);
+        key_len = ZSTR_LEN(zstr);
         key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
         // Add this channel
@@ -856,7 +856,7 @@ int redis_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw
 
             /* If we're still on a key, prefix it check slot */
             if (num_keys-- > 0) {
-                redis_cmd_append_sstr_key(&cmdstr, zstr->val, zstr->len, redis_sock, slot);
+                redis_cmd_append_sstr_key(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, slot);
 
                 /* If we have been passed a slot, all keys must match */
                 if (slot) {
@@ -868,7 +868,7 @@ int redis_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw
                     prevslot = *slot;
                 }
             } else {
-                redis_cmd_append_sstr(&cmdstr, zstr->val, zstr->len);
+                redis_cmd_append_sstr(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr));
             }
 
             zend_string_release(zstr);
@@ -911,7 +911,7 @@ int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     /* Append key */
     zend_string *zstr = zval_get_string(&z_args[0]);
-    redis_cmd_append_sstr_key(&cmdstr, zstr->val, zstr->len, redis_sock, slot);
+    redis_cmd_append_sstr_key(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, slot);
     zend_string_release(zstr);
 
     /* Add members */
@@ -1030,8 +1030,8 @@ static int gen_varkey_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     if(single_array) {
         ZEND_HASH_FOREACH_VAL(ht_arr, z_ele) {
             zstr = zval_get_string(z_ele);
-            key = zstr->val;
-            key_len = zstr->len;
+            key = ZSTR_VAL(zstr);
+            key_len = ZSTR_LEN(zstr);
             key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
             // Protect against CROSSLOT errors
@@ -1066,8 +1066,8 @@ static int gen_varkey_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         tail = has_timeout ? argc-1 : argc;
         for(i=0;i<tail;i++) {
             zstr = zval_get_string(&z_args[i]);
-            key = zstr->val;
-            key_len = zstr->len;
+            key = ZSTR_VAL(zstr);
+            key_len = ZSTR_LEN(zstr);
 
             key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
@@ -1148,9 +1148,9 @@ int redis_set_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         ZEND_HASH_FOREACH_KEY_VAL(kt, idx, zkey, v) {
             ZVAL_DEREF(v);
             /* Detect PX or EX argument and validate timeout */
-            if (zkey && IS_EX_PX_ARG(zkey->val)) {
+            if (zkey && IS_EX_PX_ARG(ZSTR_VAL(zkey))) {
                 /* Set expire type */
-                exp_type = zkey->val;
+                exp_type = ZSTR_VAL(zkey);
 
                 /* Try to extract timeout */
                 if (Z_TYPE_P(v) == IS_LONG) {
@@ -1480,8 +1480,8 @@ int redis_hmset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
         // If the hash key is an integer, convert it to a string
         if (zkey) {
-            mem_len = zkey->len;
-            mem = zkey->val;
+            mem_len = ZSTR_LEN(zkey);
+            mem = ZSTR_VAL(zkey);
         } else {
             mem_len = snprintf(kbuf, sizeof(kbuf), "%ld", (long)idx);
             mem = (char*)kbuf;
@@ -1600,8 +1600,8 @@ int redis_bitop_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zstr = zval_get_string(&z_args[i]);
 
         // Grab this key and length
-        key = zstr->val;
-        key_len = zstr->len;
+        key = ZSTR_VAL(zstr);
+        key_len = ZSTR_LEN(zstr);
 
         // Prefix key, append
         key_free = redis_key_prefix(redis_sock, &key, &key_len);
@@ -1701,8 +1701,8 @@ static int redis_gen_pf_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         // Prefix keys, serialize values
         if(is_keys) {
             zstr = zval_get_string(z_ele);
-            mem = zstr->val;
-            mem_len = zstr->len;
+            mem = ZSTR_VAL(zstr);
+            mem_len = ZSTR_LEN(zstr);
 
             // Key prefix
             mem_free = redis_key_prefix(redis_sock, &mem, &mem_len);
@@ -1722,8 +1722,8 @@ static int redis_gen_pf_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
             zstr = NULL;
             if(!mem_free) {
                 zstr = zval_get_string(z_ele);
-                mem = zstr->val;
-                mem_len = zstr->len;
+                mem = ZSTR_VAL(zstr);
+                mem_len = ZSTR_LEN(zstr);
             }
         }
 
@@ -1795,8 +1795,8 @@ int redis_pfcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         ZEND_HASH_FOREACH_VAL(ht_keys, z_key) {
             /* Turn our value into a string if it isn't one */
             zstr = zval_get_string(z_key);
-            key = zstr->val;
-            key_len = zstr->len;
+            key = ZSTR_VAL(zstr);
+            key_len = ZSTR_LEN(zstr);
 
             /* Append this key to our command */
             key_free = redis_key_prefix(redis_sock, &key, &key_len);
@@ -1827,8 +1827,8 @@ int redis_pfcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
         /* Turn our key into a string if it's a different type */
         zstr = zval_get_string(z_keys);
-        key = zstr->val;
-        key_len = zstr->len;
+        key = ZSTR_VAL(zstr);
+        key_len = ZSTR_LEN(zstr);
         key_free = redis_key_prefix(redis_sock, &key, &key_len);
         redis_cmd_append_sstr(&cmdstr, key, key_len);
 
@@ -2325,8 +2325,8 @@ int redis_hdel_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     // Get first argument (the key) as a string
     zstr = zval_get_string(&z_args[0]);
-    arg = zstr->val;
-    arg_len = zstr->len;
+    arg = ZSTR_VAL(zstr);
+    arg_len = ZSTR_LEN(zstr);
 
     // Prefix
     arg_free = redis_key_prefix(redis_sock, &arg, &arg_len);
@@ -2343,7 +2343,7 @@ int redis_hdel_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     // Iterate through the members we're removing
     for(i=1;i<argc;i++) {
         zstr = zval_get_string(&z_args[i]);
-        redis_cmd_append_sstr(&cmdstr, zstr->val, zstr->len);
+        redis_cmd_append_sstr(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr));
         zend_string_release(zstr);
     }
 
@@ -2416,8 +2416,8 @@ int redis_zadd_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     // Prefix our key
     zstr = zval_get_string(&z_args[0]);
-    key = zstr->val;
-    key_len = zstr->len;
+    key = ZSTR_VAL(zstr);
+    key_len = ZSTR_LEN(zstr);
     key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Start command construction
@@ -2544,7 +2544,7 @@ static void get_georadius_opts(HashTable *ht, int *withcoord, int *withdist,
         ZVAL_DEREF(optval);
         /* If the key is numeric it's a non value option */
         if (zkey) {
-            if (zkey->len == 5 && !strcasecmp(zkey->val, "count") && Z_TYPE_P(optval) == IS_LONG) {
+            if (ZSTR_LEN(zkey) == 5 && !strcasecmp(ZSTR_VAL(zkey), "count") && Z_TYPE_P(optval) == IS_LONG) {
                 *count = Z_LVAL_P(optval);
             }
         } else {
@@ -2755,8 +2755,8 @@ int redis_migrate_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zstr = zval_get_string(z_keys);
 
         /* We may need to prefix our string */
-        key = zstr->val;
-        keylen = zstr->len;
+        key = ZSTR_VAL(zstr);
+        keylen = ZSTR_LEN(zstr);
         keyfree = redis_key_prefix(redis_sock, &key, &keylen);
 
         /* Add key to migrate */
@@ -2778,8 +2778,8 @@ int redis_migrate_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(z_keys), z_key) {
             zstr = zval_get_string(z_key);
 
-            key = zstr->val;
-            keylen = zstr->len;
+            key = ZSTR_VAL(zstr);
+            keylen = ZSTR_LEN(zstr);
             keyfree = redis_key_prefix(redis_sock, &key, &keylen);
 
             /* Append the key */
@@ -2929,7 +2929,7 @@ int redis_command_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
         ZEND_HASH_FOREACH_VAL(ht_arr, z_ele) {
             zend_string *zstr = zval_get_string(z_ele);
-            redis_cmd_append_sstr(&cmdstr, zstr->val, zstr->len);
+            redis_cmd_append_sstr(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr));
             zend_string_release(zstr);
         } ZEND_HASH_FOREACH_END();
 
diff --git a/redis_session.c b/redis_session.c
index 8a418e3d..fd7a5e2f 100644
--- a/redis_session.c
+++ b/redis_session.c
@@ -348,7 +348,7 @@ PS_READ_FUNC(redis)
 #if (PHP_MAJOR_VERSION < 7)
     redis_pool_member *rpm = redis_pool_get_sock(pool, key TSRMLS_CC);
 #else
-    redis_pool_member *rpm = redis_pool_get_sock(pool, key->val TSRMLS_CC);
+    redis_pool_member *rpm = redis_pool_get_sock(pool, ZSTR_VAL(key) TSRMLS_CC);
 #endif
     RedisSock *redis_sock = rpm?rpm->redis_sock:NULL;
     if(!rpm || !redis_sock){
@@ -359,7 +359,7 @@ PS_READ_FUNC(redis)
 #if (PHP_MAJOR_VERSION < 7)
     resp = redis_session_key(rpm, key, strlen(key), &resp_len);
 #else
-    resp = redis_session_key(rpm, key->val, key->len, &resp_len);
+    resp = redis_session_key(rpm, ZSTR_VAL(key), ZSTR_LEN(key), &resp_len);
 #endif
     cmd_len = REDIS_SPPRINTF(&cmd, "GET", "s", resp, resp_len);
 
@@ -408,7 +408,7 @@ PS_WRITE_FUNC(redis)
 #if (PHP_MAJOR_VERSION < 7)
     redis_pool_member *rpm = redis_pool_get_sock(pool, key TSRMLS_CC);
 #else
-    redis_pool_member *rpm = redis_pool_get_sock(pool, key->val TSRMLS_CC);
+    redis_pool_member *rpm = redis_pool_get_sock(pool, ZSTR_VAL(key) TSRMLS_CC);
 #endif
     RedisSock *redis_sock = rpm?rpm->redis_sock:NULL;
     if(!rpm || !redis_sock){
@@ -421,10 +421,10 @@ PS_WRITE_FUNC(redis)
     cmd_len = REDIS_SPPRINTF(&cmd, "SETEX", "sds", session, session_len,
                              INI_INT("session.gc_maxlifetime"), val, vallen);
 #else
-    session = redis_session_key(rpm, key->val, key->len, &session_len);
+    session = redis_session_key(rpm, ZSTR_VAL(key), ZSTR_LEN(key), &session_len);
     cmd_len = REDIS_SPPRINTF(&cmd, "SETEX", "sds", session, session_len,
-                             INI_INT("session.gc_maxlifetime"), val->val,
-                             val->len);
+                             INI_INT("session.gc_maxlifetime"),
+                             ZSTR_VAL(val), ZSTR_LEN(val));
 #endif
     efree(session);
     if(redis_sock_write(redis_sock, cmd, cmd_len TSRMLS_CC) < 0) {
@@ -459,7 +459,7 @@ PS_DESTROY_FUNC(redis)
 #if (PHP_MAJOR_VERSION < 7)
     redis_pool_member *rpm = redis_pool_get_sock(pool, key TSRMLS_CC);
 #else
-    redis_pool_member *rpm = redis_pool_get_sock(pool, key->val TSRMLS_CC);
+    redis_pool_member *rpm = redis_pool_get_sock(pool, ZSTR_VAL(key) TSRMLS_CC);
 #endif
     RedisSock *redis_sock = rpm?rpm->redis_sock:NULL;
     if(!rpm || !redis_sock){
@@ -470,7 +470,7 @@ PS_DESTROY_FUNC(redis)
 #if (PHP_MAJOR_VERSION < 7)
     session = redis_session_key(rpm, key, strlen(key), &session_len);
 #else
-    session = redis_session_key(rpm, key->val, key->len, &session_len);
+    session = redis_session_key(rpm, ZSTR_VAL(key), ZSTR_LEN(key), &session_len);
 #endif
     cmd_len = REDIS_SPPRINTF(&cmd, "DEL", "s", session, session_len);
     efree(session);
@@ -653,7 +653,7 @@ PS_READ_FUNC(rediscluster) {
 #if (PHP_MAJOR_VERSION < 7)
     skey = cluster_session_key(c, key, strlen(key), &skeylen, &slot);
 #else
-    skey = cluster_session_key(c, key->val, key->len, &skeylen, &slot);
+    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);
@@ -715,10 +715,10 @@ PS_WRITE_FUNC(rediscluster) {
                             skeylen, INI_INT("session.gc_maxlifetime"), val,
                             vallen);
 #else
-    skey = cluster_session_key(c, key->val, key->len, &skeylen, &slot);
+    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"),
-                            val->val, val->len);
+                            ZSTR_VAL(val), ZSTR_LEN(val));
 #endif
     efree(skey);
 
@@ -758,7 +758,7 @@ PS_DESTROY_FUNC(rediscluster) {
 #if (PHP_MAJOR_VERSION < 7)
     skey = cluster_session_key(c, key, strlen(key), &skeylen, &slot);
 #else
-    skey = cluster_session_key(c, key->val, key->len, &skeylen, &slot);
+    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);