Added ZRANGE and ZREVRANGE

Implemented ZRANGE and ZREVRANGE for both Redis and cluster.
We can't use generic command processing here as the return type
depends on the optional WITHSCORES bit.

In addition, switched the code around such that zReverseRange is
an alias of zRevRange because ZREVRANGE is the actual Redis
command name.

6 files changed, 123 insertions, 90 deletions

diff --git a/php_redis.h b/php_redis.h
index 2c35c822..428440e8 100644
--- a/php_redis.h
+++ b/php_redis.h
@@ -108,7 +108,7 @@ PHP_METHOD(Redis, move);
 PHP_METHOD(Redis, zAdd);
 PHP_METHOD(Redis, zDelete);
 PHP_METHOD(Redis, zRange);
-PHP_METHOD(Redis, zReverseRange);
+PHP_METHOD(Redis, zRevRange);
 PHP_METHOD(Redis, zRangeByScore);
 PHP_METHOD(Redis, zRangeByLex);
 PHP_METHOD(Redis, zRevRangeByScore);
diff --git a/redis.c b/redis.c
index 769b991b..48dc900f 100644
--- a/redis.c
+++ b/redis.c
@@ -193,7 +193,7 @@ static zend_function_entry redis_functions[] = {
      PHP_ME(Redis, zAdd, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, zDelete, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, zRange, NULL, ZEND_ACC_PUBLIC)
-     PHP_ME(Redis, zReverseRange, NULL, ZEND_ACC_PUBLIC)
+     PHP_ME(Redis, zRevRange, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, zRangeByScore, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, zRevRangeByScore, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, zRangeByLex, NULL, ZEND_ACC_PUBLIC)
@@ -323,7 +323,7 @@ static zend_function_entry redis_functions[] = {
      PHP_MALIAS(Redis, scard, sSize, NULL, ZEND_ACC_PUBLIC)
      PHP_MALIAS(Redis, srem, sRemove, NULL, ZEND_ACC_PUBLIC)
      PHP_MALIAS(Redis, sismember, sContains, NULL, ZEND_ACC_PUBLIC)
-     PHP_MALIAS(Redis, zrevrange, zReverseRange, NULL, ZEND_ACC_PUBLIC)
+     PHP_MALIAS(Redis, zReverseRange, zRevRange, NULL, ZEND_ACC_PUBLIC)
 
      PHP_MALIAS(Redis, sendEcho, echo, NULL, ZEND_ACC_PUBLIC)
 
@@ -2596,53 +2596,55 @@ PHP_METHOD(Redis, zAdd) {
 	REDIS_PROCESS_RESPONSE(redis_long_response);
 }
 /* }}} */
-/* {{{ proto array Redis::zRange(string key, int start , int end, bool withscores = FALSE)
- */
-PHP_METHOD(Redis, zRange)
-{
-    zval *object;
+
+/* Handle ZRANGE and ZREVRANGE as they're the same except for keyword */
+static void generic_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw) {
+    char *cmd;
+    int cmd_len;
     RedisSock *redis_sock;
-    char *key = NULL, *cmd;
-    int key_len, cmd_len, key_free;
-    long start, end;
-    long withscores = 0;
+    zend_bool withscores=0;
 
-    if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osll|b",
-                                     &object, redis_ce,
-                                     &key, &key_len, &start, &end, &withscores) == FAILURE) {
+    if(redis_sock_get(getThis(), &redis_sock TSRMLS_CC, 0)<0) {
         RETURN_FALSE;
     }
 
-    if (redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {
+    if(redis_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, kw, &cmd,
+                        &cmd_len, &withscores, NULL, NULL)==FAILURE)
+    {
         RETURN_FALSE;
     }
 
-	key_free = redis_key_prefix(redis_sock, &key, &key_len);
-    if(withscores) {
-        cmd_len = redis_cmd_format_static(&cmd, "ZRANGE", "sdds", key,
-                                          key_len, start, end, "WITHSCORES", 10);
-    } else {
-        cmd_len = redis_cmd_format_static(&cmd, "ZRANGE", "sdd", key,
-                                          key_len, start, end);
-    }
-	if(key_free) efree(key);
-
-	REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);
+    REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);
     if(withscores) {
-            IF_ATOMIC() {
-                redis_mbulk_reply_zipped_keys_dbl(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);
-            }
-            REDIS_PROCESS_RESPONSE(redis_mbulk_reply_zipped_keys_dbl);
+        IF_ATOMIC() {
+            redis_sock_read_multibulk_reply_zipped(
+                INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);
+        }
+        REDIS_PROCESS_RESPONSE(redis_sock_read_multibulk_reply_zipped);
     } else {
-            IF_ATOMIC() {
-                if (redis_sock_read_multibulk_reply(INTERNAL_FUNCTION_PARAM_PASSTHRU,
-                                                    redis_sock, NULL, NULL) < 0) {
-                    RETURN_FALSE;
-                }
+        IF_ATOMIC() {
+            if(redis_sock_read_multibulk_reply(INTERNAL_FUNCTION_PARAM_PASSTHRU,
+                                               redis_sock, NULL, NULL)<0)
+            {
+                RETURN_FALSE;
             }
-            REDIS_PROCESS_RESPONSE(redis_sock_read_multibulk_reply);
+        }
+        REDIS_PROCESS_RESPONSE(redis_sock_read_multibulk_reply);
     }
 }
+
+/* {{{ proto array Redis::zRange(string key,int start,int end,bool scores=0) */
+PHP_METHOD(Redis, zRange)
+{
+    generic_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "ZRANGE");
+}
+
+/* {{{ proto array Redis::zRevRange(string k, long s, long e, bool scores=0) */
+PHP_METHOD(Redis, zRevRange) {
+    generic_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "ZREVRANGE");
+}
+/* }}} */
+
 /* }}} */
 /* {{{ proto long Redis::zDelete(string key, string member)
  */
