cleanup TSRMLS_* usage

1 files changed, 102 insertions, 102 deletions

diff --git a/cluster_library.c b/cluster_library.c
index a9205cf6..767e95b0 100644
--- a/cluster_library.c
+++ b/cluster_library.c
@@ -114,7 +114,7 @@ void cluster_free_reply(clusterReply *reply, int free_data) {
 static void
 cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
                                  clusterReply **element, int status_strings,
-                                 int *err TSRMLS_DC)
+                                 int *err)
 {
     int i;
     size_t sz;
@@ -126,7 +126,7 @@ cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
         r = element[i] = ecalloc(1, sizeof(clusterReply));
 
         // Bomb out, flag error condition on a communication failure
-        if (redis_read_reply_type(sock, &r->type, &len TSRMLS_CC) < 0) {
+        if (redis_read_reply_type(sock, &r->type, &len) < 0) {
             *err = 1;
             return;
         }
@@ -137,7 +137,7 @@ cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
         switch(r->type) {
             case TYPE_ERR:
             case TYPE_LINE:
-                if (redis_sock_gets(sock,buf,sizeof(buf),&sz TSRMLS_CC) < 0) {
+                if (redis_sock_gets(sock,buf,sizeof(buf),&sz) < 0) {
                     *err = 1;
                     return;
                 }
@@ -149,7 +149,7 @@ cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
                 break;
             case TYPE_BULK:
                 if (r->len >= 0) {
-                    r->str = redis_sock_read_bulk_reply(sock,r->len TSRMLS_CC);
+                    r->str = redis_sock_read_bulk_reply(sock,r->len);
                     if (!r->str) {
                         *err = 1;
                         return;
@@ -162,7 +162,7 @@ cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
                     if (r->len > 0) {
                         r->element = ecalloc(r->len,sizeof(clusterReply*));
                         cluster_multibulk_resp_recursive(sock, r->elements, r->element,
-                            status_strings, err TSRMLS_CC);
+                            status_strings, err);
                     }
                     if (*err) return;
                 }
@@ -197,17 +197,17 @@ static RedisSock *cluster_slot_sock(redisCluster *c, unsigned short slot,
 }
 
 /* Read the response from a cluster */
-clusterReply *cluster_read_resp(redisCluster *c, int status_strings TSRMLS_DC) {
+clusterReply *cluster_read_resp(redisCluster *c, int status_strings) {
     return cluster_read_sock_resp(c->cmd_sock, c->reply_type,
                                   status_strings ? c->line_reply : NULL,
-                                  c->reply_len TSRMLS_CC);
+                                  c->reply_len);
 }
 
 /* Read any sort of response from the socket, having already issued the
  * command and consumed the reply type and meta info (length) */
 clusterReply*
 cluster_read_sock_resp(RedisSock *redis_sock, REDIS_REPLY_TYPE type,
-                       char *line_reply, size_t len TSRMLS_DC)
+                       char *line_reply, size_t len)
 {
     clusterReply *r;
 
@@ -230,7 +230,7 @@ cluster_read_sock_resp(RedisSock *redis_sock, REDIS_REPLY_TYPE type,
             return r;
         case TYPE_BULK:
             r->len = len;
-            r->str = redis_sock_read_bulk_reply(redis_sock, len TSRMLS_CC);
+            r->str = redis_sock_read_bulk_reply(redis_sock, len);
             if (r->len != -1 && !r->str) {
                 cluster_free_reply(r, 1);
                 return NULL;
@@ -241,7 +241,7 @@ cluster_read_sock_resp(RedisSock *redis_sock, REDIS_REPLY_TYPE type,
             if (len != (size_t)-1) {
                 r->element = ecalloc(len, sizeof(clusterReply*)*len);
                 cluster_multibulk_resp_recursive(redis_sock, len, r->element,
-                                                 line_reply != NULL, &err TSRMLS_CC);
+                                                 line_reply != NULL, &err);
             }
             break;
         default:
@@ -261,10 +261,10 @@ cluster_read_sock_resp(RedisSock *redis_sock, REDIS_REPLY_TYPE type,
 
 /* Helper to open connection and send AUTH if necessary */
 static zend_always_inline int
-cluster_sock_open(RedisSock *redis_sock TSRMLS_DC)
+cluster_sock_open(RedisSock *redis_sock)
 {
     zend_bool need_auth = (redis_sock->auth && redis_sock->status != REDIS_SOCK_STATUS_CONNECTED);
-    if (!redis_sock_server_open(redis_sock TSRMLS_CC) && (!need_auth || !redis_sock_auth(redis_sock TSRMLS_CC))) {
+    if (!redis_sock_server_open(redis_sock) && (!need_auth || !redis_sock_auth(redis_sock ))) {
         return SUCCESS;
     }
     return FAILURE;
@@ -277,7 +277,7 @@ cluster_sock_open(RedisSock *redis_sock TSRMLS_DC)
 
 /* Send a command to the specific socket and validate reply type */
 static int cluster_send_direct(RedisSock *redis_sock, char *cmd, int cmd_len,
-                               REDIS_REPLY_TYPE type TSRMLS_DC)
+                               REDIS_REPLY_TYPE type)
 {
     char buf[1024];
 
@@ -290,15 +290,15 @@ static int cluster_send_direct(RedisSock *redis_sock, char *cmd, int cmd_len,
     return 0;
 }
 
-static int cluster_send_asking(RedisSock *redis_sock TSRMLS_DC) {
+static int cluster_send_asking(RedisSock *redis_sock) {
     return cluster_send_direct(redis_sock, RESP_ASKING_CMD,
-        sizeof(RESP_ASKING_CMD)-1, TYPE_LINE TSRMLS_CC);
+        sizeof(RESP_ASKING_CMD)-1, TYPE_LINE);
 }
 
 /* Send READONLY to a specific RedisSock unless it's already flagged as being
  * in READONLY mode.  If we can send the command, we flag the socket as being
  * in that mode. */
-static int cluster_send_readonly(RedisSock *redis_sock TSRMLS_DC) {
+static int cluster_send_readonly(RedisSock *redis_sock) {
     int ret;
 
     /* We don't have to do anything if we're already in readonly mode */
@@ -306,7 +306,7 @@ static int cluster_send_readonly(RedisSock *redis_sock TSRMLS_DC) {
 
     /* Return success if we can send it */
     ret = cluster_send_direct(redis_sock, RESP_READONLY_CMD,
-        sizeof(RESP_READONLY_CMD) - 1, TYPE_LINE TSRMLS_CC);
+        sizeof(RESP_READONLY_CMD) - 1, TYPE_LINE);
 
     /* Flag this socket as READONLY if our command worked */
     redis_sock->readonly = !ret;
@@ -316,9 +316,9 @@ static int cluster_send_readonly(RedisSock *redis_sock TSRMLS_DC) {
 }
 
 /* Send MULTI to a specific ReidsSock */
-static int cluster_send_multi(redisCluster *c, short slot TSRMLS_DC) {
+static int cluster_send_multi(redisCluster *c, short slot) {
     if (cluster_send_direct(SLOT_SOCK(c,slot), RESP_MULTI_CMD,
-        sizeof(RESP_MULTI_CMD) - 1, TYPE_LINE TSRMLS_CC) == 0)
+        sizeof(RESP_MULTI_CMD) - 1, TYPE_LINE) == 0)
     {
         c->cmd_sock->mode = MULTI;
         return 0;
@@ -330,12 +330,12 @@ static int cluster_send_multi(redisCluster *c, short slot TSRMLS_DC) {
  * here because we know we'll only have sent MULTI to the master nodes.  We can't
  * failover inside a transaction, as we don't know if the transaction will only
  * be readonly commands, or contain write commands as well */
-PHP_REDIS_API int cluster_send_exec(redisCluster *c, short slot TSRMLS_DC) {
+PHP_REDIS_API int cluster_send_exec(redisCluster *c, short slot) {
     int retval;
 
     /* Send exec */
     retval = cluster_send_slot(c, slot, RESP_EXEC_CMD, sizeof(RESP_EXEC_CMD)-1,
-        TYPE_MULTIBULK TSRMLS_CC);
+        TYPE_MULTIBULK);
 
     /* We'll either get a length corresponding to the number of commands sent to
      * this node, or -1 in the case of EXECABORT or WATCH failure. */
@@ -345,9 +345,9 @@ PHP_REDIS_API int cluster_send_exec(redisCluster *c, short slot TSRMLS_DC) {
     return retval;
 }
 
-PHP_REDIS_API int cluster_send_discard(redisCluster *c, short slot TSRMLS_DC) {
+PHP_REDIS_API int cluster_send_discard(redisCluster *c, short slot) {
     if (cluster_send_direct(SLOT_SOCK(c,slot), RESP_DISCARD_CMD,
-        sizeof(RESP_DISCARD_CMD)-1, TYPE_LINE TSRMLS_CC))
+        sizeof(RESP_DISCARD_CMD)-1, TYPE_LINE))
     {
         return 0;
     }
@@ -464,14 +464,14 @@ int cluster_dist_add_key(redisCluster *c, HashTable *ht, char *key,
 
 /* Provided a clusterKeyVal, add a value */
 void cluster_dist_add_val(redisCluster *c, clusterKeyVal *kv, zval *z_val
-                         TSRMLS_DC)
+                        )
 {
     char *val;
     size_t val_len;
     int val_free;
 
     // Serialize our value
-    val_free = redis_pack(c->flags, z_val, &val, &val_len TSRMLS_CC);
+    val_free = redis_pack(c->flags, z_val, &val, &val_len);
 
     // Attach it to the provied keyval entry
     kv->val = val;
@@ -613,7 +613,7 @@ static void fyshuffle(int *array, size_t len) {
 
 /* Execute a CLUSTER SLOTS command against the seed socket, and return the
  * reply or NULL on failure. */
-clusterReply* cluster_get_slots(RedisSock *redis_sock TSRMLS_DC)
+clusterReply* cluster_get_slots(RedisSock *redis_sock)
 {
     clusterReply *r;
     REDIS_REPLY_TYPE type;
@@ -621,14 +621,14 @@ clusterReply* cluster_get_slots(RedisSock *redis_sock TSRMLS_DC)
 
     // Send the command to the socket and consume reply type
     if (redis_sock_write(redis_sock, RESP_CLUSTER_SLOTS_CMD,
-                        sizeof(RESP_CLUSTER_SLOTS_CMD)-1 TSRMLS_CC) < 0 ||
-                        redis_read_reply_type(redis_sock, &type, &len TSRMLS_CC) < 0)
+                        sizeof(RESP_CLUSTER_SLOTS_CMD)-1) < 0 ||
+                        redis_read_reply_type(redis_sock, &type, &len) < 0)
     {
         return NULL;
     }
 
     // Consume the rest of our response
-    if ((r = cluster_read_sock_resp(redis_sock, type, NULL, len TSRMLS_CC)) == NULL ||
+    if ((r = cluster_read_sock_resp(redis_sock, type, NULL, len)) == NULL ||
        r->type != TYPE_MULTIBULK || r->elements < 1)
     {
         if (r) cluster_free_reply(r, 1);
@@ -774,7 +774,7 @@ PHP_REDIS_API void cluster_free_node(redisClusterNode *node) {
 }
 
 /* Get or create a redisClusterNode that corresponds to the asking redirection */
-static redisClusterNode *cluster_get_asking_node(redisCluster *c TSRMLS_DC) {
+static redisClusterNode *cluster_get_asking_node(redisCluster *c) {
     redisClusterNode *pNode;
     char key[1024];
     int key_len;
@@ -797,8 +797,8 @@ static redisClusterNode *cluster_get_asking_node(redisCluster *c TSRMLS_DC) {
 
 /* Get or create a node at the host:port we were asked to check, and return the
  * redis_sock for it. */
-static RedisSock *cluster_get_asking_sock(redisCluster *c TSRMLS_DC) {
-    return cluster_get_asking_node(c TSRMLS_CC)->sock;
+static RedisSock *cluster_get_asking_sock(redisCluster *c) {
+    return cluster_get_asking_node(c)->sock;
 }
 
 /* Our context seeds will be a hash table with RedisSock* pointers */
@@ -865,10 +865,10 @@ PHP_REDIS_API redisCluster *cluster_create(double timeout, double read_timeout,
 }
 
 PHP_REDIS_API void
-cluster_free(redisCluster *c, int free_ctx TSRMLS_DC)
+cluster_free(redisCluster *c, int free_ctx)
 {
     /* Disconnect from each node we're connected to */
-    cluster_disconnect(c, 0 TSRMLS_CC);
+    cluster_disconnect(c, 0);
 
     /* Free any allocated prefix */
     if (c->flags->prefix) zend_string_release(c->flags->prefix);
@@ -1116,7 +1116,7 @@ cluster_init_seeds(redisCluster *cluster, HashTable *ht_seeds) {
 }
 
 /* Initial mapping of our cluster keyspace */
-PHP_REDIS_API int cluster_map_keyspace(redisCluster *c TSRMLS_DC) {
+PHP_REDIS_API int cluster_map_keyspace(redisCluster *c) {
     RedisSock *seed;
     clusterReply *slots = NULL;
     int mapped = 0;
@@ -1124,12 +1124,12 @@ PHP_REDIS_API int cluster_map_keyspace(redisCluster *c TSRMLS_DC) {
     // Iterate over seeds until we can get slots
     ZEND_HASH_FOREACH_PTR(c->seeds, seed) {
         // Attempt to connect to this seed node
-        if (seed == NULL || cluster_sock_open(seed TSRMLS_CC) != 0) {
+        if (seed == NULL || cluster_sock_open(seed) != 0) {
             continue;
         }
 
         // Parse out cluster nodes.  Flag mapped if we are valid
-        slots = cluster_get_slots(seed TSRMLS_CC);
+        slots = cluster_get_slots(seed);
         if (slots) {
             mapped = !cluster_map_slots(c, slots);
             // Bin anything mapped, if we failed somewhere
@@ -1137,7 +1137,7 @@ PHP_REDIS_API int cluster_map_keyspace(redisCluster *c TSRMLS_DC) {
                 memset(c->master, 0, sizeof(redisClusterNode*)*REDIS_CLUSTER_SLOTS);
             }
         }
-        redis_sock_disconnect(seed, 0 TSRMLS_CC);
+        redis_sock_disconnect(seed, 0);
         if (mapped) break;
     } ZEND_HASH_FOREACH_END();
 
@@ -1193,7 +1193,7 @@ static int cluster_set_redirection(redisCluster* c, char *msg, int moved)
  * This function will return -1 on a critical error (e.g. parse/communication
  * error, 0 if no redirection was encountered, and 1 if the data was moved. */
 static int cluster_check_response(redisCluster *c, REDIS_REPLY_TYPE *reply_type
-                                  TSRMLS_DC)
+                                 )
 {
     size_t sz;
 
@@ -1201,7 +1201,7 @@ static int cluster_check_response(redisCluster *c, REDIS_REPLY_TYPE *reply_type
     CLUSTER_CLEAR_ERROR(c);
     CLUSTER_CLEAR_REPLY(c);
 
-    if (-1 == redis_check_eof(c->cmd_sock, 1 TSRMLS_CC) ||
+    if (-1 == redis_check_eof(c->cmd_sock, 1) ||
        EOF == (*reply_type = php_stream_getc(c->cmd_sock->stream)))
     {
         return -1;
@@ -1237,7 +1237,7 @@ static int cluster_check_response(redisCluster *c, REDIS_REPLY_TYPE *reply_type
 
     // Fetch the first line of our response from Redis.
     if (redis_sock_gets(c->cmd_sock,c->line_reply,sizeof(c->line_reply),
-                       &sz TSRMLS_CC) < 0)
+                       &sz) < 0)
     {
         return -1;
     }
@@ -1255,20 +1255,20 @@ static int cluster_check_response(redisCluster *c, REDIS_REPLY_TYPE *reply_type
 }
 
 /* Disconnect from each node we're connected to */
-PHP_REDIS_API void cluster_disconnect(redisCluster *c, int force TSRMLS_DC) {
+PHP_REDIS_API void cluster_disconnect(redisCluster *c, int force) {
     redisClusterNode *node, *slave;
 
     ZEND_HASH_FOREACH_PTR(c->nodes, node) {
         if (node == NULL) continue;
 
         /* Disconnect from the master */
-        redis_sock_disconnect(node->sock, force TSRMLS_CC);
+        redis_sock_disconnect(node->sock, force);
 
         /* We also want to disconnect any slave connections so they will be pooled
          * in the event we are using persistent connections and connection pooling. */
         if (node->slaves) {
             ZEND_HASH_FOREACH_PTR(node->slaves, slave) {
-                redis_sock_disconnect(slave->sock, force TSRMLS_CC);
+                redis_sock_disconnect(slave->sock, force);
             } ZEND_HASH_FOREACH_END();
         }
     } ZEND_HASH_FOREACH_END();
@@ -1277,7 +1277,7 @@ PHP_REDIS_API void cluster_disconnect(redisCluster *c, int force TSRMLS_DC) {
 /* This method attempts to write our command at random to the master and any
  * attached slaves, until we either successufly do so, or fail. */
 static int cluster_dist_write(redisCluster *c, const char *cmd, size_t sz,
-                              int nomaster TSRMLS_DC)
+                              int nomaster)
 {
     int i, count = 1, *nodes;
     RedisSock *redis_sock;
@@ -1308,7 +1308,7 @@ static int cluster_dist_write(redisCluster *c, const char *cmd, size_t sz,
         /* If we're not on the master, attempt to send the READONLY command to
          * this slave, and skip it if that fails */
         if (nodes[i] == 0 || redis_sock->readonly ||
-            cluster_send_readonly(redis_sock TSRMLS_CC) == 0)
+            cluster_send_readonly(redis_sock) == 0)
         {
             /* Attempt to send the command */
             if (CLUSTER_SEND_PAYLOAD(redis_sock, cmd, sz)) {
@@ -1350,7 +1350,7 @@ static int cluster_dist_write(redisCluster *c, const char *cmd, size_t sz,
  * ASKING redirection, such that the keyspace can be updated.
 */
 static int cluster_sock_write(redisCluster *c, const char *cmd, size_t sz,
-                              int direct TSRMLS_DC)
+                              int direct)
 {
     redisClusterNode *seed_node;
     RedisSock *redis_sock;
@@ -1366,8 +1366,8 @@ static int cluster_sock_write(redisCluster *c, const char *cmd, size_t sz,
     /* If in ASK redirection, get/create the node for that host:port, otherwise
      * just use the command socket. */
     if (c->redir_type == REDIR_ASK) {
-        redis_sock = cluster_get_asking_sock(c TSRMLS_CC);
-        if (cluster_send_asking(redis_sock TSRMLS_CC) < 0) {
+        redis_sock = cluster_get_asking_sock(c);
+        if (cluster_send_asking(redis_sock) < 0) {
             return -1;
         }
     }
@@ -1383,12 +1383,12 @@ static int cluster_sock_write(redisCluster *c, const char *cmd, size_t sz,
     } else if (failover == REDIS_FAILOVER_ERROR) {
         /* Try the master, then fall back to any slaves we may have */
         if (CLUSTER_SEND_PAYLOAD(redis_sock, cmd, sz) ||
-           !cluster_dist_write(c, cmd, sz, 1 TSRMLS_CC)) return 0;
+           !cluster_dist_write(c, cmd, sz, 1)) return 0;
     } else {
         /* Include or exclude master node depending on failover option and
          * attempt to make our write */
         nomaster = failover == REDIS_FAILOVER_DISTRIBUTE_SLAVES;
-        if (!cluster_dist_write(c, cmd, sz, nomaster TSRMLS_CC)) {
+        if (!cluster_dist_write(c, cmd, sz, nomaster)) {
             /* We were able to write to a master or slave at random */
             return 0;
         }
@@ -1428,7 +1428,7 @@ static redisClusterNode *cluster_find_node(redisCluster *c, const char *host,
 
 /* Provided a redisCluster object, the slot where we thought data was and
  * the slot where data was moved, update our node mapping */
-static void cluster_update_slot(redisCluster *c TSRMLS_DC) {
+static void cluster_update_slot(redisCluster *c) {
     redisClusterNode *node;
     char key[1024];
     size_t klen;
@@ -1481,14 +1481,14 @@ static void cluster_update_slot(redisCluster *c TSRMLS_DC) {
 /* Abort any transaction in process, by sending DISCARD to any nodes that
  * have active transactions in progress.  If we can't send DISCARD, we need
  * to disconnect as it would leave us in an undefined state. */
-PHP_REDIS_API int cluster_abort_exec(redisCluster *c TSRMLS_DC) {
+PHP_REDIS_API int cluster_abort_exec(redisCluster *c) {
     clusterFoldItem *fi = c->multi_head;
 
     /* Loop through our fold items */
     while (fi) {
         if (SLOT_SOCK(c,fi->slot)->mode == MULTI) {
-            if (cluster_send_discard(c, fi->slot TSRMLS_CC) < 0) {
-                cluster_disconnect(c, 0 TSRMLS_CC);
+            if (cluster_send_discard(c, fi->slot) < 0) {
+                cluster_disconnect(c, 0);
                 return -1;
             }
             SLOT_SOCK(c,fi->slot)->mode = ATOMIC;
@@ -1527,7 +1527,7 @@ PHP_REDIS_API short cluster_find_slot(redisCluster *c, const char *host,
 
 /* Send a command to a specific slot */
 PHP_REDIS_API int cluster_send_slot(redisCluster *c, short slot, char *cmd,
-                             int cmd_len, REDIS_REPLY_TYPE rtype TSRMLS_DC)
+                             int cmd_len, REDIS_REPLY_TYPE rtype)
 {
     /* Point our cluster to this slot and it's socket */
     c->cmd_slot = slot;
@@ -1536,19 +1536,19 @@ PHP_REDIS_API int cluster_send_slot(redisCluster *c, short slot, char *cmd,
     /* Enable multi mode on this slot if we've been directed to but haven't
      * send it to this node yet */
     if (c->flags->mode == MULTI && c->cmd_sock->mode != MULTI) {
-        if (cluster_send_multi(c, slot TSRMLS_CC) == -1) {
+        if (cluster_send_multi(c, slot) == -1) {
             CLUSTER_THROW_EXCEPTION("Unable to enter MULTI mode on requested slot", 0);
             return -1;
         }
     }
 
     /* Try the slot */
-    if (cluster_sock_write(c, cmd, cmd_len, 1 TSRMLS_CC) == -1) {
+    if (cluster_sock_write(c, cmd, cmd_len, 1) == -1) {
         return -1;
     }
 
     /* Check our response */
-    if (cluster_check_response(c, &c->reply_type TSRMLS_CC) != 0 ||
+    if (cluster_check_response(c, &c->reply_type) != 0 ||
        (rtype != TYPE_EOF && rtype != c->reply_type)) return -1;
 
     /* Success */
@@ -1558,7 +1558,7 @@ PHP_REDIS_API int cluster_send_slot(redisCluster *c, short slot, char *cmd,
 /* Send a command to given slot in our cluster.  If we get a MOVED or ASK error
  * we attempt to send the command to the node as directed. */
 PHP_REDIS_API short cluster_send_command(redisCluster *c, short slot, const char *cmd,
-                                         int cmd_len TSRMLS_DC)
+                                         int cmd_len)
 {
     int resp, timedout = 0;
     long msstart;
@@ -1585,7 +1585,7 @@ PHP_REDIS_API short cluster_send_command(redisCluster *c, short slot, const char
         /* Send MULTI to the socket if we're in MULTI mode but haven't yet */
         if (c->flags->mode == MULTI && CMD_SOCK(c)->mode != MULTI) {
             /* We have to fail if we can't send MULTI to the node */
-            if (cluster_send_multi(c, slot TSRMLS_CC) == -1) {
+            if (cluster_send_multi(c, slot) == -1) {
                 CLUSTER_THROW_EXCEPTION("Unable to enter MULTI mode on requested slot", 0);
                 return -1;
             }
@@ -1593,14 +1593,14 @@ PHP_REDIS_API short cluster_send_command(redisCluster *c, short slot, const char
 
         /* Attempt to deliver our command to the node, and that failing, to any
          * node until we find one that is available. */
-        if (cluster_sock_write(c, cmd, cmd_len, 0 TSRMLS_CC) == -1) {
+        if (cluster_sock_write(c, cmd, cmd_len, 0) == -1) {
             /* We have to abort, as no nodes are reachable */
             CLUSTER_THROW_EXCEPTION("Can't communicate with any node in the cluster", 0);
             return -1;
         }
 
         /* Check response and short-circuit on success or communication error */
-        resp = cluster_check_response(c, &c->reply_type TSRMLS_CC);
+        resp = cluster_check_response(c, &c->reply_type);
         if (resp <= 0) {
             break;
         }
@@ -1615,7 +1615,7 @@ PHP_REDIS_API short cluster_send_command(redisCluster *c, short slot, const char
 
            /* Update mapping if the data has MOVED */
            if (c->redir_type == REDIR_MOVED) {
-               cluster_update_slot(c TSRMLS_CC);
+               cluster_update_slot(c);
                c->cmd_sock = SLOT_SOCK(c, slot);
            }
         }
@@ -1630,7 +1630,7 @@ PHP_REDIS_API short cluster_send_command(redisCluster *c, short slot, const char
         return -1;
     } else if (timedout || resp == -1) {
         // Make sure the socket is reconnected, it such that it is in a clean state
-        redis_sock_disconnect(c->cmd_sock, 1 TSRMLS_CC);
+        redis_sock_disconnect(c->cmd_sock, 1);
 
         if (timedout) {
             CLUSTER_THROW_EXCEPTION(
@@ -1666,7 +1666,7 @@ PHP_REDIS_API void cluster_bulk_raw_resp(INTERNAL_FUNCTION_PARAMETERS,
 
     // Make sure we can read the response
     if (c->reply_type != TYPE_BULK ||
-       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC)) == NULL)
+       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len)) == NULL)
     {
         if (c->flags->mode != MULTI) {
             RETURN_FALSE;
@@ -1707,18 +1707,18 @@ PHP_REDIS_API void cluster_bulk_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster
 
     // Make sure we can read the response
     if (c->reply_type != TYPE_BULK ||
-       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC)) == NULL)
+       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len)) == NULL)
     {
         CLUSTER_RETURN_FALSE(c);
     }
 
     if (CLUSTER_IS_ATOMIC(c)) {
-        if (!redis_unpack(c->flags, resp, c->reply_len, return_value TSRMLS_CC)) {
+        if (!redis_unpack(c->flags, resp, c->reply_len, return_value)) {
             CLUSTER_RETURN_STRING(c, resp, c->reply_len);
         }
     } else {
         zval z_unpacked;
-        if (redis_unpack(c->flags, resp, c->reply_len, &z_unpacked TSRMLS_CC)) {
+        if (redis_unpack(c->flags, resp, c->reply_len, &z_unpacked)) {
             add_next_index_zval(&c->multi_resp, &z_unpacked);
         } else {
             add_next_index_stringl(&c->multi_resp, resp, c->reply_len);
@@ -1736,7 +1736,7 @@ PHP_REDIS_API void cluster_dbl_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
 
     // Make sure we can read the response
     if (c->reply_type != TYPE_BULK ||
-       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC)) == NULL)
+       (resp = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len)) == NULL)
     {
         CLUSTER_RETURN_FALSE(c);
     }
@@ -1915,7 +1915,7 @@ PHP_REDIS_API void cluster_sub_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
         sctx->cb.param_count = tab_idx;
 
         // Execute our callback
-        if (zend_call_function(&(sctx->cb), &(sctx->cb_cache) TSRMLS_CC) !=
+        if (zend_call_function(&(sctx->cb), &(sctx->cb_cache)) !=
                               SUCCESS)
         {
             break;
@@ -2028,7 +2028,7 @@ cluster_variant_resp_generic(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
     int i;
 
     // Make sure we can read it
-    if ((r = cluster_read_resp(c, status_strings TSRMLS_CC)) == NULL) {
+    if ((r = cluster_read_resp(c, status_strings)) == NULL) {
         CLUSTER_RETURN_FALSE(c);
     }
 
@@ -2140,7 +2140,7 @@ 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) {
+        if (cb(c->cmd_sock, &z_result, c->reply_len, ctx) == FAILURE) {
             zval_dtor(&z_result);
             CLUSTER_RETURN_FALSE(c);
         }
@@ -2167,14 +2167,14 @@ PHP_REDIS_API int cluster_scan_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
     }
 
     // Read the BULK size
-    if (cluster_check_response(c, &c->reply_type TSRMLS_CC),0 ||
+    if (cluster_check_response(c, &c->reply_type),0 ||
        c->reply_type != TYPE_BULK)
     {
         return FAILURE;
     }
 
     // Read the iterator
-    if ((pit = redis_sock_read_bulk_reply(c->cmd_sock,c->reply_len TSRMLS_CC)) == NULL)
+    if ((pit = redis_sock_read_bulk_reply(c->cmd_sock,c->reply_len)) == NULL)
     {
         return FAILURE;
     }
@@ -2184,7 +2184,7 @@ PHP_REDIS_API int cluster_scan_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
     efree(pit);
 
     // We'll need another MULTIBULK response for the payload
-    if (cluster_check_response(c, &c->reply_type TSRMLS_CC) < 0)
+    if (cluster_check_response(c, &c->reply_type) < 0)
     {
         return FAILURE;
     }
@@ -2219,7 +2219,7 @@ PHP_REDIS_API void cluster_info_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster
     char *info;
 
     // Read our bulk response
-    if ((info = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC)) == NULL)
+    if ((info = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len)) == NULL)
     {
         CLUSTER_RETURN_FALSE(c);
     }
@@ -2244,7 +2244,7 @@ PHP_REDIS_API void cluster_client_list_resp(INTERNAL_FUNCTION_PARAMETERS, redisC
     zval z_result;
 
     /* Read the bulk response */
-    info = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len TSRMLS_CC);
+    info = redis_sock_read_bulk_reply(c->cmd_sock, c->reply_len);
     if (info == NULL) {
         CLUSTER_RETURN_FALSE(c);
     }
@@ -2270,7 +2270,7 @@ cluster_xrange_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
     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) {
+    if (redis_read_stream_messages(c->cmd_sock, c->reply_len, &z_messages) < 0) {
         zval_dtor(&z_messages);
         CLUSTER_RETURN_FALSE(c);
     }
@@ -2292,7 +2292,7 @@ cluster_xread_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
     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) {
+    if (redis_read_stream_messages_multi(c->cmd_sock, c->reply_len, &z_streams) < 0) {
         zval_dtor(&z_streams);
         CLUSTER_RETURN_FALSE(c);
     }
@@ -2311,7 +2311,7 @@ cluster_xclaim_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, void *ctx) {
 
     array_init(&z_msg);
 
-    if (redis_read_xclaim_response(c->cmd_sock, c->reply_len, &z_msg TSRMLS_CC) < 0) {
+    if (redis_read_xclaim_response(c->cmd_sock, c->reply_len, &z_msg) < 0) {
         zval_dtor(&z_msg);
         CLUSTER_RETURN_FALSE(c);
     }
@@ -2349,7 +2349,7 @@ PHP_REDIS_API zval *cluster_zval_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
     ZVAL_NULL(z_ret);
     // Pull our next response if directed
     if (pull) {
-        if (cluster_check_response(c, &c->reply_type TSRMLS_CC) < 0)
+        if (cluster_check_response(c, &c->reply_type) < 0)
         {
             return NULL;
         }
@@ -2363,7 +2363,7 @@ PHP_REDIS_API zval *cluster_zval_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
     array_init(z_ret);
 
     // Call our callback
-    if (cb(c->cmd_sock, z_ret, c->reply_len, NULL TSRMLS_CC) == FAILURE) {
+    if (cb(c->cmd_sock, z_ret, c->reply_len, NULL) == FAILURE) {
         zval_dtor(z_ret);
         return NULL;
     }
@@ -2388,7 +2388,7 @@ PHP_REDIS_API void cluster_multi_mbulk_resp(INTERNAL_FUNCTION_PARAMETERS,
             c->cmd_slot = fi->slot;
             c->cmd_sock = SLOT_SOCK(c, fi->slot);
 
-            if (cluster_check_response(c, &c->reply_type TSRMLS_CC) < 0) {
+            if (cluster_check_response(c, &c->reply_type) < 0) {
                 zval_dtor(multi_resp);
                 RETURN_FALSE;
             }
@@ -2417,7 +2417,7 @@ PHP_REDIS_API void cluster_mbulk_mget_resp(INTERNAL_FUNCTION_PARAMETERS,
     c->cmd_sock->serializer = c->flags->serializer;
     c->cmd_sock->compression = c->flags->compression;
     short fail = c->reply_type != TYPE_MULTIBULK || c->reply_len == -1 ||
-        mbulk_resp_loop(c->cmd_sock, mctx->z_multi, c->reply_len, NULL TSRMLS_CC) == FAILURE;
+        mbulk_resp_loop(c->cmd_sock, mctx->z_multi, c->reply_len, NULL) == FAILURE;
 
     // If we had a failure, pad results with FALSE to indicate failure.  Non
     // existant keys (e.g. for MGET will come back as NULL)
@@ -2449,7 +2449,7 @@ PHP_REDIS_API void cluster_msetnx_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluste
 
     // Protect against an invalid response type
     if (c->reply_type != TYPE_INT) {
-        php_error_docref(0 TSRMLS_CC, E_WARNING,
+        php_error_docref(0, E_WARNING,
             "Invalid response type for MSETNX");
         while (real_argc--) {
             add_next_index_bool(mctx->z_multi, 0);
@@ -2483,7 +2483,7 @@ PHP_REDIS_API void cluster_del_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *
 
     // If we get an invalid reply, inform the client
     if (c->reply_type != TYPE_INT) {
-        php_error_docref(0 TSRMLS_CC, E_WARNING,
+        php_error_docref(0, E_WARNING,
             "Invalid reply type returned for DEL command");
         efree(mctx);
         return;
@@ -2513,7 +2513,7 @@ PHP_REDIS_API void cluster_mset_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster
     // If we get an invalid reply type something very wrong has happened,
     // and we have to abort.
     if (c->reply_type != TYPE_LINE) {
-        php_error_docref(0 TSRMLS_CC, E_ERROR,
+        php_error_docref(0, E_ERROR,
             "Invalid reply type returned for MSET command");
         zval_dtor(mctx->z_multi);
         efree(mctx->z_multi);
@@ -2584,7 +2584,7 @@ cluster_mbulk_assoc_resp(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
 
 /* MULTI BULK response where we don't touch the values (e.g. KEYS) */
 int mbulk_resp_loop_raw(RedisSock *redis_sock, zval *z_result,
-                        long long count, void *ctx TSRMLS_DC)
+                        long long count, void *ctx)
 {
     char *line;
     int line_len;
@@ -2592,7 +2592,7 @@ int mbulk_resp_loop_raw(RedisSock *redis_sock, zval *z_result,
     // Iterate over the number we have
     while (count--) {
         // Read the line, which should never come back null
-        line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
+        line = redis_sock_read(redis_sock, &line_len);
         if (line == NULL) return FAILURE;
 
         // Add to our result array
@@ -2606,7 +2606,7 @@ int mbulk_resp_loop_raw(RedisSock *redis_sock, zval *z_result,
 
 /* MULTI BULK response where we unserialize everything */
 int mbulk_resp_loop(RedisSock *redis_sock, zval *z_result,
-                    long long count, void *ctx TSRMLS_DC)
+                    long long count, void *ctx)
 {
     char *line;
     int line_len;
@@ -2614,11 +2614,11 @@ int mbulk_resp_loop(RedisSock *redis_sock, zval *z_result,
     /* Iterate over the lines we have to process */
     while (count--) {
         /* Read our line */
-        line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
+        line = redis_sock_read(redis_sock, &line_len);
 
         if (line != NULL) {
             zval z_unpacked;
-            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked)) {
                 add_next_index_zval(z_result, &z_unpacked);
             } else {
                 add_next_index_stringl(z_result, line, line_len);
@@ -2635,7 +2635,7 @@ int mbulk_resp_loop(RedisSock *redis_sock, zval *z_result,
 
 /* MULTI BULK response where we turn key1,value1 into key1=>value1 */
 int mbulk_resp_loop_zipstr(RedisSock *redis_sock, zval *z_result,
-                           long long count, void *ctx TSRMLS_DC)
+                           long long count, void *ctx)
 {
     char *line, *key = NULL;
     int line_len, key_len = 0;
@@ -2649,7 +2649,7 @@ int mbulk_resp_loop_zipstr(RedisSock *redis_sock, zval *z_result,
     // Iterate through our elements
     while (count--) {
         // Grab our line, bomb out on failure
-        line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
+        line = redis_sock_read(redis_sock, &line_len);
         if (!line) return -1;
 
         if (idx++ % 2 == 0) {
@@ -2659,7 +2659,7 @@ int mbulk_resp_loop_zipstr(RedisSock *redis_sock, zval *z_result,
         } else {
             /* Attempt unpacking */
             zval z_unpacked;
-            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked)) {
                 add_assoc_zval(z_result, key, &z_unpacked);
             } else {
                 add_assoc_stringl_ex(z_result, key, key_len, line, line_len);
@@ -2675,7 +2675,7 @@ int mbulk_resp_loop_zipstr(RedisSock *redis_sock, zval *z_result,
 
 /* MULTI BULK loop processor where we expect key,score key, score */
 int mbulk_resp_loop_zipdbl(RedisSock *redis_sock, zval *z_result,
-                           long long count, void *ctx TSRMLS_DC)
+                           long long count, void *ctx)
 {
     char *line, *key = NULL;
     int line_len, key_len = 0;
@@ -2688,14 +2688,14 @@ int mbulk_resp_loop_zipdbl(RedisSock *redis_sock, zval *z_result,
 
     // While we have elements
     while (count--) {
-        line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
+        line = redis_sock_read(redis_sock, &line_len);
         if (line != NULL) {
             if (idx++ % 2 == 0) {
                 key = line;
                 key_len = line_len;
             } else {
                 zval zv, *z = &zv;
-                if (redis_unpack(redis_sock,key,key_len, z TSRMLS_CC)) {
+                if (redis_unpack(redis_sock,key,key_len, z)) {
                     zend_string *zstr = zval_get_string(z);
                     add_assoc_double_ex(z_result, ZSTR_VAL(zstr), ZSTR_LEN(zstr), atof(line));
                     zend_string_release(zstr);
@@ -2716,7 +2716,7 @@ int mbulk_resp_loop_zipdbl(RedisSock *redis_sock, zval *z_result,
 
 /* MULTI BULK where we're passed the keys, and we attach vals */
 int mbulk_resp_loop_assoc(RedisSock *redis_sock, zval *z_result,
-                          long long count, void *ctx TSRMLS_DC)
+                          long long count, void *ctx)
 {
     char *line;
     int line_len,i = 0;
@@ -2725,11 +2725,11 @@ int mbulk_resp_loop_assoc(RedisSock *redis_sock, zval *z_result,
     // Loop while we've got replies
     while (count--) {
         zend_string *zstr = zval_get_string(&z_keys[i]);
-        line = redis_sock_read(redis_sock, &line_len TSRMLS_CC);
+        line = redis_sock_read(redis_sock, &line_len);
 
         if (line != NULL) {
             zval z_unpacked;
-            if (redis_unpack(redis_sock, line, line_len, &z_unpacked TSRMLS_CC)) {
+            if (redis_unpack(redis_sock, line, line_len, &z_unpacked)) {
                 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);