← Back to branch summary

~alexlawn/php-redis/alex-redis-hmget

« back to all changes in this revision

Viewing changes to redis_array_impl.c

  • Committer: GitHub
  • Author(s): Pavlo Yatsukhnenko
  • Date: 2016-09-13 19:06:47 UTC
  • mfrom: (532.1.1)
  • Revision ID: git-v1:28184c76b61a853219850e0c7564b2c23fe56299
Merge pull request #945 from yatsukhnenko/develop

WIP: php7 compatibility

Show diffs side-by-side

added added

removed removed

Lines of Context:
redis_array_impl.c
35
35
        int i = 0, host_len, id;
36
36
        char *host, *p;
37
37
        short port;
38
 
        zval **zpData, z_cons, z_ret;
 
38
        zval *zpData, z_cons, z_ret;
39
39
        RedisSock *redis_sock  = NULL;
40
40
 
41
41
        /* function calls on the Redis object */
44
44
        /* init connections */
45
45
        for (zend_hash_internal_pointer_reset(hosts); zend_hash_has_more_elements(hosts) == SUCCESS; zend_hash_move_forward(hosts))
46
46
        {
47
 
                if ((zend_hash_get_current_data(hosts, (void **) &zpData) == FAILURE) || (Z_TYPE_PP(zpData) != IS_STRING))
 
47
                if ((zpData = zend_hash_get_current_data(hosts)) == NULL || Z_TYPE_P(zpData) != IS_STRING)
48
48
                {
49
49
                        for(i=0;i<ra->count;i++) {
50
50
                                zval_dtor(ra->redis[i]);
59
59
                        return NULL;
60
60
                }
61
61
 
62
 
                ra->hosts[i] = estrdup(Z_STRVAL_PP(zpData));
 
62
                ra->hosts[i] = estrdup(Z_STRVAL_P(zpData));
63
63
 
64
64
                /* default values */
65
 
                host = Z_STRVAL_PP(zpData);
66
 
                host_len = Z_STRLEN_PP(zpData);
 
65
                host = Z_STRVAL_P(zpData);
 
66
                host_len = Z_STRLEN_P(zpData);
67
67
                port = 6379;
68
68
 
69
69
                if((p = strrchr(host, ':'))) { /* found port */
766
766
 
767
767
        int i;
768
768
        zval z_fun_type, z_ret, *z_arg;
769
 
        zval **z_data;
 
769
        zval *z_data;
770
770
        long success = 1;
771
771
 
772
772
        MAKE_STD_ZVAL(z_arg);
795
795
                                zend_hash_has_more_elements(retHash) == SUCCESS;
796
796
                                zend_hash_move_forward(retHash)) {
797
797
 
798
 
                        if(zend_hash_get_current_data(retHash, (void**)&z_data) == FAILURE) {
799
 
                                success = 0;
800
 
                                break;
801
 
                        }
802
 
                        if(Z_TYPE_PP(z_data) != IS_LONG) {
 
798
                        if ((z_data = zend_hash_get_current_data(retHash)) == NULL || Z_TYPE_P(z_data) != IS_LONG) {
803
799
                                success = 0;
804
800
                                break;
805
801
                        }
806
802
                        /* Get the result - Might change in the future to handle doubles as well */
807
 
                        res[i] = Z_LVAL_PP(z_data);
808
 
                        i++;
 
803
                        res[i++] = Z_LVAL_P(z_data);
809
804
                }
810
805
        }
811
806
        zval_dtor(&z_ret);
883
878
static zend_bool
884
879
ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
885
880
 
886
 
        zval z_fun_zrange, z_fun_zadd, z_ret, z_ret_dest, *z_args[4], **z_zadd_args, **z_score_pp;
 
881
        zval z_fun_zrange, z_fun_zadd, z_ret, z_ret_dest, *z_args[4], **z_zadd_args, *z_score_p;
887
882
        int count;
888
883
        HashTable *h_zset_vals;
889
884
        char *val;
923
918
                        zend_hash_has_more_elements(h_zset_vals) == SUCCESS;
924
919
                        zend_hash_move_forward(h_zset_vals)) {
925
920
 
926
 
                if(zend_hash_get_current_data(h_zset_vals, (void**)&z_score_pp) == FAILURE) {
 
921
                if ((z_score_p = zend_hash_get_current_data(h_zset_vals)) == NULL) {
927
922
                        continue;
928
923
                }
929
924
 
930
925
                /* add score */
931
 
                convert_to_double(*z_score_pp);
 
926
                convert_to_double(z_score_p);
932
927
                MAKE_STD_ZVAL(z_zadd_args[i]);
933
 
                ZVAL_DOUBLE(z_zadd_args[i], Z_DVAL_PP(z_score_pp));
 
928
                ZVAL_DOUBLE(z_zadd_args[i], Z_DVAL_P(z_score_p));
934
929
 
935
930
                /* add value */
936
931
                MAKE_STD_ZVAL(z_zadd_args[i+1]);
1056
1051
                int list_count, const char **cmd_list,
1057
1052
                int add_count, const char **cmd_add, long ttl TSRMLS_DC) {
1058
1053
 
1059
 
        zval z_fun_retrieve, z_fun_sadd, z_ret, **z_retrieve_args, **z_sadd_args, **z_data_pp;
 
1054
        zval z_fun_retrieve, z_fun_sadd, z_ret, **z_retrieve_args, **z_sadd_args, *z_data_p;
1060
1055
        int count, i;
1061
1056
        HashTable *h_set_vals;
1062
1057
 
1099
1094
                        zend_hash_has_more_elements(h_set_vals) == SUCCESS;
1100
1095
                        zend_hash_move_forward(h_set_vals), i++) {
1101
1096
 
1102
 
                if(zend_hash_get_current_data(h_set_vals, (void**)&z_data_pp) == FAILURE) {
 
1097
                if ((z_data_p = zend_hash_get_current_data(h_set_vals)) == NULL) {
1103
1098
                        continue;
1104
1099
                }
1105
1100
 
1106
1101
                /* add set elements */
1107
1102
                MAKE_STD_ZVAL(z_sadd_args[i+1]);
1108
 
                *(z_sadd_args[i+1]) = **z_data_pp;
 
1103
                *(z_sadd_args[i+1]) = *z_data_p;
1109
1104
                zval_copy_ctor(z_sadd_args[i+1]);
1110
1105
        }
1111
1106