@@ -2679,57 +2681,7 @@ PHP_METHOD(Redis, zDeleteRangeByRank)
 }
 /* }}} */
 
-/* {{{ proto array Redis::zReverseRange(string key, int start , int end, bool withscores = FALSE)
- */
-PHP_METHOD(Redis, zReverseRange)
-{
-    zval *object;
-    RedisSock *redis_sock;
-    char *key = NULL, *cmd;
-    int key_len, cmd_len, key_free;
-    long start, end;
-    long withscores = 0;
-
-    if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osll|b",
-                                     &object, redis_ce,
-                                     &key, &key_len, &start, &end, &withscores) == FAILURE) {
-        RETURN_FALSE;
-    }
-
-    if (redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {
-        RETURN_FALSE;
-    }
-
-	key_free = redis_key_prefix(redis_sock, &key, &key_len);
-    if(withscores) {
-        cmd_len = redis_cmd_format_static(&cmd, "ZREVRANGE", "sdds",
-                                          key, key_len, start, end, "WITHSCORES",
-                                          10);
-    } else {
-        cmd_len = redis_cmd_format_static(&cmd, "ZREVRANGE", "sdd",
-                                          key, key_len, start, end);
-    }
-	if(key_free) efree(key);
-
-    REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);
-    if(withscores) {
-    	IF_ATOMIC() {
-            redis_mbulk_reply_zipped_keys_dbl(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);
-    	}
-        REDIS_PROCESS_RESPONSE(redis_mbulk_reply_zipped_keys_dbl);
-    } else {
-    	IF_ATOMIC() {
-            if (redis_sock_read_multibulk_reply(INTERNAL_FUNCTION_PARAM_PASSTHRU,
-                                                redis_sock, NULL, NULL) < 0) {
-                RETURN_FALSE;
-            }
-    	}
-    	REDIS_PROCESS_RESPONSE(redis_sock_read_multibulk_reply);
-    }
-}
-/* }}} */
-
-PHP_REDIS_API void
+PHPAPI void
 redis_generic_zrange_by_score(INTERNAL_FUNCTION_PARAMETERS, char *keyword) {
 
     zval *object, *z_options = NULL, **z_limit_val_pp = NULL, **z_withscores_val_pp = NULL;
diff --git a/redis_cluster.c b/redis_cluster.c
index 8321a8be..6640047d 100644
--- a/redis_cluster.c
+++ b/redis_cluster.c
@@ -112,6 +112,8 @@ zend_function_entry redis_cluster_functions[] = {
     PHP_ME(RedisCluster, setrange, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, restore, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, smove, NULL, ZEND_ACC_PUBLIC)
+    PHP_ME(RedisCluster, zrange, NULL, ZEND_ACC_PUBLIC)
+    PHP_ME(RedisCluster, zrevrange, NULL, ZEND_ACC_PUBLIC)
     {NULL, NULL, NULL}
 };
 
@@ -732,4 +734,46 @@ PHP_METHOD(RedisCluster, setrange) {
 }
 /* }}} */
 
+/* Generic implementation for both ZRANGE and ZREVRANGE */
+static void generic_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw) {
+    redisCluster *c = GET_CONTEXT();
+    char *cmd; int cmd_len; short slot; 
+    zend_bool withscores;
+
+    if(redis_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, c->flags, kw, &cmd,
+                        &cmd_len, &withscores, &slot, NULL)==FAILURE)
+    {
+        efree(cmd);
+        RETURN_FALSE;
+    }
+
+    if(cluster_send_command(c,slot,cmd,cmd_len TSRMLS_CC)<0 || c->err!=NULL) {
+        efree(cmd);
+        RETURN_FALSE;
+    }
+
+    efree(cmd);
+
+    // Response type differs if we use WITHSCORES or not
+    if(!withscores) {
+        cluster_mbulk_resp(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, NULL);
+    } else {
+        cluster_mbulk_zipdbl_resp(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, NULL);
+    }
+}
+
+/* {{{ proto 
+ *     array RedisCluster::zrange(string k, long s, long e, bool score=0) */
+PHP_METHOD(RedisCluster, zrange) {
+    generic_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "ZRANGE");
+}
+/* }}} */
+
+/* {{{ proto 
+ *     array RedisCluster::zrevrange(string k,long s,long e,bool scores=0) */
+PHP_METHOD(RedisCluster, zrevrange) {
+    generic_zrange_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "ZREVRANGE");
+}
+/* }}} */
+
 /* vim: set tabstop=4 softtabstops=4 noexpandtab shiftwidth=4: */
