Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 04a7327

Browse files
yatsukhnenkoyatsukhnenko
committed
WIP: php7 compatibility
1 parent a3799e5 commit 04a7327

5 files changed

Lines changed: 112 additions & 139 deletions

File tree

‎common.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -237,6 +237,7 @@ inline_call_user_function(HashTable *function_table, zval *object, zval *functio
237237
_params = ecalloc(param_count, sizeof(zval *));
238238
for (i = 0; i < param_count; i++) {
239239
_params[i] = &params[i];
240+
INIT_PZVAL(_params[i]);
240241
}
241242
}
242243
ret = _call_user_function(function_table, &object, function_name, retval_ptr, param_count, _params TSRMLS_CC);

‎redis.c‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1019,8 +1019,7 @@ PHP_METHOD(Redis, getMultiple)
10191019
key = Z_STRVAL_P(z_ele);
10201020
key_len = Z_STRLEN_P(z_ele);
10211021
} else {
1022-
z_tmp = *z_ele;
1023-
zval_copy_ctor(&z_tmp);
1022+
ZVAL_ZVAL(&z_tmp, z_ele, 1, 0);
10241023
convert_to_string(&z_tmp);
10251024

10261025
key = Z_STRVAL(z_tmp);

‎redis_array.c‎

Lines changed: 62 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -109,8 +109,7 @@ static void redis_array_free(RedisArray *ra) {
109109
}
110110

111111
/* Delete pur commands */
112-
zval_dtor(ra->z_pure_cmds);
113-
efree(ra->z_pure_cmds);
112+
zval_dtor(&ra->z_pure_cmds);
114113

115114
/* Free structure itself */
116115
efree(ra);
@@ -383,7 +382,6 @@ ra_forward_call(INTERNAL_FUNCTION_PARAMETERS, RedisArray *ra, const char *cmd, i
383382
/* copy args to array */
384383
i = 0;
385384
ZEND_HASH_FOREACH_VAL(h_args, zp_tmp) {
386-
INIT_ZVAL(z_callargs[i]);
387385
z_callargs[i] = *zp_tmp;
388386
i++;
389387
} ZEND_HASH_FOREACH_END();
@@ -437,7 +435,7 @@ PHP_METHOD(RedisArray, __call)
437435
zval *z_args;
438436

439437
char *cmd;
440-
int cmd_len;
438+
size_t cmd_len;
441439

442440
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osa",
443441
&object, redis_array_ce, &cmd, &cmd_len, &z_args) == FAILURE) {
@@ -834,7 +832,7 @@ PHP_METHOD(RedisArray, select)
834832
/* MGET will distribute the call to several nodes and regroup the values. */
835833
PHP_METHOD(RedisArray, mget)
836834
{
837-
zval *object, *z_keys, z_fun, *z_argarray, *data, *z_ret, *z_cur, *z_tmp_array, *z_tmp;
835+
zval *object, *z_keys, z_fun, z_argarray, *data, z_ret, *z_cur, z_tmp_array, *z_tmp;
838836
int i, j, n;
839837
RedisArray *ra;
840838
int *pos, argc, *argc_each;
@@ -899,79 +897,81 @@ PHP_METHOD(RedisArray, mget)
899897
argv[i++] = data;
900898
} ZEND_HASH_FOREACH_END();
901899

902-
/* prepare return value */
903-
array_init(return_value);
904-
MAKE_STD_ZVAL(z_tmp_array);
905-
array_init(z_tmp_array);
906-
900+
array_init(&z_tmp_array);
907901
/* calls */
908902
for(n = 0; n < ra->count; ++n) { /* for each node */
909903
/* We don't even need to make a call to this node if no keys go there */
910904
if(!argc_each[n]) continue;
911905

912906
/* copy args for MGET call on node. */
913-
MAKE_STD_ZVAL(z_argarray);
914-
array_init(z_argarray);
907+
array_init(&z_argarray);
915908

916909
for(i = 0; i < argc; ++i) {
917910
if(pos[i] != n) continue;
918911

912+
#if (PHP_MAJOR_VERSION < 7)
919913
MAKE_STD_ZVAL(z_tmp);
920-
*z_tmp = *argv[i];
921-
zval_copy_ctor(z_tmp);
922-
INIT_PZVAL(z_tmp);
923-
add_next_index_zval(z_argarray, z_tmp);
914+
#else
915+
zval zv;
916+
z_tmp = &zv;
917+
#endif
918+
ZVAL_ZVAL(z_tmp, argv[i], 1, 0);
919+
add_next_index_zval(&z_argarray, z_tmp);
924920
}
925921

926922
/* call MGET on the node */
927-
MAKE_STD_ZVAL(z_ret);
928-
call_user_function(&redis_ce->function_table, &ra->redis[n], &z_fun, z_ret, 1, z_argarray);
923+
call_user_function(&redis_ce->function_table, &ra->redis[n], &z_fun, &z_ret, 1, &z_argarray);
929924

930925
/* cleanup args array */
931-
zval_ptr_dtor(&z_argarray);
926+
zval_dtor(&z_argarray);
927+
928+
/* Error out if we didn't get a proper response */
929+
if (Z_TYPE(z_ret) != IS_ARRAY) {
930+
/* cleanup */
931+
zval_dtor(&z_ret);
932+
zval_dtor(&z_tmp_array);
933+
zval_dtor(&z_fun);
934+
efree(pos);
935+
efree(argc_each);
936+
937+
/* failure */
938+
RETURN_FALSE;
939+
}
932940

933941
for(i = 0, j = 0; i < argc; ++i) {
934-
/* Error out if we didn't get a proper response */
935-
if(Z_TYPE_P(z_ret) != IS_ARRAY) {
936-
/* cleanup */
937-
zval_dtor(z_ret);
938-
efree(z_ret);
939-
zval_ptr_dtor(&z_tmp_array);
940-
zval_dtor(&z_fun);
941-
efree(pos);
942-
efree(argc_each);
943-
944-
/* failure */
945-
RETURN_FALSE;
946-
}
947-
948942
if(pos[i] != n) continue;
949943

950-
z_cur = zend_hash_index_find(Z_ARRVAL_P(z_ret), j++);
944+
z_cur = zend_hash_index_find(Z_ARRVAL(z_ret), j++);
951945

946+
#if (PHP_MAJOR_VERSION < 7)
952947
MAKE_STD_ZVAL(z_tmp);
953-
*z_tmp = *z_cur;
954-
zval_copy_ctor(z_tmp);
955-
INIT_PZVAL(z_tmp);
956-
add_index_zval(z_tmp_array, i, z_tmp);
948+
#else
949+
zval zv;
950+
z_tmp = &zv;
951+
#endif
952+
ZVAL_ZVAL(z_tmp, z_cur, 1, 0);
953+
add_index_zval(&z_tmp_array, i, z_tmp);
957954
}
958-
zval_dtor(z_ret);
959-
efree(z_ret);
955+
zval_dtor(&z_ret);
960956
}
961957

958+
array_init(return_value);
962959
/* copy temp array in the right order to return_value */
963960
for(i = 0; i < argc; ++i) {
964-
z_cur = zend_hash_index_find(Z_ARRVAL_P(z_tmp_array), i);
961+
z_cur = zend_hash_index_find(Z_ARRVAL(z_tmp_array), i);
965962

963+
#if (PHP_MAJOR_VERSION < 7)
966964
MAKE_STD_ZVAL(z_tmp);
967-
*z_tmp = *z_cur;
968-
zval_copy_ctor(z_tmp);
969-
INIT_PZVAL(z_tmp);
965+
#else
966+
zval zv;
967+
z_tmp = &zv;
968+
#endif
969+
ZVAL_ZVAL(z_tmp, z_cur, 1, 0);
970970
add_next_index_zval(return_value, z_tmp);
971971
}
972972

973973
/* cleanup */
974-
zval_ptr_dtor(&z_tmp_array);
974+
zval_dtor(&z_tmp_array);
975975
zval_dtor(&z_fun);
976976
efree(argv);
977977
efree(pos);
@@ -982,12 +982,11 @@ PHP_METHOD(RedisArray, mget)
982982
/* MSET will distribute the call to several nodes and regroup the values. */
983983
PHP_METHOD(RedisArray, mset)
984984
{
985-
zval *object, *z_keys, z_fun, *z_argarray, *data, z_ret;
985+
zval *object, *z_keys, z_fun, z_argarray, *data, z_ret, **argv;
986986
int i, n;
987987
RedisArray *ra;
988988
int *pos, argc, *argc_each;
989989
HashTable *h_keys;
990-
zval *redis_inst, **argv;
991990
char *key, **keys, kbuf[40];
992991
int key_len, *key_lens;
993992
zend_string *zkey;
@@ -1024,7 +1023,7 @@ PHP_METHOD(RedisArray, mset)
10241023
key_len = zkey->len;
10251024
key = zkey->val;
10261025
} else {
1027-
key_len = snprintf(kbuf, sizeof(kbuf), "%ld", (long)idx);
1026+
key_len = snprintf(kbuf, sizeof(kbuf), "%lu", idx);
10281027
key = kbuf;
10291028
}
10301029

@@ -1044,48 +1043,44 @@ PHP_METHOD(RedisArray, mset)
10441043
int found = 0;
10451044

10461045
/* copy args */
1047-
MAKE_STD_ZVAL(z_argarray);
1048-
array_init(z_argarray);
1046+
array_init(&z_argarray);
10491047
for(i = 0; i < argc; ++i) {
1050-
zval *z_tmp;
1051-
10521048
if(pos[i] != n) continue;
1053-
1054-
ALLOC_ZVAL(z_tmp);
1055-
*z_tmp = *argv[i];
1056-
zval_copy_ctor(z_tmp);
1057-
INIT_PZVAL(z_tmp);
1058-
1059-
add_assoc_zval_ex(z_argarray, keys[i], key_lens[i], z_tmp);
1049+
#if (PHP_MAJOR_VERSION < 7)
1050+
zval *z_tmp;
1051+
MAKE_STD_ZVAL(z_tmp);
1052+
#else
1053+
zval zv, *z_tmp = &zv;
1054+
#endif
1055+
ZVAL_ZVAL(z_tmp, argv[i], 1, 0);
1056+
add_assoc_zval_ex(&z_argarray, keys[i], key_lens[i], z_tmp);
10601057
found++;
10611058
}
10621059

10631060
if(!found)
10641061
{
1065-
zval_dtor(z_argarray);
1066-
efree(z_argarray);
1062+
zval_dtor(&z_argarray);
10671063
continue; /* don't run empty MSETs */
10681064
}
10691065

10701066
/* prepare call */
10711067
ZVAL_STRINGL(&z_fun, "MSET", 4);
1072-
redis_inst = &ra->redis[n];
10731068
if(ra->index) { /* add MULTI */
1074-
ra_index_multi(redis_inst, MULTI TSRMLS_CC);
1069+
ra_index_multi(&ra->redis[n], MULTI TSRMLS_CC);
10751070
}
10761071

10771072
/* call */
1078-
call_user_function(&redis_ce->function_table, redis_inst, &z_fun, &z_ret, 1, z_argarray);
1073+
call_user_function(&redis_ce->function_table, &ra->redis[n], &z_fun, &z_ret, 1, &z_argarray);
10791074

10801075
if(ra->index) {
1081-
ra_index_keys(z_argarray, redis_inst TSRMLS_CC); /* use SADD to add keys to node index */
1082-
ra_index_exec(redis_inst, NULL, 0 TSRMLS_CC); /* run EXEC */
1076+
ra_index_keys(&z_argarray, &ra->redis[n] TSRMLS_CC); /* use SADD to add keys to node index */
1077+
ra_index_exec(&ra->redis[n], NULL, 0 TSRMLS_CC); /* run EXEC */
10831078
}
10841079

10851080
zval_dtor(&z_fun);
10861081
zval_dtor(&z_ret);
10871082

1088-
zval_ptr_dtor(&z_argarray);
1083+
zval_dtor(&z_argarray);
10891084
}
10901085

10911086
/* Free any keys that we needed to allocate memory for, because they weren't strings */

‎redis_array.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ typedef struct RedisArray_ {
5050
zend_bool pconnect; /* should we use pconnect */
5151
zval *z_fun; /* key extractor, callable */
5252
zval *z_dist; /* key distributor, callable */
53-
zval *z_pure_cmds; /* hash table */
53+
zval z_pure_cmds; /* hash table */
5454
double connect_timeout; /* socket connect timeout */
5555

5656
struct RedisArray_ *prev;

0 commit comments

Comments
 (0)