ZEND_HASH_FOREACH_VAL macro

Author: yatsukhnenko

common.h

@@ -1,10 +1,29 @@
 #include "php.h"
 #include "php_ini.h"
-#include <ext/standard/php_smart_string.h>
 
 #ifndef REDIS_COMMON_H
 #define REDIS_COMMON_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)
+
+#define ZEND_HASH_FOREACH_VAL(ht, _val) do { \
+    HashPosition _hpos; \
+    for (zend_hash_internal_pointer_reset_ex(ht, &_hpos); \
+         zend_hash_get_current_data_ex(ht, (void **) &_val, &_hpos) == SUCCESS; \
+         zend_hash_move_forward_ex(ht, &_hpos) \
+    )
+
+#define ZEND_HASH_FOREACH_END() } while(0)
+#else
+#include <ext/standard/php_smart_string.h>
+#endif
+
 /* NULL check so Eclipse doesn't go crazy */
 #ifndef NULL
 #define NULL   ((void *) 0)
@@ -101,7 +120,7 @@ typedef enum _PUBSUB_TYPE {
 #define IF_NOT_MULTI() if(redis_sock->mode != MULTI)
 #define IF_NOT_ATOMIC() if(redis_sock->mode != ATOMIC)
 #define IF_ATOMIC() if(redis_sock->mode == ATOMIC)
-#define ELSE_IF_MULTI() else if(redis_sock->mode == MULTI) { \
+#define ELSE_IF_MULTI() else IF_MULTI() { \
     if(redis_response_enqueued(redis_sock TSRMLS_CC) == 1) { \
         RETURN_ZVAL(getThis(), 1, 0);\
     } else { \
@@ -161,7 +180,7 @@ typedef enum _PUBSUB_TYPE {
 }
 
 #define REDIS_ELSE_IF_MULTI(function, closure_context) \
-    else if(redis_sock->mode == MULTI) { \
+    else IF_MULTI() { \
         if(redis_response_enqueued(redis_sock TSRMLS_CC) == 1) {\
             REDIS_SAVE_CALLBACK(function, closure_context); \
             RETURN_ZVAL(getThis(), 1, 0);\
@@ -177,14 +196,12 @@ typedef enum _PUBSUB_TYPE {
 }
 
 #define REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len) \
-    IF_MULTI_OR_ATOMIC() { \
-        SOCKET_WRITE_COMMAND(redis_sock, cmd, cmd_len); \
-        efree(cmd); \
-    }\
     IF_PIPELINE() { \
         PIPELINE_ENQUEUE_COMMAND(cmd, cmd_len); \
-        efree(cmd); \
-    }
+    } else { \
+        SOCKET_WRITE_COMMAND(redis_sock, cmd, cmd_len); \
+    } \
+    efree(cmd);
 
 #define REDIS_PROCESS_RESPONSE_CLOSURE(function, closure_context) \
     REDIS_ELSE_IF_MULTI(function, closure_context) \

library.c

@@ -8,7 +8,6 @@
 #include <netinet/tcp.h>  /* TCP_NODELAY */
 #include <sys/socket.h>
 #endif
-#include <ext/standard/php_smart_string.h>
 #include <ext/standard/php_var.h>
 #include <zend_smart_str.h>
 #ifdef HAVE_REDIS_IGBINARY

library.h

@@ -73,11 +73,6 @@ 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 *return_value TSRMLS_DC);
 
-PHP_REDIS_API void redis_free_socket(RedisSock *redis_sock);
-PHP_REDIS_API void redis_send_discard(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock);
-PHP_REDIS_API int redis_sock_set_err(RedisSock *redis_sock, const char *msg, int msg_len);
-
-
 /*
 * Variant Read methods, mostly to implement eval
 */

redis.c

@@ -37,7 +37,6 @@
 #include "ext/session/php_session.h"
 #endif
 
-#include <ext/standard/php_smart_string.h>
 #include <ext/standard/php_var.h>
 #include <ext/standard/php_math.h>
 
@@ -674,7 +673,7 @@ PHP_METHOD(Redis,__destruct) {
     }
 
     // If we think we're in MULTI mode, send a discard
-    if(redis_sock->mode == MULTI) {
+    IF_MULTI() {
         // Discard any multi commands, and free any callbacks that have been
         // queued
         send_discard_static(redis_sock TSRMLS_CC);
@@ -952,7 +951,6 @@ PHP_METHOD(Redis, getMultiple)
 {
     zval *object, *z_args, *z_ele;
     HashTable *hash;
-    HashPosition ptr;
     RedisSock *redis_sock;
     smart_string cmd = {0};
     int arg_count;
@@ -980,10 +978,7 @@ PHP_METHOD(Redis, getMultiple)
     redis_cmd_init_sstr(&cmd, arg_count, "MGET", 4);
 
     /* Iterate through and grab our keys */
-    for(zend_hash_internal_pointer_reset_ex(hash, &ptr);
-        (z_ele = zend_hash_get_current_data_ex(hash, &ptr)) != NULL;
-        zend_hash_move_forward_ex(hash, &ptr))
-    {
+    ZEND_HASH_FOREACH_VAL(hash, z_ele) {
         char *key;
         int key_free;
         size_t key_len;
@@ -1005,7 +1000,7 @@ PHP_METHOD(Redis, getMultiple)
 
         /* Decrement refcount/free temporary string. */
         zend_string_release(key_zstr);
-    }
+    } ZEND_HASH_FOREACH_END();
 
     /* Kick off our command */
     REDIS_PROCESS_REQUEST(redis_sock, cmd.c, cmd.len);
@@ -2518,7 +2513,6 @@ PHP_REDIS_API void generic_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS,
 {
     zval *object, *array, *data;
     HashTable *arr_hash;
-    HashPosition pointer;
     RedisSock *redis_sock;
     char *cmd = "", *old_cmd = NULL;
     int cmd_len, array_count;
@@ -2541,10 +2535,7 @@ PHP_REDIS_API void generic_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS,
         RETURN_FALSE;
     }
 
-    for (zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
-         (data = zend_hash_get_current_data_ex(arr_hash, &pointer)) != NULL;
-         zend_hash_move_forward_ex(arr_hash, &pointer)) {
-
+    ZEND_HASH_FOREACH_VAL(arr_hash, data) {
         if (Z_TYPE_P(data) == IS_STRING) {
             char *old_cmd = NULL;
             if(*cmd) {
@@ -2555,7 +2546,7 @@ PHP_REDIS_API void generic_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS,
                 efree(old_cmd);
             }
         }
-    }
+    } ZEND_HASH_FOREACH_END();
 
     old_cmd = cmd;
     cmd_len = spprintf(&cmd, 0, "%s %s\r\n", unsub_cmd, cmd);
@@ -2905,10 +2896,7 @@ redis_build_pubsub_cmd(RedisSock *redis_sock, char **ret, PUBSUB_TYPE type,
         redis_cmd_append_sstr(&cmd, "NUMSUB", sizeof("NUMSUB")-1);
 
         /* Iterate our elements */
-        for(zend_hash_internal_pointer_reset_ex(ht_chan, &ptr);
-            (z_ele = zend_hash_get_current_data_ex(ht_chan, &ptr)) != NULL;
-            zend_hash_move_forward_ex(ht_chan, &ptr))
-        {
+        ZEND_HASH_FOREACH_VAL(ht_chan, z_ele) {
             char *key;
             int key_free;
             size_t key_len;
@@ -2928,7 +2916,7 @@ redis_build_pubsub_cmd(RedisSock *redis_sock, char **ret, PUBSUB_TYPE type,
 
             /* Decrement reference count to temporary/underlying zend_string */
             zend_string_release(key_zstr);
-        }
+        } ZEND_HASH_FOREACH_END();
 
         /* Set return */
         *ret = cmd.c;
@@ -3026,7 +3014,6 @@ redis_build_eval_cmd(RedisSock *redis_sock, char **ret, char *keyword,
 {
     zval *elem;
     HashTable *args_hash;
-    HashPosition hash_pos;
     int cmd_len, args_count = 0;
     int eval_cmd_count = 2;
 
@@ -3049,10 +3036,7 @@ redis_build_eval_cmd(RedisSock *redis_sock, char **ret, char *keyword,
             cmd_len = redis_cmd_append_int(ret, cmd_len, keys_count);
 
             // Iterate the values in our "keys" array
-            for(zend_hash_internal_pointer_reset_ex(args_hash, &hash_pos);
-                (elem = zend_hash_get_current_data_ex(args_hash, &hash_pos)) != NULL;
-                zend_hash_move_forward_ex(args_hash, &hash_pos))
-            {
+            ZEND_HASH_FOREACH_VAL(args_hash, elem) {
                 char *key, *old_cmd;
                 int key_free;
                 size_t key_len;
@@ -3079,7 +3063,7 @@ redis_build_eval_cmd(RedisSock *redis_sock, char **ret, char *keyword,
 
                 // Free our temporary string if we created one (or decrement refcount)
                 zend_string_release(key_zstr);
-            }
+            } ZEND_HASH_FOREACH_END();
         }
     }
 

redis_array.c

@@ -340,7 +340,6 @@ ra_forward_call(INTERNAL_FUNCTION_PARAMETERS, RedisArray *ra, const char *cmd, i
     int i;
     zval *redis_inst;
     zval z_fun, *z_callargs;
-    HashPosition pointer;
     HashTable *h_args;
 
     int argc;
@@ -378,12 +377,11 @@ ra_forward_call(INTERNAL_FUNCTION_PARAMETERS, RedisArray *ra, const char *cmd, i
     z_callargs = emalloc(argc * sizeof(zval));
 
     /* copy args to array */
-    for (i = 0, zend_hash_internal_pointer_reset_ex(h_args, &pointer);
-            (zp_tmp = zend_hash_get_current_data_ex(h_args, &pointer)) != NULL;
-            ++i, zend_hash_move_forward_ex(h_args, &pointer))
-    {
+	i = 0;
+	ZEND_HASH_FOREACH_VAL(h_args, zp_tmp) {
         ZVAL_DUP(&z_callargs[i], zp_tmp);
-    }
+		i++;
+    } ZEND_HASH_FOREACH_END();
 
     /* multi/exec */
     if(ra->z_multi_exec) {
@@ -831,7 +829,6 @@ PHP_METHOD(RedisArray, mget)
     RedisArray *ra;
     int *pos, argc, *argc_each;
     HashTable *h_keys;
-    HashPosition pointer;
     zval **redis_instances, **argv;
 
     /* Multi/exec support */
@@ -861,10 +858,8 @@ PHP_METHOD(RedisArray, mget)
     memset(argc_each, 0, ra->count * sizeof(int));
 
     /* associate each key to a redis node */
-    for (i = 0, zend_hash_internal_pointer_reset_ex(h_keys, &pointer);
-            (data = zend_hash_get_current_data_ex(h_keys, &pointer)) != NULL;
-            zend_hash_move_forward_ex(h_keys, &pointer), ++i)
-    {
+	i = 0;
+	ZEND_HASH_FOREACH_VAL(h_keys, data) {
         /* If we need to represent a long key as a string */
         unsigned int key_len;
         char kbuf[40], *key_lookup;
@@ -893,7 +888,8 @@ PHP_METHOD(RedisArray, mget)
 
         argc_each[pos[i]]++;    /* count number of keys per node */
         argv[i] = data;
-    }
+		i++;
+    } ZEND_HASH_FOREACH_END();
 
     /* prepare return value */
     array_init(return_value);
@@ -1113,7 +1109,6 @@ PHP_METHOD(RedisArray, del)
     RedisArray *ra;
     int *pos, argc, *argc_each;
     HashTable *h_keys;
-    HashPosition pointer;
     zval *redis_inst, **redis_instances, **argv;;
     long total = 0;
     int free_zkeys = 0;
@@ -1163,10 +1158,8 @@ PHP_METHOD(RedisArray, del)
     memset(argc_each, 0, ra->count * sizeof(int));
 
     /* associate each key to a redis node */
-    for (i = 0, zend_hash_internal_pointer_reset_ex(h_keys, &pointer);
-            (data = zend_hash_get_current_data_ex(h_keys, &pointer)) != NULL;
-            zend_hash_move_forward_ex(h_keys, &pointer), ++i) {
-
+	i = 0;
+	ZEND_HASH_FOREACH_VAL(h_keys, data) {
         if (Z_TYPE_P(data) != IS_STRING) {
             php_error_docref(NULL TSRMLS_CC, E_ERROR, "DEL: all keys must be string.");
             efree(pos);
@@ -1176,7 +1169,8 @@ PHP_METHOD(RedisArray, del)
         redis_instances[i] = ra_find_node(ra, Z_STRVAL_P(data), Z_STRLEN_P(data), &pos[i] TSRMLS_CC);
         argc_each[pos[i]]++;    /* count number of keys per node */
         argv[i] = data;
-    }
+		i++;
+    } ZEND_HASH_FOREACH_END();
 
     /* calls */
     for(n = 0; n < ra->count; ++n) { /* for each node */

redis_array_impl.c

@@ -718,17 +718,16 @@ ra_rehash_scan(zval *z_redis, char ***keys, int **key_lens, const char *cmd, con
     *keys = emalloc(count * sizeof(char*));
     *key_lens = emalloc(count * sizeof(int));
 
-    for (i = 0, zend_hash_internal_pointer_reset_ex(h_keys, &pointer);
-            (z_data_p = zend_hash_get_current_data_ex(h_keys, &pointer)) != NULL;
-            zend_hash_move_forward_ex(h_keys, &pointer), ++i) {
-
+    i = 0;
+    ZEND_HASH_FOREACH_VAL(h_keys, z_data_p) {
         key = Z_STRVAL_P(z_data_p);
         key_len = Z_STRLEN_P(z_data_p);
 
         /* copy key and length */
         (*keys)[i] = estrndup(key, key_len);
         (*key_lens)[i] = key_len;
-    }
+        i++;
+    } ZEND_HASH_FOREACH_END();
 
     /* cleanup */
     zval_dtor(&z_fun_smembers);

redis_cluster.c

@@ -1830,7 +1830,6 @@ static void cluster_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
     size_t lua_len, key_len;
     zval *z_arr=NULL, *z_ele;
     HashTable *ht_arr;
-    HashPosition ptr;
     zend_long num_keys = 0;
     short slot;
     smart_string cmdstr = {0};
@@ -1855,10 +1854,7 @@ static void cluster_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
 
     // Iterate over our args if we have any
     if(args_count > 0) {
-        for(zend_hash_internal_pointer_reset_ex(ht_arr, &ptr);
-            (z_ele = zend_hash_get_current_data_ex(ht_arr, &ptr)) != NULL;
-            zend_hash_move_forward_ex(ht_arr, &ptr))
-        {
+		ZEND_HASH_FOREACH_VAL(ht_arr, z_ele) {
             convert_to_string(z_ele);
             key = Z_STRVAL_P(z_ele);
             key_len = Z_STRLEN_P(z_ele);
@@ -1885,7 +1881,7 @@ static void cluster_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
 
             /* Free key if we prefixed */
             if(key_free) efree(key);
-        }
+        } ZEND_HASH_FOREACH_END();
     } else {
         /* Pick a slot at random, we're being told there are no keys */
         slot = rand() % REDIS_CLUSTER_MOD;