diff --git a/redis_cluster.h b/redis_cluster.h
index c2016c2f..cecf8b02 100644
--- a/redis_cluster.h
+++ b/redis_cluster.h
@@ -136,4 +136,6 @@ PHP_METHOD(RedisCluster, pfmerge);
 PHP_METHOD(RedisCluster, restore);
 PHP_METHOD(RedisCluster, setrange);
 PHP_METHOD(RedisCluster, smove);
+PHP_METHOD(RedisCluster, zrange);
+PHP_METHOD(RedisCluster, zrevrange);
 #endif
diff --git a/redis_commands.c b/redis_commands.c
index 156e0256..928c019a 100644
--- a/redis_commands.c
+++ b/redis_commands.c
@@ -372,6 +372,40 @@ int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     return SUCCESS;
 }
 
+/* ZRANGE/ZREVRANGE */
+int redis_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
+                     char *kw, char **cmd, int *cmd_len, zend_bool *withscores,
+                     short *slot, void **ctx)
+{
+    char *key;
+    int key_len, key_free;
+    long start, end;
+    zend_bool ws;
+
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll|b", &key, &key_len,
+                             &start, &end, &ws)==FAILURE)
+    {
+        return FAILURE;
+    }
+
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
+    if(ws) {
+        *cmd_len = redis_cmd_format_static(cmd, kw, "sdds", key, key_len, start,
+            end, "WITHSCORES", sizeof("WITHSCORES")-1);
+    } else {
+        *cmd_len = redis_cmd_format_static(cmd, kw, "sdd", key, key_len, start,
+            end);
+    }
+
+    CMD_SET_SLOT(slot, key, key_len);
+
+    // Free key, push out WITHSCORES option
+    if(key_free) efree(key);
+    *withscores = ws;
+
+    return SUCCESS;
+}
+
 /* Commands with specific signatures or that need unique functions because they
  * have specific processing (argument validation, etc) that make them unique */
 
diff --git a/redis_commands.h b/redis_commands.h
index 006d4a79..03e245bb 100644
--- a/redis_commands.h
+++ b/redis_commands.h
@@ -49,8 +49,9 @@ int redis_key_str_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *kw, char **cmd, int *cmd_len, short *slot, void **ctx);
 
-int redis_ss_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
-    char *kw, char **cmd, int *cmd_len, short *slot, void **ctx);
+int redis_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
+    char *kw, char **cmd, int *cmd_len, zend_bool *withscores, short *slot, 
+    void **ctx);
 
 /* Commands which need a unique construction mechanism.  This is either because
  * they don't share a signature with any other command, or because there is