f = (Bucket *) a;
s = (Bucket *) b;
- if (f->nKeyLength == 0) {
- Z_TYPE(first) = IS_LONG;
- Z_LVAL(first) = f->h;
+ if (f->key == NULL) {
+ ZVAL_LONG(&first, f->h);
} else {
- Z_TYPE(first) = IS_STRING;
- Z_STRVAL(first) = (char*)f->arKey;
- Z_STRLEN(first) = f->nKeyLength - 1;
+ ZVAL_STR(&first, f->key);
}
- if (s->nKeyLength == 0) {
- Z_TYPE(second) = IS_LONG;
- Z_LVAL(second) = s->h;
+ if (s->key == 0) {
+ ZVAL_LONG(&second, s->h);
} else {
- Z_TYPE(second) = IS_STRING;
- Z_STRVAL(second) = (char*)s->arKey;
- Z_STRLEN(second) = s->nKeyLength - 1;
+ ZVAL_STR(&second, s->key);
}
if (ARRAYG(compare_func)(&result, &first, &second TSRMLS_CC) == FAILURE) {
static int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */
{
long cnt = 0;
- zval **element;
+ zval *element;
if (Z_TYPE_P(array) == IS_ARRAY) {
if (Z_ARRVAL_P(array)->nApplyCount > 1) {
HashPosition pos;
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **) &element, &pos) == SUCCESS;
+ (element = zend_hash_get_current_data_ex(Z_ARRVAL_P(array), &pos)) != NULL;
zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos)
) {
Z_ARRVAL_P(array)->nApplyCount++;
- cnt += php_count_recursive(*element, COUNT_RECURSIVE TSRMLS_CC);
+ cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC);
Z_ARRVAL_P(array)->nApplyCount--;
}
}
break;
case IS_OBJECT: {
#ifdef HAVE_SPL
- zval *retval;
+ zval retval;
#endif
/* first, we check if the handler is defined */
if (Z_OBJ_HT_P(array)->count_elements) {
return;
}
}
-//???
-#if 0
#ifdef HAVE_SPL
/* if not and the object implements Countable we call its count() method */
if (Z_OBJ_HT_P(array)->get_class_entry && instanceof_function(Z_OBJCE_P(array), spl_ce_Countable TSRMLS_CC)) {
- zend_call_method_with_0_params(&array, NULL, NULL, "count", &retval);
- if (retval) {
+ zend_call_method_with_0_params(array, NULL, NULL, "count", &retval);
+ if (Z_TYPE(retval) != IS_UNDEF) {
convert_to_long_ex(&retval);
- RETVAL_LONG(Z_LVAL_P(retval));
+ RETVAL_LONG(Z_LVAL(retval));
zval_ptr_dtor(&retval);
}
return;
}
-#endif
#endif
}
default:
f = (Bucket *) a;
s = (Bucket *) b;
- first = (zval *) f->xData;
- second = (zval *) s->xData;
+ first = &f->val;
+ second = &s->val;
if (ARRAYG(compare_func)(&result, first, second TSRMLS_CC) == FAILURE) {
return 0;
f = (Bucket *) a;
s = (Bucket *) b;
- fval = (zval *) f->xData;
- sval = (zval *) s->xData;
- first = *fval;
- second = *sval;
+ fval = &f->val;
+ sval = &s->val;
+ ZVAL_COPY_VALUE(&first, fval);
+ ZVAL_COPY_VALUE(&second, sval);
if (Z_TYPE_P(fval) != IS_STRING) {
zval_copy_ctor(&first);
{
Bucket *f;
Bucket *s;
- zval **args[2];
- zval *retval_ptr = NULL;
+ zval args[2];
+ zval retval;
f = (Bucket *) a;
s = (Bucket *) b;
- args[0] = (zval **) &f->xData;
- args[1] = (zval **) &s->xData;
+ ZVAL_COPY_VALUE(&args[0], &f->val);
+ ZVAL_COPY_VALUE(&args[1], &s->val);
BG(user_compare_fci).param_count = 2;
BG(user_compare_fci).params = args;
- BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+ BG(user_compare_fci).retval = &retval;
BG(user_compare_fci).no_separation = 0;
- if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
- long retval;
+ if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+ long ret;
- convert_to_long_ex(&retval_ptr);
- retval = Z_LVAL_P(retval_ptr);
- zval_ptr_dtor(&retval_ptr);
- return retval < 0 ? -1 : retval > 0 ? 1 : 0;
+ convert_to_long_ex(&retval);
+ ret = Z_LVAL(retval);
+ zval_ptr_dtor(&retval);
+ return ret < 0 ? -1 : ret > 0 ? 1 : 0;
} else {
return 0;
}
* comparison. The result of sorting in such case is undefined and the
* function returns FALSE.
*/
- Z_UNSET_ISREF_P(array);
+//??? Z_UNSET_ISREF_P(array);
refcount = Z_REFCOUNT_P(array);
if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_compare, 1 TSRMLS_CC) == FAILURE) {
}
if (Z_REFCOUNT_P(array) > 1) {
- Z_SET_ISREF_P(array);
+//??? Z_SET_ISREF_P(array);
}
PHP_ARRAY_CMP_FUNC_RESTORE();
* comparison. The result of sorting in such case is undefined and the
* function returns FALSE.
*/
- Z_UNSET_ISREF_P(array);
+//??? Z_UNSET_ISREF_P(array);
refcount = Z_REFCOUNT_P(array);
if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_compare, 0 TSRMLS_CC) == FAILURE) {
}
if (Z_REFCOUNT_P(array) > 1) {
- Z_SET_ISREF_P(array);
+//??? Z_SET_ISREF_P(array);
}
PHP_ARRAY_CMP_FUNC_RESTORE();
{
Bucket *f;
Bucket *s;
- zval *key1, *key2;
- zval **args[2];
- zval *retval_ptr = NULL;
+ zval args[2];
+ zval retval;
long result;
- ALLOC_INIT_ZVAL(key1);
- ALLOC_INIT_ZVAL(key2);
- args[0] = &key1;
- args[1] = &key2;
+ ZVAL_NULL(&args[0]);
+ ZVAL_NULL(&args[1]);
f = (Bucket *) a;
s = (Bucket *) b;
- if (f->nKeyLength == 0) {
- Z_LVAL_P(key1) = f->h;
- Z_TYPE_P(key1) = IS_LONG;
+ if (f->key == NULL) {
+ ZVAL_LONG(&args[0], f->h);
} else {
- Z_STRVAL_P(key1) = estrndup(f->arKey, f->nKeyLength - 1);
- Z_STRLEN_P(key1) = f->nKeyLength - 1;
- Z_TYPE_P(key1) = IS_STRING;
+ ZVAL_STR(&args[0], STR_COPY(f->key));
}
- if (s->nKeyLength == 0) {
- Z_LVAL_P(key2) = s->h;
- Z_TYPE_P(key2) = IS_LONG;
+ if (s->key == NULL) {
+ ZVAL_LONG(&args[1], s->h);
} else {
- Z_STRVAL_P(key2) = estrndup(s->arKey, s->nKeyLength - 1);
- Z_STRLEN_P(key2) = s->nKeyLength - 1;
- Z_TYPE_P(key2) = IS_STRING;
+ ZVAL_STR(&args[1], STR_COPY(s->key));
}
BG(user_compare_fci).param_count = 2;
BG(user_compare_fci).params = args;
- BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+ BG(user_compare_fci).retval = &retval;
BG(user_compare_fci).no_separation = 0;
- if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
- convert_to_long_ex(&retval_ptr);
- result = Z_LVAL_P(retval_ptr);
- zval_ptr_dtor(&retval_ptr);
+ if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+ convert_to_long_ex(&retval);
+ result = Z_LVAL(retval);
+ zval_ptr_dtor(&retval);
} else {
result = 0;
}
- zval_ptr_dtor(&key1);
- zval_ptr_dtor(&key2);
+ zval_ptr_dtor(&args[0]);
+ zval_ptr_dtor(&args[1]);
return result;
}
* comparison. The result of sorting in such case is undefined and the
* function returns FALSE.
*/
- Z_UNSET_ISREF_P(array);
+//??? Z_UNSET_ISREF_P(array);
refcount = Z_REFCOUNT_P(array);
if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_key_compare, 0 TSRMLS_CC) == FAILURE) {
}
if (Z_REFCOUNT_P(array) > 1) {
- Z_SET_ISREF_P(array);
+//??? Z_SET_ISREF_P(array);
}
PHP_ARRAY_CMP_FUNC_RESTORE();
PHP_FUNCTION(end)
{
HashTable *array;
- zval **entry;
+ zval *entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
return;
zend_hash_internal_pointer_end(array);
if (return_value_used) {
- if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+ if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
- RETURN_ZVAL_FAST(*entry);
+ RETURN_ZVAL_FAST(entry);
}
}
/* }}} */
PHP_FUNCTION(prev)
{
HashTable *array;
- zval **entry;
+ zval *entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
return;
zend_hash_move_backwards(array);
if (return_value_used) {
- if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+ if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
- RETURN_ZVAL_FAST(*entry);
+ RETURN_ZVAL_FAST(entry);
}
}
/* }}} */
PHP_FUNCTION(next)
{
HashTable *array;
- zval **entry;
+ zval *entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
return;
zend_hash_move_forward(array);
if (return_value_used) {
- if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+ if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
- RETURN_ZVAL_FAST(*entry);
+ RETURN_ZVAL_FAST(entry);
}
}
/* }}} */
PHP_FUNCTION(reset)
{
HashTable *array;
- zval **entry;
+ zval *entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
return;
zend_hash_internal_pointer_reset(array);
if (return_value_used) {
- if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+ if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
- RETURN_ZVAL_FAST(*entry);
+ RETURN_ZVAL_FAST(entry);
}
}
/* }}} */
PHP_FUNCTION(current)
{
HashTable *array;
- zval **entry;
+ zval *entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
return;
}
- if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+ if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
- RETURN_ZVAL_FAST(*entry);
+ RETURN_ZVAL_FAST(entry);
}
/* }}} */
PHP_FUNCTION(min)
{
int argc;
- zval ***args = NULL;
+ zval *args = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
return;
/* mixed min ( array $values ) */
if (argc == 1) {
- zval **result;
+ zval *result;
- if (Z_TYPE_PP(args[0]) != IS_ARRAY) {
+ if (Z_TYPE(args[0]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "When only one parameter is given, it must be an array");
RETVAL_NULL();
} else {
- if (zend_hash_minmax(Z_ARRVAL_PP(args[0]), php_array_data_compare, 0, (void **) &result TSRMLS_CC) == SUCCESS) {
- RETVAL_ZVAL_FAST(*result);
+ if ((result = zend_hash_minmax(Z_ARRVAL(args[0]), php_array_data_compare, 0 TSRMLS_CC)) != NULL) {
+ RETVAL_ZVAL_FAST(result);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array must contain at least one element");
RETVAL_FALSE;
}
} else {
/* mixed min ( mixed $value1 , mixed $value2 [, mixed $value3... ] ) */
- zval **min, result;
+ zval *min, result;
int i;
- min = args[0];
+ min = &args[0];
for (i = 1; i < argc; i++) {
- is_smaller_function(&result, *args[i], *min TSRMLS_CC);
+ is_smaller_function(&result, &args[i], min TSRMLS_CC);
if (Z_LVAL(result) == 1) {
- min = args[i];
+ min = &args[i];
}
}
- RETVAL_ZVAL_FAST(*min);
+ RETVAL_ZVAL_FAST(min);
}
if (args) {
Return the highest value in an array or a series of arguments */
PHP_FUNCTION(max)
{
- zval ***args = NULL;
+ zval *args = NULL;
int argc;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
/* mixed max ( array $values ) */
if (argc == 1) {
- zval **result;
+ zval *result;
- if (Z_TYPE_PP(args[0]) != IS_ARRAY) {
+ if (Z_TYPE(args[0]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "When only one parameter is given, it must be an array");
RETVAL_NULL();
} else {
- if (zend_hash_minmax(Z_ARRVAL_PP(args[0]), php_array_data_compare, 1, (void **) &result TSRMLS_CC) == SUCCESS) {
- RETVAL_ZVAL_FAST(*result);
+ if ((result = zend_hash_minmax(Z_ARRVAL(args[0]), php_array_data_compare, 1 TSRMLS_CC)) != NULL) {
+ RETVAL_ZVAL_FAST(result);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array must contain at least one element");
RETVAL_FALSE;
}
} else {
/* mixed max ( mixed $value1 , mixed $value2 [, mixed $value3... ] ) */
- zval **max, result;
+ zval *max, result;
int i;
- max = args[0];
+ max = &args[0];
for (i = 1; i < argc; i++) {
- is_smaller_or_equal_function(&result, *args[i], *max TSRMLS_CC);
+ is_smaller_or_equal_function(&result, &args[i], max TSRMLS_CC);
if (Z_LVAL(result) == 0) {
- max = args[i];
+ max = &args[i];
}
}
- RETVAL_ZVAL_FAST(*max);
+ RETVAL_ZVAL_FAST(max);
}
if (args) {
static int php_array_walk(HashTable *target_hash, zval *userdata, int recursive TSRMLS_DC) /* {{{ */
{
- zval **args[3], /* Arguments to userland function */
- *retval_ptr = NULL, /* Return value - unused */
- *key=NULL; /* Entry key */
+ zval args[3], /* Arguments to userland function */
+ retval, /* Return value - unused */
+ *zv;
/* Set up known arguments */
- args[1] = &key;
- args[2] = &userdata;
+ ZVAL_UNDEF(&retval);
+ ZVAL_UNDEF(&args[1]);
if (userdata) {
- Z_ADDREF_P(userdata);
+ ZVAL_COPY(&args[2], userdata);
}
- BG(array_walk_fci).retval_ptr_ptr = &retval_ptr;
+ BG(array_walk_fci).retval = &retval;
BG(array_walk_fci).param_count = userdata ? 3 : 2;
BG(array_walk_fci).params = args;
BG(array_walk_fci).no_separation = 0;
/* Iterate through hash */
zend_hash_internal_pointer_reset(target_hash);
- while (!EG(exception) && zend_hash_get_current_data(target_hash, (void **)&args[0]) == SUCCESS) {
- if (recursive && Z_TYPE_PP(args[0]) == IS_ARRAY) {
+ while (!EG(exception) && (zv = zend_hash_get_current_data(target_hash)) != NULL) {
+ ZVAL_COPY_VALUE(&args[0], zv);
+ if (recursive && Z_TYPE(args[0]) == IS_ARRAY) {
HashTable *thash;
zend_fcall_info orig_array_walk_fci;
zend_fcall_info_cache orig_array_walk_fci_cache;
- SEPARATE_ZVAL_IF_NOT_REF(args[0]);
- thash = Z_ARRVAL_PP(args[0]);
+ SEPARATE_ZVAL_IF_NOT_REF(&args[0]);
+ thash = Z_ARRVAL(args[0]);
if (thash->nApplyCount > 1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
if (userdata) {
- zval_ptr_dtor(&userdata);
+ zval_ptr_dtor(userdata);
}
return 0;
}
BG(array_walk_fci_cache) = orig_array_walk_fci_cache;
} else {
/* Allocate space for key */
- MAKE_STD_ZVAL(key);
- zend_hash_get_current_key_zval(target_hash, key);
+ zend_hash_get_current_key_zval(target_hash, &args[1]);
/* Call the userland function */
if (zend_call_function(&BG(array_walk_fci), &BG(array_walk_fci_cache) TSRMLS_CC) == SUCCESS) {
- if (retval_ptr) {
- zval_ptr_dtor(&retval_ptr);
- }
+ zval_ptr_dtor(&retval);
} else {
- if (key) {
- zval_ptr_dtor(&key);
- key = NULL;
+ if (Z_TYPE(args[1]) != IS_UNDEF) {
+ zval_ptr_dtor(&args[1]);
+ ZVAL_UNDEF(&args[1]);
}
break;
}
}
- if (key) {
- zval_ptr_dtor(&key);
- key = NULL;
+ if (Z_TYPE(args[1]) != IS_UNDEF) {
+ zval_ptr_dtor(&args[1]);
+ ZVAL_UNDEF(&args[1]);
}
zend_hash_move_forward(target_hash);
}
if (userdata) {
- zval_ptr_dtor(&userdata);
+ zval_ptr_dtor(userdata);
}
return 0;
}
{
zval *value, /* value to check for */
*array, /* array to check in */
- **entry, /* pointer to array entry */
+ *entry, /* pointer to array entry */
res; /* comparison result */
HashPosition pos; /* hash iterator */
zend_bool strict = 0; /* strict comparison or not */
}
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
- is_equal_func(&res, value, *entry TSRMLS_CC);
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(array), &pos)) != NULL) {
+ is_equal_func(&res, value, entry TSRMLS_CC);
if (Z_LVAL(res)) {
if (behavior == 0) {
RETURN_TRUE;
PHPAPI int php_prefix_varname(zval *result, zval *prefix, char *var_name, int var_name_len, zend_bool add_underscore TSRMLS_DC) /* {{{ */
{
- Z_STRLEN_P(result) = Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len;
- Z_TYPE_P(result) = IS_STRING;
- Z_STRVAL_P(result) = emalloc(Z_STRLEN_P(result) + 1);
+ ZVAL_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0));
memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRLEN_P(prefix));
if (add_underscore) {
{
zval *var_array, *prefix = NULL;
long extract_type = EXTR_OVERWRITE;
- zval **entry, *data;
- char *var_name;
+ zval *entry, data;
+ zend_string *var_name;
ulong num_key;
- uint var_name_len;
int var_exists, key_type, count = 0;
int extract_refs = 0;
HashPosition pos;
}
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(var_array), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(var_array), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(var_array), &pos)) != NULL) {
zval final_name;
ZVAL_NULL(&final_name);
- key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(var_array), &var_name, &var_name_len, &num_key, 0, &pos);
+ key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(var_array), &var_name, &num_key, 0, &pos);
var_exists = 0;
if (key_type == HASH_KEY_IS_STRING) {
- var_name_len--;
- var_exists = zend_hash_exists(EG(active_symbol_table), var_name, var_name_len + 1);
+ var_exists = zend_hash_exists(EG(active_symbol_table), var_name);
} else if (key_type == HASH_KEY_IS_LONG && (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID)) {
zval num;
case EXTR_OVERWRITE:
/* GLOBALS protection */
- if (var_exists && var_name_len == sizeof("GLOBALS")-1 && !strcmp(var_name, "GLOBALS")) {
+ if (var_exists && var_name->len == sizeof("GLOBALS")-1 && !strcmp(var_name->val, "GLOBALS")) {
break;
}
- if (var_exists && var_name_len == sizeof("this")-1 && !strcmp(var_name, "this") && EG(scope) && EG(scope)->name_length != 0) {
+ if (var_exists && var_name->len == sizeof("this")-1 && !strcmp(var_name->val, "this") && EG(scope) && EG(scope)->name->len != 0) {
break;
}
- ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+ ZVAL_STR(&final_name, STR_COPY(var_name));
break;
case EXTR_PREFIX_IF_EXISTS:
if (var_exists) {
- php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+ php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
}
break;
case EXTR_PREFIX_SAME:
- if (!var_exists && var_name_len != 0) {
- ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+ if (!var_exists && var_name->len != 0) {
+ ZVAL_STR(&final_name, STR_COPY(var_name));
}
/* break omitted intentionally */
case EXTR_PREFIX_ALL:
- if (Z_TYPE(final_name) == IS_NULL && var_name_len != 0) {
- php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+ if (Z_TYPE(final_name) == IS_NULL && var_name->len != 0) {
+ php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
}
break;
case EXTR_PREFIX_INVALID:
if (Z_TYPE(final_name) == IS_NULL) {
- if (!php_valid_var_name(var_name, var_name_len)) {
- php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+ if (!php_valid_var_name(var_name->val, var_name->len)) {
+ php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
} else {
- ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+ ZVAL_STR(&final_name, STR_COPY(var_name));
}
}
break;
default:
if (!var_exists) {
- ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+ ZVAL_STR(&final_name, STR_COPY(var_name));
}
break;
}
if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
if (extract_refs) {
- zval **orig_var;
+ zval *orig_var;
SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
zval_add_ref(entry);
- if (zend_hash_find(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) &orig_var) == SUCCESS) {
+ if ((orig_var = zend_hash_find(EG(active_symbol_table), Z_STR(final_name))) != NULL) {
zval_ptr_dtor(orig_var);
- *orig_var = *entry;
+ ZVAL_COPY_VALUE(orig_var, entry);
} else {
- zend_hash_update(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) entry, sizeof(zval *), NULL);
+ zend_hash_update(EG(active_symbol_table), Z_STR(final_name), entry);
}
} else {
- MAKE_STD_ZVAL(data);
- *data = **entry;
- zval_copy_ctor(data);
-
- ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, data, 1, 0);
+ ZVAL_DUP(&data, entry);
+ ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, &data, 1, 0);
}
count++;
}
}
if (!extract_refs) {
- zval_ptr_dtor(&var_array);
+ zval_ptr_dtor(var_array);
}
RETURN_LONG(count);
static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_value, zval *entry TSRMLS_DC) /* {{{ */
{
- zval **value_ptr, *value, *data;
+ zval *value_ptr, data;
if (Z_TYPE_P(entry) == IS_STRING) {
- if (zend_hash_find(eg_active_symbol_table, Z_STRVAL_P(entry), Z_STRLEN_P(entry) + 1, (void **)&value_ptr) != FAILURE) {
- value = *value_ptr;
- ALLOC_ZVAL(data);
- MAKE_COPY_ZVAL(&value, data);
-
- zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(entry), Z_STRLEN_P(entry) + 1, &data, sizeof(zval *), NULL);
+ if ((value_ptr = zend_hash_find(eg_active_symbol_table, Z_STR_P(entry))) != NULL) {
+ ZVAL_DUP(&data, value_ptr);
+ zend_hash_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
}
}
else if (Z_TYPE_P(entry) == IS_ARRAY) {
Z_ARRVAL_P(entry)->nApplyCount++;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(entry), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), (void**)&value_ptr, &pos) == SUCCESS) {
- value = *value_ptr;
-
- php_compact_var(eg_active_symbol_table, return_value, value TSRMLS_CC);
+ while ((value_ptr = zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), &pos)) != NULL) {
+ php_compact_var(eg_active_symbol_table, return_value, value_ptr TSRMLS_CC);
zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos);
}
Z_ARRVAL_P(entry)->nApplyCount--;
Creates a hash containing variables and their values */
PHP_FUNCTION(compact)
{
- zval ***args = NULL; /* function arguments array */
+ zval *args = NULL; /* function arguments array */
int num_args, i;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &num_args) == FAILURE) {
/* compact() is probably most used with a single array of var_names
or multiple string names, rather than a combination of both.
So quickly guess a minimum result size based on that */
- if (ZEND_NUM_ARGS() == 1 && Z_TYPE_PP(args[0]) == IS_ARRAY) {
- array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_PP(args[0])));
+ if (ZEND_NUM_ARGS() == 1 && Z_TYPE(args[0]) == IS_ARRAY) {
+ array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL(args[0])));
} else {
array_init_size(return_value, ZEND_NUM_ARGS());
}
for (i=0; i<ZEND_NUM_ARGS(); i++) {
- php_compact_var(EG(active_symbol_table), return_value, *args[i] TSRMLS_CC);
+ php_compact_var(EG(active_symbol_table), return_value, &args[i] TSRMLS_CC);
}
if (args) {
}
num--;
- zend_hash_index_update(Z_ARRVAL_P(return_value), start_key, &val, sizeof(zval *), NULL);
- zval_add_ref(&val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), start_key, val);
+ zval_add_ref(val);
while (num--) {
- if (zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &val, sizeof(zval *), NULL) == SUCCESS) {
- zval_add_ref(&val);
+ if (zend_hash_next_index_insert(Z_ARRVAL_P(return_value), val) != NULL) {
+ zval_add_ref(val);
} else {
zval_dtor(return_value);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied");
Create an array using the elements of the first parameter as keys each initialized to val */
PHP_FUNCTION(array_fill_keys)
{
- zval *keys, *val, **entry;
+ zval *keys, *val, *entry;
HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az", &keys, &val) == FAILURE) {
array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(keys)));
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(keys), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), &pos)) != NULL) {
- if (Z_TYPE_PP(entry) == IS_LONG) {
- zval_add_ref(&val);
- zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &val, sizeof(zval *), NULL);
+ if (Z_TYPE_P(entry) == IS_LONG) {
+ zval_add_ref(val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val);
} else {
- zval key, *key_ptr = *entry;
+ zval key, *key_ptr = entry;
- if (Z_TYPE_PP(entry) != IS_STRING) {
- key = **entry;
- zval_copy_ctor(&key);
+ if (Z_TYPE_P(entry) != IS_STRING) {
+ ZVAL_DUP(&key, entry);
convert_to_string(&key);
key_ptr = &key;
}
- zval_add_ref(&val);
- zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(key_ptr), Z_STRLEN_P(key_ptr) + 1, &val, sizeof(zval *), NULL);
+ zval_add_ref(val);
+ zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(key_ptr), val);
- if (key_ptr != *entry) {
+ if (key_ptr != entry) {
zval_dtor(&key);
}
}
is_step_double = 1;
}
- convert_to_double_ex(&zstep);
+ convert_to_double_ex(zstep);
step = Z_DVAL_P(zstep);
/* We only want positive step values. */
if (hash->nNumUsed != hash->nNumOfElements) {
for (j = 0, idx = 0; idx < hash->nNumUsed; idx++) {
p = hash->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
if (j != idx) {
hash->arData[j] = *p;
}
for (j = 0; j < n_elems; j++) {
p = hash->arData + j;
- if (p->nKeyLength && !IS_INTERNED(p->arKey)) {
- pefree((char*)p->arKey, hash->flags & HASH_FLAG_PERSISTENT);
+ if (p->key && !IS_INTERNED(p->key)) {
+ pefree((char*)p->key, hash->flags & HASH_FLAG_PERSISTENT);
}
p->h = j;
- p->nKeyLength = 0;
- p->arKey = NULL;
+ p->key = NULL;
}
hash->nNextFreeElement = n_elems;
if (!(hash->flags & HASH_FLAG_PACKED)) {
}
/* }}} */
-PHPAPI HashTable* php_splice(HashTable *in_hash, int offset, int length, zval ***list, int list_count, HashTable **removed) /* {{{ */
+PHPAPI HashTable* php_splice(HashTable *in_hash, int offset, int length, zval *list, int list_count, HashTable *removed) /* {{{ */
{
HashTable *out_hash = NULL; /* Output hashtable */
int num_in, /* Number of entries in the input hashtable */
/* Start at the beginning of the input hash and copy entries to output hash until offset is reached */
for (pos = 0, idx = 0; pos < offset && idx < in_hash->nNumUsed; idx++) {
p = in_hash->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
pos++;
/* Get entry and increase reference count */
- entry = (zval *)p->xData;
+ entry = &p->val;
Z_ADDREF_P(entry);
/* Update output hash depending on key type */
- if (p->nKeyLength == 0) {
- zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
+ if (p->key == NULL) {
+ zend_hash_next_index_insert(out_hash, entry);
} else {
- zend_hash_quick_update(out_hash, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL);
+ zend_hash_update(out_hash, p->key, entry);
}
}
if (removed != NULL) {
for ( ; pos < offset + length && idx < in_hash->nNumUsed; idx++) {
p = in_hash->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
pos++;
- entry = (zval *)p->xData;
+ entry = &p->val;
Z_ADDREF_P(entry);
- if (p->nKeyLength == 0) {
- zend_hash_next_index_insert(*removed, &entry, sizeof(zval *), NULL);
+ if (p->key == NULL) {
+ zend_hash_next_index_insert(removed, entry);
} else {
- zend_hash_quick_update(*removed, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL);
+ zend_hash_update(removed, p->key, entry);
}
}
} else { /* otherwise just skip those entries */
if (list != NULL) {
/* ..for each one, create a new zval, copy entry into it and copy it into the output hash */
for (i = 0; i < list_count; i++) {
- entry = *list[i];
+ entry = &list[i];
Z_ADDREF_P(entry);
- zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(out_hash, entry);
}
}
/* Copy the remaining input hash entries to the output hash */
for ( ; idx < in_hash->nNumUsed ; idx++) {
p = in_hash->arData + idx;
- if (!p->xData) continue;
- entry = (zval *)p->xData;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ entry = &p->val;
Z_ADDREF_P(entry);
- if (p->nKeyLength == 0) {
- zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
+ if (p->key == NULL) {
+ zend_hash_next_index_insert(out_hash, entry);
} else {
- zend_hash_quick_update(out_hash, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL);
+ zend_hash_update(out_hash, p->key, entry);
}
}
new_var = *args[i];
Z_ADDREF_P(new_var);
- if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var, sizeof(zval *), NULL) == FAILURE) {
+ if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), new_var) == NULL) {
Z_DELREF_P(new_var);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied");
efree(args);
static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
{
zval *stack, /* Input stack */
- **val; /* Value to be popped */
- char *key = NULL;
- uint key_len = 0;
+ *val; /* Value to be popped */
+ zend_string *key = NULL;
ulong index;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &stack) == FAILURE) {
} else {
zend_hash_internal_pointer_reset(Z_ARRVAL_P(stack));
}
- zend_hash_get_current_data(Z_ARRVAL_P(stack), (void **)&val);
- RETVAL_ZVAL_FAST(*val);
+ val = zend_hash_get_current_data(Z_ARRVAL_P(stack));
+ RETVAL_ZVAL_FAST(val);
/* Delete the first or last value */
- zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &key_len, &index, 0, NULL);
- if (key && Z_ARRVAL_P(stack) == &EG(symbol_table)) {
- zend_delete_global_variable(key, key_len - 1 TSRMLS_CC);
+ zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &index, 0, NULL);
+ if (key && Z_ARRVAL_P(stack) == &EG(symbol_table).ht) {
+ zend_delete_global_variable(key TSRMLS_CC);
+ } else if (key) {
+ zend_hash_del(Z_ARRVAL_P(stack), key);
} else {
- zend_hash_del_key_or_index(Z_ARRVAL_P(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
+ zend_hash_index_del(Z_ARRVAL_P(stack), index);
}
/* If we did a shift... re-index like it did before */
for (idx = 0; idx < Z_ARRVAL_P(stack)->nNumUsed; idx++) {
p = Z_ARRVAL_P(stack)->arData + idx;
- if (!p->xData) continue;
- if (p->nKeyLength == 0) {
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ if (p->key == NULL) {
if (p->h != k) {
p->h = k++;
should_rehash = 1;
zend_hash_rehash(Z_ARRVAL_P(stack));
}
}
- } else if (!key_len && index >= Z_ARRVAL_P(stack)->nNextFreeElement - 1) {
+ } else if (!key && index >= Z_ARRVAL_P(stack)->nNextFreeElement - 1) {
Z_ARRVAL_P(stack)->nNextFreeElement = Z_ARRVAL_P(stack)->nNextFreeElement - 1;
}
Pushes elements onto the beginning of the array */
PHP_FUNCTION(array_unshift)
{
- zval ***args, /* Function arguments array */
+ zval *args, /* Function arguments array */
*stack; /* Input stack */
HashTable *new_hash; /* New hashtable for the stack */
HashTable old_hash;
* hashtable and replace it with new one */
new_hash = php_splice(Z_ARRVAL_P(stack), 0, 0, &args[0], argc, NULL);
old_hash = *Z_ARRVAL_P(stack);
- if (Z_ARRVAL_P(stack) == &EG(symbol_table)) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
+ if (Z_ARRVAL_P(stack) == &EG(symbol_table).ht) {
+ zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
}
*Z_ARRVAL_P(stack) = *new_hash;
FREE_HASHTABLE(new_hash);
{
zval *array, /* Input array */
*repl_array = NULL, /* Replacement array */
- ***repl = NULL; /* Replacement elements */
+ *repl = NULL; /* Replacement elements */
HashTable *new_hash = NULL, /* Output array's hash */
- **rem_hash = NULL; /* Removed elements' hash */
+ *rem_hash = NULL; /* Removed elements' hash */
HashTable old_hash;
uint idx;
Bucket *p; /* Bucket used for traversing hash */
/* Create the array of replacement elements */
repl_num = zend_hash_num_elements(Z_ARRVAL_P(repl_array));
- repl = (zval ***)safe_emalloc(repl_num, sizeof(zval **), 0);
+ repl = (zval *)safe_emalloc(repl_num, sizeof(zval), 0);
for (idx = 0, i = 0; idx < Z_ARRVAL_P(repl_array)->nNumUsed; idx++) {
p = Z_ARRVAL_P(repl_array)->arData + idx;
- if (!p->xData) continue;
- repl[i++] = (zval **)&p->xData;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ ZVAL_COPY_VALUE(&repl[i++], &p->val);
}
}
/* Initialize return value */
array_init_size(return_value, size > 0 ? size : 0);
- rem_hash = &Z_ARRVAL_P(return_value);
+ rem_hash = Z_ARRVAL_P(return_value);
}
/* Perform splice */
/* Replace input array's hashtable with the new one */
old_hash = *Z_ARRVAL_P(array);
- if (Z_ARRVAL_P(array) == &EG(symbol_table)) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
+ if (Z_ARRVAL_P(array) == &EG(symbol_table).ht) {
+ zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
}
*Z_ARRVAL_P(array) = *new_hash;
FREE_HASHTABLE(new_hash);
PHP_FUNCTION(array_slice)
{
zval *input, /* Input array */
- **z_length = NULL, /* How many elements to get */
- **entry; /* An array entry */
+ *z_length = NULL, /* How many elements to get */
+ *entry; /* An array entry */
long offset, /* Offset to get elements from */
length = 0;
zend_bool preserve_keys = 0; /* Whether to preserve keys while copying to the new array or not */
int num_in, /* Number of elements in the input array */
pos; /* Current position in the array */
- char *string_key;
- uint string_key_len;
+ zend_string *string_key;
ulong num_key;
HashPosition hpos;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|Zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) {
return;
}
num_in = zend_hash_num_elements(Z_ARRVAL_P(input));
/* We want all entries from offset to the end if length is not passed or is null */
- if (ZEND_NUM_ARGS() < 3 || Z_TYPE_PP(z_length) == IS_NULL) {
+ if (ZEND_NUM_ARGS() < 3 || Z_TYPE_P(z_length) == IS_NULL) {
length = num_in;
} else {
convert_to_long_ex(z_length);
- length = Z_LVAL_PP(z_length);
+ length = Z_LVAL_P(z_length);
}
/* Clamp the offset.. */
/* Start at the beginning and go until we hit offset */
pos = 0;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &hpos);
- while (pos < offset && zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &hpos) == SUCCESS) {
+ while (pos < offset && (entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &hpos)) != NULL) {
pos++;
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &hpos);
}
/* Copy elements from input array to the one that's returned */
- while (pos < offset + length && zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &hpos) == SUCCESS) {
+ while (pos < offset + length && (entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &hpos)) != NULL) {
zval_add_ref(entry);
- switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &hpos)) {
+ switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &num_key, 0, &hpos)) {
case HASH_KEY_IS_STRING:
- zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, entry, sizeof(zval *), NULL);
+ zend_hash_update(Z_ARRVAL_P(return_value), string_key, entry);
break;
case HASH_KEY_IS_LONG:
if (preserve_keys) {
- zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(zval *), NULL);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
} else {
- zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
}
break;
}
PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS_DC) /* {{{ */
{
- zval **src_entry, **dest_entry;
- char *string_key;
- uint string_key_len;
+ zval *src_entry, *dest_entry;
+ zend_string *string_key;
ulong num_key;
HashPosition pos;
zend_hash_internal_pointer_reset_ex(src, &pos);
- while (zend_hash_get_current_data_ex(src, (void **)&src_entry, &pos) == SUCCESS) {
- switch (zend_hash_get_current_key_ex(src, &string_key, &string_key_len, &num_key, 0, &pos)) {
+ while ((src_entry = zend_hash_get_current_data_ex(src, &pos)) != NULL) {
+ switch (zend_hash_get_current_key_ex(src, &string_key, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
- if (recursive && zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == SUCCESS) {
- HashTable *thash = Z_TYPE_PP(dest_entry) == IS_ARRAY ? Z_ARRVAL_PP(dest_entry) : NULL;
- zval *src_zval;
+ if (recursive && (dest_entry = zend_hash_find(dest, string_key)) != NULL) {
+ HashTable *thash = Z_TYPE_P(dest_entry) == IS_ARRAY ? Z_ARRVAL_P(dest_entry) : NULL;
+ zval src_zval;
zval *tmp = NULL;
- if ((thash && thash->nApplyCount > 1) || (*src_entry == *dest_entry && Z_ISREF_PP(dest_entry) && (Z_REFCOUNT_PP(dest_entry) % 2))) {
+ if ((thash && thash->nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
return 0;
}
SEPARATE_ZVAL(dest_entry);
- if (Z_TYPE_PP(dest_entry) == IS_NULL) {
+ if (Z_TYPE_P(dest_entry) == IS_NULL) {
convert_to_array_ex(dest_entry);
- add_next_index_null(*dest_entry);
+ add_next_index_null(dest_entry);
} else {
convert_to_array_ex(dest_entry);
}
- if (Z_TYPE_PP(src_entry) == IS_OBJECT) {
- ALLOC_ZVAL(src_zval);
- INIT_PZVAL_COPY(src_zval, *src_entry);
- zval_copy_ctor(src_zval);
- convert_to_array(src_zval);
- tmp = src_zval;
+ if (Z_TYPE_P(src_entry) == IS_OBJECT) {
+ ZVAL_DUP(&src_zval, src_entry);
+ zval_copy_ctor(&src_zval);
+ convert_to_array(&src_zval);
+ tmp = &src_zval;
} else {
- src_zval = *src_entry;
+ ZVAL_COPY_VALUE(&src_zval, src_entry);
}
- if (Z_TYPE_P(src_zval) == IS_ARRAY) {
+ if (Z_TYPE(src_zval) == IS_ARRAY) {
if (thash) {
thash->nApplyCount++;
}
- if (!php_array_merge(Z_ARRVAL_PP(dest_entry), Z_ARRVAL_P(src_zval), recursive TSRMLS_CC)) {
+ if (!php_array_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL(src_zval), recursive TSRMLS_CC)) {
if (thash) {
thash->nApplyCount--;
}
thash->nApplyCount--;
}
} else {
- Z_ADDREF_PP(src_entry);
- zend_hash_next_index_insert(Z_ARRVAL_PP(dest_entry), &src_zval, sizeof(zval *), NULL);
+ Z_ADDREF_P(src_entry);
+ zend_hash_next_index_insert(Z_ARRVAL_P(dest_entry), &src_zval);
}
if (tmp) {
- zval_ptr_dtor(&tmp);
+ zval_ptr_dtor(tmp);
}
} else {
- Z_ADDREF_PP(src_entry);
- zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
+ Z_ADDREF_P(src_entry);
+ zend_hash_update(dest, string_key, src_entry);
}
break;
case HASH_KEY_IS_LONG:
- Z_ADDREF_PP(src_entry);
- zend_hash_next_index_insert(dest, src_entry, sizeof(zval *), NULL);
+ Z_ADDREF_P(src_entry);
+ zend_hash_next_index_insert(dest, src_entry);
break;
}
zend_hash_move_forward_ex(src, &pos);
PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC) /* {{{ */
{
- zval **src_entry, **dest_entry;
- char *string_key;
- uint string_key_len;
+ zval *src_entry, *dest_entry;
+ zend_string *string_key;
ulong num_key;
HashPosition pos;
for (zend_hash_internal_pointer_reset_ex(src, &pos);
- zend_hash_get_current_data_ex(src, (void **)&src_entry, &pos) == SUCCESS;
+ (src_entry = zend_hash_get_current_data_ex(src, &pos)) != NULL;
zend_hash_move_forward_ex(src, &pos)) {
- switch (zend_hash_get_current_key_ex(src, &string_key, &string_key_len, &num_key, 0, &pos)) {
+ switch (zend_hash_get_current_key_ex(src, &string_key, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
- if (Z_TYPE_PP(src_entry) != IS_ARRAY ||
- zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == FAILURE ||
- Z_TYPE_PP(dest_entry) != IS_ARRAY) {
+ if (Z_TYPE_P(src_entry) != IS_ARRAY ||
+ (dest_entry = zend_hash_find(dest, string_key)) == NULL ||
+ Z_TYPE_P(dest_entry) != IS_ARRAY) {
- Z_ADDREF_PP(src_entry);
- zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
+ Z_ADDREF_P(src_entry);
+ zend_hash_update(dest, string_key, src_entry);
continue;
}
break;
case HASH_KEY_IS_LONG:
- if (Z_TYPE_PP(src_entry) != IS_ARRAY ||
- zend_hash_index_find(dest, num_key, (void **)&dest_entry) == FAILURE ||
- Z_TYPE_PP(dest_entry) != IS_ARRAY) {
+ if (Z_TYPE_P(src_entry) != IS_ARRAY ||
+ (dest_entry = zend_hash_index_find(dest, num_key)) == NULL ||
+ Z_TYPE_P(dest_entry) != IS_ARRAY) {
- Z_ADDREF_PP(src_entry);
- zend_hash_index_update(dest, num_key, src_entry, sizeof(zval *), NULL);
+ Z_ADDREF_P(src_entry);
+ zend_hash_index_update(dest, num_key, src_entry);
continue;
}
break;
}
- if (Z_ARRVAL_PP(dest_entry)->nApplyCount > 1 || Z_ARRVAL_PP(src_entry)->nApplyCount > 1 || (*src_entry == *dest_entry && Z_ISREF_PP(dest_entry) && (Z_REFCOUNT_PP(dest_entry) % 2))) {
+ if (Z_ARRVAL_P(dest_entry)->nApplyCount > 1 || Z_ARRVAL_P(src_entry)->nApplyCount > 1 || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
return 0;
}
SEPARATE_ZVAL(dest_entry);
- Z_ARRVAL_PP(dest_entry)->nApplyCount++;
- Z_ARRVAL_PP(src_entry)->nApplyCount++;
+ Z_ARRVAL_P(dest_entry)->nApplyCount++;
+ Z_ARRVAL_P(src_entry)->nApplyCount++;
- if (!php_array_replace_recursive(Z_ARRVAL_PP(dest_entry), Z_ARRVAL_PP(src_entry) TSRMLS_CC)) {
- Z_ARRVAL_PP(dest_entry)->nApplyCount--;
- Z_ARRVAL_PP(src_entry)->nApplyCount--;
+ if (!php_array_replace_recursive(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry) TSRMLS_CC)) {
+ Z_ARRVAL_P(dest_entry)->nApplyCount--;
+ Z_ARRVAL_P(src_entry)->nApplyCount--;
return 0;
}
- Z_ARRVAL_PP(dest_entry)->nApplyCount--;
- Z_ARRVAL_PP(src_entry)->nApplyCount--;
+ Z_ARRVAL_P(dest_entry)->nApplyCount--;
+ Z_ARRVAL_P(src_entry)->nApplyCount--;
}
return 1;
static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int recursive, int replace) /* {{{ */
{
- zval ***args = NULL;
+ zval *args = NULL;
int argc, i, init_size = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
}
for (i = 0; i < argc; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+ if (Z_TYPE(args[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
efree(args);
RETURN_NULL();
} else {
- int num = zend_hash_num_elements(Z_ARRVAL_PP(args[i]));
+ int num = zend_hash_num_elements(Z_ARRVAL(args[i]));
if (num > init_size) {
init_size = num;
for (i = 0; i < argc; i++) {
if (!replace) {
- php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]), recursive TSRMLS_CC);
+ php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL(args[i]), recursive TSRMLS_CC);
} else if (recursive && i > 0) { /* First array will be copied directly instead */
- php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]) TSRMLS_CC);
+ php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL(args[i]) TSRMLS_CC);
} else {
- zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *), 1);
+ zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL(args[i]), zval_add_ref, 1);
}
}
{
zval *input, /* Input array */
*search_value = NULL, /* Value to search for */
- **entry, /* An entry in the input array */
+ *entry, /* An entry in the input array */
res, /* Result of comparison */
- *new_val; /* New value */
+ new_val; /* New value */
int add_key; /* Flag to indicate whether a key should be added */
zend_bool strict = 0; /* do strict comparison */
HashPosition pos;
/* Go through input array and add keys to the return array */
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL) {
if (search_value != NULL) {
- is_equal_func(&res, search_value, *entry TSRMLS_CC);
+ is_equal_func(&res, search_value, entry TSRMLS_CC);
add_key = zval_is_true(&res);
}
if (add_key) {
- MAKE_STD_ZVAL(new_val);
- zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(input), new_val, &pos);
- zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &new_val, sizeof(zval *), NULL);
+ zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(input), &new_val, &pos);
+ zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &new_val);
}
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
PHP_FUNCTION(array_values)
{
zval *input, /* Input array */
- **entry; /* An entry in the input array */
+ *entry; /* An entry in the input array */
HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &input) == FAILURE) {
/* Go through input array and add values to the return array */
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL) {
zval_add_ref(entry);
- zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
}
}
Return the value as key and the frequency of that value in input as value */
PHP_FUNCTION(array_count_values)
{
- zval *input, /* Input array */
- **entry, /* An entry in the input array */
- **tmp;
+ zval *input, /* Input array */
+ *entry, /* An entry in the input array */
+ *tmp;
HashTable *myht;
HashPosition pos;
/* Go through input array and add values to the return array */
myht = Z_ARRVAL_P(input);
zend_hash_internal_pointer_reset_ex(myht, &pos);
- while (zend_hash_get_current_data_ex(myht, (void **)&entry, &pos) == SUCCESS) {
- if (Z_TYPE_PP(entry) == IS_LONG) {
- if (zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), (void **)&tmp) == FAILURE) {
- zval *data;
- MAKE_STD_ZVAL(data);
- ZVAL_LONG(data, 1);
- zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &data, sizeof(data), NULL);
+ while ((entry = zend_hash_get_current_data_ex(myht, &pos)) != NULL) {
+ if (Z_TYPE_P(entry) == IS_LONG) {
+ if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_P(entry))) == NULL) {
+ zval data;
+ ZVAL_LONG(&data, 1);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data);
} else {
- Z_LVAL_PP(tmp)++;
+ Z_LVAL_P(tmp)++;
}
- } else if (Z_TYPE_PP(entry) == IS_STRING) {
- if (zend_symtable_find(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, (void**)&tmp) == FAILURE) {
- zval *data;
- MAKE_STD_ZVAL(data);
- ZVAL_LONG(data, 1);
- zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, &data, sizeof(data), NULL);
+ } else if (Z_TYPE_P(entry) == IS_STRING) {
+ if ((tmp = zend_symtable_find(Z_ARRVAL_P(return_value), Z_STR_P(entry))) == NULL) {
+ zval data;
+ ZVAL_LONG(&data, 1);
+ zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
} else {
- Z_LVAL_PP(tmp)++;
+ Z_LVAL_P(tmp)++;
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only count STRING and INTEGER values!");
* Specialized conversion rules for array_column() function
*/
static inline
-zend_bool array_column_param_helper(zval **param,
+zend_bool array_column_param_helper(zval *param,
const char *name TSRMLS_DC) {
- switch (Z_TYPE_PP(param)) {
+ switch (Z_TYPE_P(param)) {
case IS_DOUBLE:
convert_to_long_ex(param);
/* fallthrough */
value_key and optionally indexed by the index_key */
PHP_FUNCTION(array_column)
{
- zval **zcolumn = NULL, **zkey = NULL, **data;
+ zval *zcolumn = NULL, *zkey = NULL, *data;
HashTable *arr_hash;
HashPosition pointer;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hZ!|Z!", &arr_hash, &zcolumn, &zkey) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hz!|z!", &arr_hash, &zcolumn, &zkey) == FAILURE) {
return;
}
array_init(return_value);
for (zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
- zend_hash_get_current_data_ex(arr_hash, (void**)&data, &pointer) == SUCCESS;
+ (data = zend_hash_get_current_data_ex(arr_hash, &pointer)) != NULL;
zend_hash_move_forward_ex(arr_hash, &pointer)) {
- zval **zcolval, **zkeyval = NULL;
+ zval *zcolval, *zkeyval = NULL;
HashTable *ht;
- if (Z_TYPE_PP(data) != IS_ARRAY) {
+ if (Z_TYPE_P(data) != IS_ARRAY) {
/* Skip elemens which are not sub-arrays */
continue;
}
- ht = Z_ARRVAL_PP(data);
+ ht = Z_ARRVAL_P(data);
if (!zcolumn) {
/* NULL column ID means use entire subarray as data */
zcolval = data;
/* Otherwise, skip if the value doesn't exist in our subarray */
- } else if ((Z_TYPE_PP(zcolumn) == IS_STRING) &&
- (zend_hash_find(ht, Z_STRVAL_PP(zcolumn), Z_STRLEN_PP(zcolumn) + 1, (void**)&zcolval) == FAILURE)) {
+ } else if ((Z_TYPE_P(zcolumn) == IS_STRING) &&
+ ((zcolval = zend_hash_find(ht, Z_STR_P(zcolumn))) == NULL)) {
continue;
- } else if ((Z_TYPE_PP(zcolumn) == IS_LONG) &&
- (zend_hash_index_find(ht, Z_LVAL_PP(zcolumn), (void**)&zcolval) == FAILURE)) {
+ } else if ((Z_TYPE_P(zcolumn) == IS_LONG) &&
+ ((zcolval = zend_hash_index_find(ht, Z_LVAL_P(zcolumn))) == NULL)) {
continue;
}
/* Failure will leave zkeyval alone which will land us on the final else block below
* which is to append the value as next_index
*/
- if (zkey && (Z_TYPE_PP(zkey) == IS_STRING)) {
- zend_hash_find(ht, Z_STRVAL_PP(zkey), Z_STRLEN_PP(zkey) + 1, (void**)&zkeyval);
- } else if (zkey && (Z_TYPE_PP(zkey) == IS_LONG)) {
- zend_hash_index_find(ht, Z_LVAL_PP(zkey), (void**)&zkeyval);
- }
-
- Z_ADDREF_PP(zcolval);
- if (zkeyval && Z_TYPE_PP(zkeyval) == IS_STRING) {
- add_assoc_zval(return_value, Z_STRVAL_PP(zkeyval), *zcolval);
- } else if (zkeyval && Z_TYPE_PP(zkeyval) == IS_LONG) {
- add_index_zval(return_value, Z_LVAL_PP(zkeyval), *zcolval);
- } else if (zkeyval && Z_TYPE_PP(zkeyval) == IS_OBJECT) {
+ if (zkey && (Z_TYPE_P(zkey) == IS_STRING)) {
+ zkeyval = zend_hash_find(ht, Z_STR_P(zkey));
+ } else if (zkey && (Z_TYPE_P(zkey) == IS_LONG)) {
+ zkeyval = zend_hash_index_find(ht, Z_LVAL_P(zkey));
+ }
+
+ Z_ADDREF_P(zcolval);
+ if (zkeyval && Z_TYPE_P(zkeyval) == IS_STRING) {
+//???
+ add_assoc_zval(return_value, Z_STRVAL_P(zkeyval), zcolval);
+ } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_LONG) {
+ add_index_zval(return_value, Z_LVAL_P(zkeyval), zcolval);
+ } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_OBJECT) {
SEPARATE_ZVAL(zkeyval);
- convert_to_string(*zkeyval);
- add_assoc_zval(return_value, Z_STRVAL_PP(zkeyval), *zcolval);
+ convert_to_string(zkeyval);
+//???
+ add_assoc_zval(return_value, Z_STRVAL_P(zkeyval), zcolval);
} else {
- add_next_index_zval(return_value, *zcolval);
+ add_next_index_zval(return_value, zcolval);
}
}
}
PHP_FUNCTION(array_reverse)
{
zval *input, /* Input array */
- **entry; /* An entry in the input array */
- char *string_key;
- uint string_key_len;
+ *entry; /* An entry in the input array */
+ zend_string *string_key;
ulong num_key;
zend_bool preserve_keys = 0; /* whether to preserve keys */
HashPosition pos;
array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(input)));
zend_hash_internal_pointer_end_ex(Z_ARRVAL_P(input), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL) {
zval_add_ref(entry);
- switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &pos)) {
+ switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
- zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, entry, sizeof(zval *), NULL);
+ zend_hash_update(Z_ARRVAL_P(return_value), string_key, entry);
break;
case HASH_KEY_IS_LONG:
if (preserve_keys) {
- zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(zval *), NULL);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
} else {
- zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
}
break;
}
{
zval *input; /* Input array */
zval *pad_value; /* Padding value obviously */
- zval ***pads; /* Array to pass to splice */
+ zval *pads; /* Array to pass to splice */
HashTable *new_hash;/* Return value from splice */
HashTable old_hash;
long pad_size; /* Size to pad to */
zval_dtor(return_value);
RETURN_FALSE;
}
- pads = (zval ***)safe_emalloc(num_pads, sizeof(zval **), 0);
+ pads = (zval *)safe_emalloc(num_pads, sizeof(zval), 0);
for (i = 0; i < num_pads; i++) {
- pads[i] = &pad_value;
+ ZVAL_COPY_VALUE(&pads[i], pad_value);
}
/* Pad on the right or on the left */
/* Copy the result hash into return value */
old_hash = *Z_ARRVAL_P(return_value);
- if (Z_ARRVAL_P(return_value) == &EG(symbol_table)) {
- zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
+ if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+ zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
}
*Z_ARRVAL_P(return_value) = *new_hash;
FREE_HASHTABLE(new_hash);
Return array with key <-> value flipped */
PHP_FUNCTION(array_flip)
{
- zval *array, **entry, *data;
+ zval *array, *entry, data;
HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {
array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
- MAKE_STD_ZVAL(data);
- zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(array), data, &pos);
-
- if (Z_TYPE_PP(entry) == IS_LONG) {
- zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &data, sizeof(data), NULL);
- } else if (Z_TYPE_PP(entry) == IS_STRING) {
- zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, &data, sizeof(data), NULL);
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(array), &pos)) != NULL) {
+ zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(array), &data, &pos);
+
+ if (Z_TYPE_P(entry) == IS_LONG) {
+ zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data);
+ } else if (Z_TYPE_P(entry) == IS_STRING) {
+ zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
} else {
zval_ptr_dtor(&data); /* will free also zval structure */
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only flip STRING and INTEGER values!");
Retuns an array with all string keys lowercased [or uppercased] */
PHP_FUNCTION(array_change_key_case)
{
- zval *array, **entry;
- char *string_key;
- char *new_key;
- uint str_key_len;
+ zval *array, *entry;
+ zend_string *string_key;
+ zend_string *new_key;
ulong num_key;
long change_to_upper=0;
HashPosition pos;
array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(array), &pos)) != NULL) {
zval_add_ref(entry);
- switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &str_key_len, &num_key, 0, &pos)) {
+ switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &num_key, 0, &pos)) {
case HASH_KEY_IS_LONG:
- zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(entry), NULL);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
break;
case HASH_KEY_IS_STRING:
- new_key = estrndup(string_key, str_key_len - 1);
+ new_key = STR_DUP(string_key, 0);
if (change_to_upper) {
- php_strtoupper(new_key, str_key_len - 1);
+ php_strtoupper(new_key->val, new_key->len);
} else {
- php_strtolower(new_key, str_key_len - 1);
+ php_strtolower(new_key->val, new_key->len);
}
- zend_hash_update(Z_ARRVAL_P(return_value), new_key, str_key_len, entry, sizeof(entry), NULL);
- efree(new_key);
+ zend_hash_update(Z_ARRVAL_P(return_value), new_key, entry);
+ STR_FREE(new_key);
break;
}
Removes duplicate values from array */
PHP_FUNCTION(array_unique)
{
- zval *array, *tmp;
+ zval *array;
uint idx;
Bucket *p;
struct bucketindex {
php_set_compare_func(sort_type TSRMLS_CC);
array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
- zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array), (copy_ctor_func_t) zval_add_ref, (void *)&tmp, sizeof(zval*));
+ zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array), zval_add_ref);
if (Z_ARRVAL_P(array)->nNumOfElements <= 1) { /* nothing to do */
return;
}
for (i = 0, idx = 0; idx < Z_ARRVAL_P(array)->nNumUsed; idx++) {
p = Z_ARRVAL_P(array)->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
arTmp[i].b = *p;
arTmp[i].i = i;
i++;
}
- arTmp[i].b.xData = NULL;
+ ZVAL_UNDEF(&arTmp[i].b.val);
zend_qsort((void *) arTmp, i, sizeof(struct bucketindex), php_array_data_compare TSRMLS_CC);
/* go through the sorted array and delete duplicates from the copy */
lastkept = arTmp;
- for (cmpdata = arTmp + 1; cmpdata->b.xData; cmpdata++) {
+ for (cmpdata = arTmp + 1; Z_TYPE(cmpdata->b.val) != IS_UNDEF; cmpdata++) {
if (php_array_data_compare(lastkept, cmpdata TSRMLS_CC)) {
lastkept = cmpdata;
} else {
} else {
p = &cmpdata->b;
}
- if (p->nKeyLength == 0) {
+ if (p->key == NULL) {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
} else {
- if (Z_ARRVAL_P(return_value) == &EG(symbol_table)) {
- zend_delete_global_variable(p->arKey, p->nKeyLength - 1 TSRMLS_CC);
+ if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+ zend_delete_global_variable(p->key TSRMLS_CC);
} else {
- zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+ zend_hash_del(Z_ARRVAL_P(return_value), p->key);
}
}
}
}
/* }}} */
-static int zval_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
+static int zval_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */
{
zval result;
zval *first;
zval *second;
- first = *((zval **) a);
- second = *((zval **) b);
+ first = a;
+ second = b;
if (string_compare_function(&result, first, second TSRMLS_CC) == FAILURE) {
return 0;
}
/* }}} */
-static int zval_user_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
+static int zval_user_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */
{
- zval **args[2];
- zval *retval_ptr = NULL;
+ zval args[2];
+ zval retval;
- args[0] = (zval **) a;
- args[1] = (zval **) b;
+ ZVAL_COPY_VALUE(&args[0], a);
+ ZVAL_COPY_VALUE(&args[1], b);
BG(user_compare_fci).param_count = 2;
BG(user_compare_fci).params = args;
- BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+ BG(user_compare_fci).retval = &retval;
BG(user_compare_fci).no_separation = 0;
- if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
- long retval;
+ if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+ long ret;
- convert_to_long_ex(&retval_ptr);
- retval = Z_LVAL_P(retval_ptr);
- zval_ptr_dtor(&retval_ptr);
- return retval < 0 ? -1 : retval > 0 ? 1 : 0;;
+ convert_to_long_ex(&retval);
+ ret = Z_LVAL(retval);
+ zval_ptr_dtor(&retval);
+ return ret < 0 ? -1 : ret > 0 ? 1 : 0;;
} else {
return 0;
}
uint idx;
Bucket *p;
int argc, i;
- zval ***args;
- int (*intersect_data_compare_func)(zval **, zval ** TSRMLS_DC) = NULL;
+ zval *args;
+ int (*intersect_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
zend_bool ok;
- zval **data;
+ zval *data;
int req_args;
char *param_spec;
}
for (i = 0; i < argc; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+ if (Z_TYPE(args[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
RETVAL_NULL();
goto out;
array_init(return_value);
- for (idx = 0; idx < Z_ARRVAL_PP(args[0])->nNumUsed; idx++) {
- p = Z_ARRVAL_PP(args[0])->arData + idx;
- if (!p->xData) continue;
- if (p->nKeyLength == 0) {
+ for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
+ p = Z_ARRVAL(args[0])->arData + idx;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ if (p->key == NULL) {
ok = 1;
for (i = 1; i < argc; i++) {
- if (zend_hash_index_find(Z_ARRVAL_PP(args[i]), p->h, (void**)&data) == FAILURE ||
+ if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) == NULL ||
(intersect_data_compare_func &&
- intersect_data_compare_func((zval**)&p->xData, data TSRMLS_CC) != 0)
+ intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
) {
ok = 0;
break;
}
}
if (ok) {
- Z_ADDREF_P((zval*)p->xData);
- zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->xData, sizeof(zval*), NULL);
+ Z_ADDREF(p->val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
}
} else {
ok = 1;
for (i = 1; i < argc; i++) {
- if (zend_hash_quick_find(Z_ARRVAL_PP(args[i]), p->arKey, p->nKeyLength, p->h, (void**)&data) == FAILURE ||
+ if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) == NULL ||
(intersect_data_compare_func &&
- intersect_data_compare_func((zval**)&p->xData, data TSRMLS_CC) != 0)
+ intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
) {
ok = 0;
break;
}
}
if (ok) {
- Z_ADDREF_P((zval*)p->xData);
- zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, &p->xData, sizeof(zval*), NULL);
+ Z_ADDREF(p->val);
+ zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
}
}
}
static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_compare_type, int key_compare_type) /* {{{ */
{
- zval ***args = NULL;
+ zval *args = NULL;
HashTable *hash;
int arr_argc, i, c = 0;
uint idx;
}
for (i = 0; i < arr_argc; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+ if (Z_TYPE(args[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
arr_argc = i; /* only free up to i - 1 */
goto out;
}
- hash = Z_ARRVAL_PP(args[i]);
+ hash = Z_ARRVAL(args[i]);
list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->flags & HASH_FLAG_PERSISTENT);
if (!list) {
PHP_ARRAY_CMP_FUNC_RESTORE();
ptrs[i] = list;
for (idx = 0; idx < hash->nNumUsed; idx++) {
p = hash->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
*list++ = *p;
}
- list->xData = NULL;
+ ZVAL_UNDEF(&list->val);
if (behavior == INTERSECT_NORMAL) {
zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), intersect_data_compare_func TSRMLS_CC);
} else if (behavior & INTERSECT_ASSOC) { /* triggered also when INTERSECT_KEY */
}
/* copy the argument array */
- RETVAL_ZVAL(*args[0], 1, 0);
- if (return_value->value.ht == &EG(symbol_table)) {
- HashTable *ht;
- zval *tmp;
+ RETVAL_ZVAL(&args[0], 1, 0);
+ if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+ HashTable *old_ht = Z_ARRVAL_P(return_value);
- ALLOC_HASHTABLE(ht);
- zend_hash_init(ht, zend_hash_num_elements(return_value->value.ht), NULL, ZVAL_PTR_DTOR, 0);
- zend_hash_copy(ht, return_value->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
- return_value->value.ht = ht;
+ ZVAL_NEW_ARR(return_value);
+ zend_hash_init(Z_ARRVAL_P(return_value), zend_hash_num_elements(old_ht), NULL, ZVAL_PTR_DTOR, 0);
+ zend_hash_copy(Z_ARRVAL_P(return_value), old_ht, zval_add_ref);
}
/* go through the lists and look for common values */
- while (ptrs[0]->xData) {
+ while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
if ((behavior & INTERSECT_ASSOC) /* triggered also when INTERSECT_KEY */
&&
key_compare_type == INTERSECT_COMP_KEY_USER) {
for (i = 1; i < arr_argc; i++) {
if (behavior & INTERSECT_NORMAL) {
- while (ptrs[i]->xData && (0 < (c = intersect_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+ while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
ptrs[i]++;
}
} else if (behavior & INTERSECT_ASSOC) { /* triggered also when INTERSECT_KEY */
- while (ptrs[i]->xData && (0 < (c = intersect_key_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+ while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_key_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
ptrs[i]++;
}
- if ((!c && ptrs[i]->xData) && (behavior == INTERSECT_ASSOC)) { /* only when INTERSECT_ASSOC */
+ if ((!c && Z_TYPE(ptrs[i]->val) != IS_UNDEF) && (behavior == INTERSECT_ASSOC)) { /* only when INTERSECT_ASSOC */
/* this means that ptrs[i] is not NULL so we can compare
* and "c==0" is from last operation
* in this branch of code we enter only when INTERSECT_ASSOC
}
}
}
- if (!ptrs[i]->xData) {
+ if (Z_TYPE(ptrs[i]->val) == IS_UNDEF) {
/* delete any values corresponding to remains of ptrs[0] */
/* and exit because they do not present in at least one of */
/* the other arguments */
for (;;) {
p = ptrs[0]++;
- if (!p->xData) {
+ if (Z_TYPE(p->val) == IS_UNDEF) {
goto out;
}
- if (p->nKeyLength == 0) {
+ if (p->key == NULL) {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
} else {
- zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+ zend_hash_del(Z_ARRVAL_P(return_value), p->key);
}
}
}
/* with value < value of ptrs[i] */
for (;;) {
p = ptrs[0];
- if (p->nKeyLength == 0) {
+ if (p->key == NULL) {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
} else {
- zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+ zend_hash_del(Z_ARRVAL_P(return_value), p->key);
}
- if (!(++ptrs[0])->xData) {
+ if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
goto out;
}
if (behavior == INTERSECT_NORMAL) {
/* ptrs[0] is present in all the arguments */
/* Skip all entries with same value as ptrs[0] */
for (;;) {
- if (!(++ptrs[0])->xData) {
+ if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
goto out;
}
if (behavior == INTERSECT_NORMAL) {
}
out:
for (i = 0; i < arr_argc; i++) {
- hash = Z_ARRVAL_PP(args[i]);
+ hash = Z_ARRVAL(args[i]);
pefree(lists[i], hash->flags & HASH_FLAG_PERSISTENT);
}
uint idx;
Bucket *p;
int argc, i;
- zval ***args;
- int (*diff_data_compare_func)(zval **, zval ** TSRMLS_DC) = NULL;
+ zval *args;
+ int (*diff_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
zend_bool ok;
- zval **data;
+ zval *data;
/* Get the argument count */
argc = ZEND_NUM_ARGS();
}
for (i = 0; i < argc; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+ if (Z_TYPE(args[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
RETVAL_NULL();
goto out;
array_init(return_value);
- for (idx = 0; idx < Z_ARRVAL_PP(args[0])->nNumUsed; idx++) {
- p = Z_ARRVAL_PP(args[0])->arData + idx;
- if (!p->xData) continue;
- if (p->nKeyLength == 0) {
+ for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
+ p = Z_ARRVAL(args[0])->arData + idx;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ if (p->key == NULL) {
ok = 1;
for (i = 1; i < argc; i++) {
- if (zend_hash_index_find(Z_ARRVAL_PP(args[i]), p->h, (void**)&data) == SUCCESS &&
+ if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) != NULL &&
(!diff_data_compare_func ||
- diff_data_compare_func((zval**)&p->xData, data TSRMLS_CC) == 0)
+ diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
) {
ok = 0;
break;
}
}
if (ok) {
- Z_ADDREF_P((zval*)p->xData);
- zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->xData, sizeof(zval*), NULL);
+ Z_ADDREF(p->val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
}
} else {
ok = 1;
for (i = 1; i < argc; i++) {
- if (zend_hash_quick_find(Z_ARRVAL_PP(args[i]), p->arKey, p->nKeyLength, p->h, (void**)&data) == SUCCESS &&
+ if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) != NULL &&
(!diff_data_compare_func ||
- diff_data_compare_func((zval**)&p->xData, data TSRMLS_CC) == 0)
+ diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
) {
ok = 0;
break;
}
}
if (ok) {
- Z_ADDREF_P((zval*)p->xData);
- zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, &p->xData, sizeof(zval*), NULL);
+ Z_ADDREF(p->val);
+ zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
}
}
}
static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_compare_type, int key_compare_type) /* {{{ */
{
- zval ***args = NULL;
+ zval *args = NULL;
HashTable *hash;
int arr_argc, i, c;
uint idx;
}
for (i = 0; i < arr_argc; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+ if (Z_TYPE(args[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
arr_argc = i; /* only free up to i - 1 */
goto out;
}
- hash = Z_ARRVAL_PP(args[i]);
+ hash = Z_ARRVAL(args[i]);
list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->flags & HASH_FLAG_PERSISTENT);
if (!list) {
PHP_ARRAY_CMP_FUNC_RESTORE();
ptrs[i] = list;
for (idx = 0; idx < hash->nNumUsed; idx++) {
p = hash->arData + idx;
- if (!p->xData) continue;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
*list++ = *p;
}
- list->xData = NULL;
+ ZVAL_UNDEF(&list->val);
if (behavior == DIFF_NORMAL) {
zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), diff_data_compare_func TSRMLS_CC);
} else if (behavior & DIFF_ASSOC) { /* triggered also when DIFF_KEY */
}
/* copy the argument array */
- RETVAL_ZVAL(*args[0], 1, 0);
- if (return_value->value.ht == &EG(symbol_table)) {
- HashTable *ht;
- zval *tmp;
+ RETVAL_ZVAL(&args[0], 1, 0);
+ if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+ HashTable *old_ht = Z_ARRVAL_P(return_value);
- ALLOC_HASHTABLE(ht);
- zend_hash_init(ht, zend_hash_num_elements(return_value->value.ht), NULL, ZVAL_PTR_DTOR, 0);
- zend_hash_copy(ht, return_value->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
- return_value->value.ht = ht;
+ ZVAL_NEW_ARR(return_value);
+ zend_hash_init(Z_ARRVAL_P(return_value), zend_hash_num_elements(old_ht), NULL, ZVAL_PTR_DTOR, 0);
+ zend_hash_copy(Z_ARRVAL_P(return_value), old_ht, zval_add_ref);
}
/* go through the lists and look for values of ptr[0] that are not in the others */
- while (ptrs[0]->xData) {
+ while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
if ((behavior & DIFF_ASSOC) /* triggered also when DIFF_KEY */
&&
key_compare_type == DIFF_COMP_KEY_USER
for (i = 1; i < arr_argc; i++) {
Bucket *ptr = ptrs[i];
if (behavior == DIFF_NORMAL) {
- while (ptrs[i]->xData && (0 < (c = diff_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+ while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = diff_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
ptrs[i]++;
}
} else if (behavior & DIFF_ASSOC) { /* triggered also when DIFF_KEY */
- while (ptr->xData && (0 != (c = diff_key_compare_func(ptrs[0], ptr TSRMLS_CC)))) {
+ while (Z_TYPE(ptr->val) != IS_UNDEF && (0 != (c = diff_key_compare_func(ptrs[0], ptr TSRMLS_CC)))) {
ptr++;
}
}
if (!c) {
if (behavior == DIFF_NORMAL) {
- if (ptrs[i]->xData) {
+ if (Z_TYPE(ptrs[i]->val) != IS_UNDEF) {
ptrs[i]++;
}
break;
} else if (behavior == DIFF_ASSOC) { /* only when DIFF_ASSOC */
/* In this branch is execute only when DIFF_ASSOC. If behavior == DIFF_KEY
* data comparison is not needed - skipped. */
- if (ptr->xData) {
+ if (Z_TYPE(ptr->val) != IS_UNDEF) {
if (data_compare_type == DIFF_COMP_DATA_USER) {
BG(user_compare_fci) = *fci_data;
BG(user_compare_fci_cache) = *fci_data_cache;
/* delete all entries with value as ptrs[0] */
for (;;) {
p = ptrs[0];
- if (p->nKeyLength == 0) {
+ if (p->key == NULL) {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
} else {
- zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+ zend_hash_del(Z_ARRVAL_P(return_value), p->key);
}
- if (!(++ptrs[0])->xData) {
+ if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
goto out;
}
if (behavior == DIFF_NORMAL) {
/* ptrs[0] in none of the other arguments */
/* skip all entries with value as ptrs[0] */
for (;;) {
- if (!(++ptrs[0])->xData) {
+ if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
goto out;
}
if (behavior == DIFF_NORMAL) {
}
out:
for (i = 0; i < arr_argc; i++) {
- hash = Z_ARRVAL_PP(args[i]);
+ hash = Z_ARRVAL(args[i]);
pefree(lists[i], hash->flags & HASH_FLAG_PERSISTENT);
}
do {
php_set_compare_func(ARRAYG(multisort_flags)[MULTISORT_TYPE][r] TSRMLS_CC);
- ARRAYG(compare_func)(&temp, (zval *)ab[r].xData, (zval *)bb[r].xData TSRMLS_CC);
+ ARRAYG(compare_func)(&temp, &ab[r].val, &bb[r].val TSRMLS_CC);
result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_LVAL(temp);
if (result != 0) {
return result;
}
r++;
- } while (ab[r].xData != NULL);
+ } while (Z_TYPE(ab[r].val) != IS_UNDEF);
return result;
}
Sort multiple arrays at once similar to how ORDER BY clause works in SQL */
PHP_FUNCTION(array_multisort)
{
- zval*** args;
- zval*** arrays;
+ zval* args;
+ zval** arrays;
Bucket** indirect;
uint idx;
Bucket* p;
}
/* Allocate space for storing pointers to input arrays and sort flags. */
- arrays = (zval ***)ecalloc(argc, sizeof(zval **));
+ arrays = (zval **)ecalloc(argc, sizeof(zval *));
for (i = 0; i < MULTISORT_LAST; i++) {
parse_state[i] = 0;
ARRAYG(multisort_flags)[i] = (int *)ecalloc(argc, sizeof(int));
* accordingly. There can't be two sort flags of the same type after an
* array, and the very first argument has to be an array. */
for (i = 0; i < argc; i++) {
- if (Z_TYPE_PP(args[i]) == IS_ARRAY) {
+ if (Z_TYPE(args[i]) == IS_ARRAY) {
/* We see the next array, so we update the sort flags of
* the previous array and reset the sort flags. */
if (i > 0) {
sort_order = PHP_SORT_ASC;
sort_type = PHP_SORT_REGULAR;
}
- arrays[num_arrays++] = args[i];
+ arrays[num_arrays++] = &args[i];
/* Next one may be an array or a list of sort flags. */
for (k = 0; k < MULTISORT_LAST; k++) {
parse_state[k] = 1;
}
- } else if (Z_TYPE_PP(args[i]) == IS_LONG) {
- switch (Z_LVAL_PP(args[i]) & ~PHP_SORT_FLAG_CASE) {
+ } else if (Z_TYPE(args[i]) == IS_LONG) {
+ switch (Z_LVAL(args[i]) & ~PHP_SORT_FLAG_CASE) {
case PHP_SORT_ASC:
case PHP_SORT_DESC:
/* flag allowed here */
if (parse_state[MULTISORT_ORDER] == 1) {
/* Save the flag and make sure then next arg is not the current flag. */
- sort_order = Z_LVAL_PP(args[i]) == PHP_SORT_DESC ? -1 : 1;
+ sort_order = Z_LVAL(args[i]) == PHP_SORT_DESC ? -1 : 1;
parse_state[MULTISORT_ORDER] = 0;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1);
/* flag allowed here */
if (parse_state[MULTISORT_TYPE] == 1) {
/* Save the flag and make sure then next arg is not the current flag. */
- sort_type = Z_LVAL_PP(args[i]);
+ sort_type = Z_LVAL(args[i]);
parse_state[MULTISORT_TYPE] = 0;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1);
ARRAYG(multisort_flags)[MULTISORT_TYPE][num_arrays - 1] = sort_type;
/* Make sure the arrays are of the same size. */
- array_size = zend_hash_num_elements(Z_ARRVAL_PP(arrays[0]));
+ array_size = zend_hash_num_elements(Z_ARRVAL_P(arrays[0]));
for (i = 0; i < num_arrays; i++) {
- if (zend_hash_num_elements(Z_ARRVAL_PP(arrays[i])) != array_size) {
+ if (zend_hash_num_elements(Z_ARRVAL_P(arrays[i])) != array_size) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array sizes are inconsistent");
MULTISORT_ABORT;
}
}
for (i = 0; i < num_arrays; i++) {
k = 0;
- for (idx = 0; idx < Z_ARRVAL_PP(arrays[i])->nNumUsed; idx++) {
- p = Z_ARRVAL_PP(arrays[i])->arData + idx;
- if (!p->xData) continue;
+ for (idx = 0; idx < Z_ARRVAL_P(arrays[i])->nNumUsed; idx++) {
+ p = Z_ARRVAL_P(arrays[i])->arData + idx;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
indirect[k][i] = *p;
k++;
}
}
for (k = 0; k < array_size; k++) {
- indirect[k][num_arrays].xData = NULL;
+ ZVAL_UNDEF(&indirect[k][num_arrays].val);
}
/* Do the actual sort magic - bada-bim, bada-boom. */
/* Restructure the arrays based on sorted indirect - this is mostly taken from zend_hash_sort() function. */
HANDLE_BLOCK_INTERRUPTIONS();
for (i = 0; i < num_arrays; i++) {
- hash = Z_ARRVAL_PP(arrays[i]);
+ hash = Z_ARRVAL_P(arrays[i]);
hash->nNumUsed = array_size;
hash->nInternalPointer = 0;
for (n = 0, k = 0; k < array_size; k++) {
hash->arData[k] = indirect[k][i];
- if (hash->arData[k].nKeyLength == 0)
+ if (hash->arData[k].key == NULL)
hash->arData[k].h = n++;
}
zval *input;
long randval, num_req = 1;
int num_avail, key_type;
- char *string_key;
- uint string_key_len;
+ zend_string *string_key;
ulong num_key;
HashPosition pos;
/* We can't use zend_hash_index_find() because the array may have string keys or gaps. */
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- while (num_req && (key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTENT) {
+ while (num_req && (key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTENT) {
randval = php_rand(TSRMLS_C);
/* If we are returning a single result, just do it. */
if (Z_TYPE_P(return_value) != IS_ARRAY) {
if (key_type == HASH_KEY_IS_STRING) {
- RETURN_STRINGL(string_key, string_key_len - 1, 1);
+ RETURN_STR(STR_COPY(string_key));
} else {
RETURN_LONG(num_key);
}
} else {
/* Append the result to the return value. */
if (key_type == HASH_KEY_IS_STRING) {
- add_next_index_stringl(return_value, string_key, string_key_len - 1, 1);
+ add_next_index_str(return_value, string_key);
} else {
add_next_index_long(return_value, num_key);
}
PHP_FUNCTION(array_sum)
{
zval *input,
- **entry,
+ *entry,
entry_n;
HashPosition pos;
ZVAL_LONG(return_value, 0);
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS;
+ (entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL;
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos)
) {
- if (Z_TYPE_PP(entry) == IS_ARRAY || Z_TYPE_PP(entry) == IS_OBJECT) {
+ if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) {
continue;
}
- entry_n = **entry;
- zval_copy_ctor(&entry_n);
+ ZVAL_DUP(&entry_n, entry);
convert_scalar_to_number(&entry_n TSRMLS_CC);
fast_add_function(return_value, return_value, &entry_n TSRMLS_CC);
}
PHP_FUNCTION(array_product)
{
zval *input,
- **entry,
+ *entry,
entry_n;
HashPosition pos;
double dval;
}
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS;
+ (entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL;
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos)
) {
- if (Z_TYPE_PP(entry) == IS_ARRAY || Z_TYPE_PP(entry) == IS_OBJECT) {
+ if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) {
continue;
}
- entry_n = **entry;
- zval_copy_ctor(&entry_n);
+ ZVAL_DUP(&entry_n, entry);
convert_scalar_to_number(&entry_n TSRMLS_CC);
if (Z_TYPE(entry_n) == IS_LONG && Z_TYPE_P(return_value) == IS_LONG) {
PHP_FUNCTION(array_reduce)
{
zval *input;
- zval **args[2];
- zval **operand;
- zval *result = NULL;
- zval *retval;
+ zval args[2];
+ zval *operand;
+ zval result;
+ zval retval;
zend_fcall_info fci;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
zval *initial = NULL;
return;
}
+
if (ZEND_NUM_ARGS() > 2) {
- ALLOC_ZVAL(result);
- MAKE_COPY_ZVAL(&initial, result);
+ ZVAL_DUP(&result, initial);
} else {
- MAKE_STD_ZVAL(result);
- ZVAL_NULL(result);
+ ZVAL_NULL(&result);
}
/* (zval **)input points to an element of argument stack
htbl = Z_ARRVAL_P(input);
if (zend_hash_num_elements(htbl) == 0) {
- if (result) {
- RETVAL_ZVAL(result, 1, 1);
- }
- return;
+ RETURN_ZVAL(&result, 1, 1);
}
- fci.retval_ptr_ptr = &retval;
+ fci.retval = &retval;
fci.param_count = 2;
fci.no_separation = 0;
zend_hash_internal_pointer_reset_ex(htbl, &pos);
- while (zend_hash_get_current_data_ex(htbl, (void **)&operand, &pos) == SUCCESS) {
-
- if (result) {
- args[0] = &result;
- args[1] = operand;
- fci.params = args;
-
- if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && retval) {
- zval_ptr_dtor(&result);
- result = retval;
- } else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the reduction callback");
- return;
- }
+ while ((operand = zend_hash_get_current_data_ex(htbl, &pos)) != NULL) {
+ ZVAL_COPY_VALUE(&args[0], &result);
+ ZVAL_COPY_VALUE(&args[1], operand);
+ fci.params = args;
+
+ if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+ zval_ptr_dtor(&result);
+ ZVAL_COPY_VALUE(&result, &retval);
} else {
- result = *operand;
- zval_add_ref(&result);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the reduction callback");
+ return;
}
zend_hash_move_forward_ex(htbl, &pos);
}
- RETVAL_ZVAL(result, 1, 1);
+ RETVAL_ZVAL(&result, 1, 1);
}
/* }}} */
PHP_FUNCTION(array_filter)
{
zval *array;
- zval **operand;
- zval **args[2];
- zval *retval = NULL;
- zval *key = NULL;
+ zval *operand;
+ zval args[2];
+ zval retval;
+//??? zval *key = NULL;
zend_bool have_callback = 0;
long use_type = 0;
- char *string_key;
+ zend_string *string_key;
zend_fcall_info fci = empty_fcall_info;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
- uint string_key_len;
ulong num_key;
HashPosition pos;
if (ZEND_NUM_ARGS() > 1) {
have_callback = 1;
fci.no_separation = 0;
- fci.retval_ptr_ptr = &retval;
+ fci.retval = &retval;
if (use_type == ARRAY_FILTER_USE_BOTH) {
fci.param_count = 2;
- args[1] = &key;
+//??? args[1] = &key;
} else {
fci.param_count = 1;
if (use_type == ARRAY_FILTER_USE_KEY) {
- args[0] = &key;
+//??? args[0] = &key;
}
}
}
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
- zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&operand, &pos) == SUCCESS;
+ (operand = zend_hash_get_current_data_ex(Z_ARRVAL_P(array), &pos)) != NULL;
zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos)
) {
- int key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, &num_key, 0, &pos);
+ int key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &num_key, 0, &pos);
if (have_callback) {
if (use_type) {
- MAKE_STD_ZVAL(key);
/* Set up the key */
switch (key_type) {
case HASH_KEY_IS_LONG:
- Z_TYPE_P(key) = IS_LONG;
- Z_LVAL_P(key) = num_key;
+ ZVAL_LONG(&args[0], num_key);
break;
case HASH_KEY_IS_STRING:
- ZVAL_STRINGL(key, string_key, string_key_len - 1, 1);
+ ZVAL_STR(&args[0], STR_COPY(string_key));
break;
}
}
if (use_type != ARRAY_FILTER_USE_KEY) {
- args[0] = operand;
+ ZVAL_COPY_VALUE(&args[0], operand);
}
fci.params = args;
- if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && retval) {
- int retval_true = zend_is_true(retval TSRMLS_CC);
+ if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+ int retval_true = zend_is_true(&retval TSRMLS_CC);
zval_ptr_dtor(&retval);
if (use_type) {
- zval_ptr_dtor(&key);
+ zval_ptr_dtor(&args[0]);
}
if (!retval_true) {
continue;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the filter callback");
return;
}
- } else if (!zend_is_true(*operand TSRMLS_CC)) {
+ } else if (!zend_is_true(operand TSRMLS_CC)) {
continue;
}
zval_add_ref(operand);
switch (key_type) {
case HASH_KEY_IS_STRING:
- zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, operand, sizeof(zval *), NULL);
+ zend_hash_update(Z_ARRVAL_P(return_value), string_key, operand);
break;
case HASH_KEY_IS_LONG:
- zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, operand, sizeof(zval *), NULL);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, operand);
break;
}
}
Applies the callback to the elements in given arrays. */
PHP_FUNCTION(array_map)
{
- zval ***arrays = NULL;
+ zval *arrays = NULL;
int n_arrays = 0;
- zval ***params;
- zval *result, *null;
+ zval *params;
+ zval result;
HashPosition *array_pos;
zval **args;
zend_fcall_info fci = empty_fcall_info;
array_pos = (HashPosition *)safe_emalloc(n_arrays, sizeof(HashPosition), 0);
for (i = 0; i < n_arrays; i++) {
- if (Z_TYPE_PP(arrays[i]) != IS_ARRAY) {
+ if (Z_TYPE(arrays[i]) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d should be an array", i + 2);
efree(arrays);
efree(args);
efree(array_pos);
return;
}
- SEPARATE_ZVAL_IF_NOT_REF(arrays[i]);
- args[i] = *arrays[i];
- array_len[i] = zend_hash_num_elements(Z_ARRVAL_PP(arrays[i]));
+ SEPARATE_ZVAL_IF_NOT_REF(&arrays[i]);
+ args[i] = &arrays[i];
+ array_len[i] = zend_hash_num_elements(Z_ARRVAL(arrays[i]));
if (array_len[i] > maxlen) {
maxlen = array_len[i];
}
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(arrays[i]), &array_pos[i]);
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL(arrays[i]), &array_pos[i]);
}
efree(arrays);
}
array_init_size(return_value, maxlen);
- params = (zval ***)safe_emalloc(n_arrays, sizeof(zval **), 0);
- MAKE_STD_ZVAL(null);
- ZVAL_NULL(null);
+ params = (zval *)safe_emalloc(n_arrays, sizeof(zval), 0);
/* We iterate through all the arrays at once. */
for (k = 0; k < maxlen; k++) {
- uint str_key_len;
ulong num_key;
- char *str_key;
+ zend_string *str_key;
int key_type = 0;
/* If no callback, the result will be an array, consisting of current
* entries from all arrays. */
if (!ZEND_FCI_INITIALIZED(fci)) {
- MAKE_STD_ZVAL(result);
- array_init_size(result, n_arrays);
+ array_init_size(&result, n_arrays);
}
for (i = 0; i < n_arrays; i++) {
/* If this array still has elements, add the current one to the
* parameter list, otherwise use null value. */
if (k < array_len[i]) {
- zend_hash_get_current_data_ex(Z_ARRVAL_P(args[i]), (void **)¶ms[i], &array_pos[i]);
+ zval *zv = zend_hash_get_current_data_ex(Z_ARRVAL_P(args[i]), &array_pos[i]);
+
+ ZVAL_COPY_VALUE(¶ms[i], zv);
/* It is safe to store only last value of key type, because
* this loop will run just once if there is only 1 array. */
if (n_arrays == 1) {
- key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(args[0]), &str_key, &str_key_len, &num_key, 0, &array_pos[i]);
+ key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(args[0]), &str_key, &num_key, 0, &array_pos[i]);
}
zend_hash_move_forward_ex(Z_ARRVAL_P(args[i]), &array_pos[i]);
} else {
- params[i] = &null;
+ ZVAL_NULL(¶ms[i]);
}
if (!ZEND_FCI_INITIALIZED(fci)) {
- zval_add_ref(params[i]);
- add_next_index_zval(result, *params[i]);
+ zval_add_ref(¶ms[i]);
+ add_next_index_zval(&result, ¶ms[i]);
}
}
if (ZEND_FCI_INITIALIZED(fci)) {
- fci.retval_ptr_ptr = &result;
+ fci.retval = &result;
fci.param_count = n_arrays;
fci.params = params;
fci.no_separation = 0;
- if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS || !result) {
+ if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS || Z_TYPE(result) == IS_UNDEF) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the map callback");
efree(array_len);
efree(args);
efree(array_pos);
zval_dtor(return_value);
- zval_ptr_dtor(&null);
efree(params);
RETURN_NULL();
}
}
if (n_arrays > 1) {
- add_next_index_zval(return_value, result);
+ add_next_index_zval(return_value, &result);
} else {
if (key_type == HASH_KEY_IS_STRING) {
- add_assoc_zval_ex(return_value, str_key, str_key_len, result);
+//???
+ add_assoc_zval_ex(return_value, str_key->val, str_key->len, &result);
} else {
- add_index_zval(return_value, num_key, result);
+ add_index_zval(return_value, num_key, &result);
}
}
}
- zval_ptr_dtor(&null);
efree(params);
efree(array_len);
efree(array_pos);
switch (Z_TYPE_P(key)) {
case IS_STRING:
- if (zend_symtable_exists(array, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1)) {
+ if (zend_symtable_exists(array, Z_STR_P(key))) {
RETURN_TRUE;
}
RETURN_FALSE;
}
RETURN_FALSE;
case IS_NULL:
- if (zend_hash_exists(array, "", 1)) {
+ if (zend_hash_exists(array, STR_EMPTY_ALLOC())) {
RETURN_TRUE;
}
RETURN_FALSE;
{
int argc = ZEND_NUM_ARGS(), key_type, num_in;
long size, current = 0;
- char *str_key;
- uint str_key_len;
+ zend_string *str_key;
ulong num_key;
zend_bool preserve_keys = 0;
zval *input = NULL;
- zval *chunk = NULL;
- zval **entry;
+ zval chunk;
+ zval *entry;
HashPosition pos;
if (zend_parse_parameters(argc TSRMLS_CC, "al|b", &input, &size, &preserve_keys) == FAILURE) {
array_init_size(return_value, ((num_in - 1) / size) + 1);
+ ZVAL_UNDEF(&chunk);
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void**)&entry, &pos) == SUCCESS) {
+ while ((entry = zend_hash_get_current_data_ex(Z_ARRVAL_P(input), &pos)) != NULL) {
/* If new chunk, create and initialize it. */
- if (!chunk) {
- MAKE_STD_ZVAL(chunk);
- array_init_size(chunk, size);
+ if (Z_TYPE(chunk) == IS_UNDEF) {
+ array_init_size(&chunk, size);
}
/* Add entry to the chunk, preserving keys if necessary. */
zval_add_ref(entry);
if (preserve_keys) {
- key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &str_key, &str_key_len, &num_key, 0, &pos);
+ key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &str_key, &num_key, 0, &pos);
switch (key_type) {
case HASH_KEY_IS_STRING:
- add_assoc_zval_ex(chunk, str_key, str_key_len, *entry);
+//???
+ add_assoc_zval_ex(&chunk, str_key->val, str_key->len, entry);
break;
default:
- add_index_zval(chunk, num_key, *entry);
+ add_index_zval(&chunk, num_key, entry);
break;
}
} else {
- add_next_index_zval(chunk, *entry);
+ add_next_index_zval(&chunk, entry);
}
/* If reached the chunk size, add it to the result array, and reset the
* pointer. */
if (!(++current % size)) {
- add_next_index_zval(return_value, chunk);
- chunk = NULL;
+ add_next_index_zval(return_value, &chunk);
+ ZVAL_UNDEF(&chunk);
}
zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
}
/* Add the final chunk if there is one. */
- if (chunk) {
- add_next_index_zval(return_value, chunk);
+ if (Z_TYPE(chunk) != IS_UNDEF) {
+ add_next_index_zval(return_value, &chunk);
}
}
/* }}} */
{
zval *values, *keys;
HashPosition pos_values, pos_keys;
- zval **entry_keys, **entry_values;
+ zval *entry_keys, *entry_values;
int num_keys, num_values;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aa", &keys, &values) == FAILURE) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(keys), &pos_keys);
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(values), &pos_values);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), (void **)&entry_keys, &pos_keys) == SUCCESS &&
- zend_hash_get_current_data_ex(Z_ARRVAL_P(values), (void **)&entry_values, &pos_values) == SUCCESS
+ while ((entry_keys = zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), &pos_keys)) != NULL &&
+ (entry_values = zend_hash_get_current_data_ex(Z_ARRVAL_P(values), &pos_values)) != NULL
) {
- if (Z_TYPE_PP(entry_keys) == IS_LONG) {
+ if (Z_TYPE_P(entry_keys) == IS_LONG) {
zval_add_ref(entry_values);
- add_index_zval(return_value, Z_LVAL_PP(entry_keys), *entry_values);
+ add_index_zval(return_value, Z_LVAL_P(entry_keys), entry_values);
} else {
- zval key, *key_ptr = *entry_keys;
+ zval key, *key_ptr = entry_keys;
- if (Z_TYPE_PP(entry_keys) != IS_STRING) {
- key = **entry_keys;
- zval_copy_ctor(&key);
+ if (Z_TYPE_P(entry_keys) != IS_STRING) {
+ ZVAL_DUP(&key, entry_keys);
convert_to_string(&key);
key_ptr = &key;
}
zval_add_ref(entry_values);
- add_assoc_zval_ex(return_value, Z_STRVAL_P(key_ptr), Z_STRLEN_P(key_ptr) + 1, *entry_values);
+//???
+ add_assoc_zval_ex(return_value, Z_STRVAL_P(key_ptr), Z_STRLEN_P(key_ptr), entry_values);
- if (key_ptr != *entry_keys) {
+ if (key_ptr != entry_keys) {
zval_dtor(&key);
}
}
RETURN_FALSE;
}
- RETURN_STRINGL(result, newlen, 0);
+//??? RETURN_STRINGL(result, newlen, 0);
+ RETURN_STRINGL(result, newlen);
}
/* }}} */
RETURN_FALSE;
}
- RETURN_STRINGL(result, newlen, 0);
+//??? RETURN_STRINGL(result, newlen, 0);
+ RETURN_STRINGL(result, newlen);
}
/* }}} */
if (value == NULL) {
RETURN_FALSE;
} else {
- RETURN_STRING(value, 1);
+ RETURN_STRING(value);
}
}
#endif
}
if (return_value) {
- RETVAL_STRINGL(c, len, 1);
+ RETVAL_STRINGL(c, len);
} else {
return estrndup(c, len);
}
}
}
- RETURN_STRINGL(newtext, textlen, 0);
+//??? RETURN_STRINGL(newtext, textlen, 0);
+ RETURN_STRINGL(newtext, textlen);
} else {
/* Multiple character line break or forced cut */
if (linelength > 0) {
/* free unused memory */
newtext = erealloc(newtext, newtextlen+1);
- RETURN_STRINGL(newtext, newtextlen, 0);
+//??? RETURN_STRINGL(newtext, newtextlen, 0);
+ RETURN_STRINGL(newtext, newtextlen);
}
}
/* }}} */
endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);
p1 = Z_STRVAL_P(str);
- p2 = php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
+ p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
if (p2 == NULL) {
add_next_index_stringl(return_value, p1, Z_STRLEN_P(str), 1);
do {
add_next_index_stringl(return_value, p1, p2 - p1, 1);
p1 = p2 + Z_STRLEN_P(delim);
- } while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL &&
+ } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL &&
--limit > 1);
if (p1 <= endp)
endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);
p1 = Z_STRVAL_P(str);
- p2 = php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
+ p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
if (p2 == NULL) {
/*
positions = erealloc(positions, allocated*sizeof(char *));
}
positions[found++] = p1 = p2 + Z_STRLEN_P(delim);
- } while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);
+ } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);
to_return = limit + found;
/* limit is at least -1 therefore no need of bounds checking : i will be always less than found */
return;
}
- ZVAL_STRINGL(&zstr, str, str_len, 0);
- ZVAL_STRINGL(&zdelim, delim, delim_len, 0);
+//??? ZVAL_STRINGL(&zstr, str, str_len, 0);
+//??? ZVAL_STRINGL(&zdelim, delim, delim_len, 0);
+ ZVAL_STRINGL(&zstr, str, str_len);
+ ZVAL_STRINGL(&zdelim, delim, delim_len);
if (limit > 1) {
php_explode(&zdelim, &zstr, return_value, limit);
} else if (limit < 0) {
*/
PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
{
- zval **tmp;
+ zval *tmp;
HashPosition pos;
smart_str implstr = {0};
int numelems, i = 0;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), (void **) &tmp, &pos) == SUCCESS) {
- switch ((*tmp)->type) {
+ while ((tmp = zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), &pos)) != NULL) {
+ switch (Z_TYPE_P(tmp)) {
case IS_STRING:
- smart_str_appendl(&implstr, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+ smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
break;
case IS_LONG: {
char stmp[MAX_LENGTH_OF_LONG + 1];
- str_len = slprintf(stmp, sizeof(stmp), "%ld", Z_LVAL_PP(tmp));
+ str_len = slprintf(stmp, sizeof(stmp), "%ld", Z_LVAL_P(tmp));
smart_str_appendl(&implstr, stmp, str_len);
}
break;
case IS_BOOL:
- if (Z_LVAL_PP(tmp) == 1) {
+ if (Z_LVAL_P(tmp) == 1) {
smart_str_appendl(&implstr, "1", sizeof("1")-1);
}
break;
case IS_DOUBLE: {
char *stmp;
- str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_PP(tmp));
+ str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_P(tmp));
smart_str_appendl(&implstr, stmp, str_len);
efree(stmp);
}
case IS_OBJECT: {
int copy;
zval expr;
- zend_make_printable_zval(*tmp, &expr, ©);
+ zend_make_printable_zval(tmp, &expr, ©);
smart_str_appendl(&implstr, Z_STRVAL(expr), Z_STRLEN(expr));
if (copy) {
zval_dtor(&expr);
break;
default:
- tmp_val = **tmp;
- zval_copy_ctor(&tmp_val);
- convert_to_string(&tmp_val);
+ ZVAL_DUP(&tmp_val, tmp);
smart_str_appendl(&implstr, Z_STRVAL(tmp_val), Z_STRLEN(tmp_val));
zval_dtor(&tmp_val);
break;
smart_str_0(&implstr);
if (implstr.len) {
- RETURN_STRINGL(implstr.c, implstr.len, 0);
+//??? RETURN_STRINGL(implstr.c, implstr.len, 0);
+ RETURN_STRINGL(implstr.c, implstr.len);
} else {
smart_str_free(&implstr);
RETURN_EMPTY_STRING();
Joins array elements placing glue string between items and return one string */
PHP_FUNCTION(implode)
{
- zval **arg1 = NULL, **arg2 = NULL, *delim, *arr;
+ zval *arg1 = NULL, *arg2 = NULL, *delim, *arr, tmp;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|Z", &arg1, &arg2) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &arg1, &arg2) == FAILURE) {
return;
}
if (arg2 == NULL) {
- if (Z_TYPE_PP(arg1) != IS_ARRAY) {
+ if (Z_TYPE_P(arg1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument must be an array");
return;
}
- MAKE_STD_ZVAL(delim);
-#define _IMPL_EMPTY ""
- ZVAL_STRINGL(delim, _IMPL_EMPTY, sizeof(_IMPL_EMPTY) - 1, 0);
+ ZVAL_STR(&tmp, STR_EMPTY_ALLOC());
+ delim = &tmp;
SEPARATE_ZVAL(arg1);
- arr = *arg1;
+ arr = arg1;
} else {
- if (Z_TYPE_PP(arg1) == IS_ARRAY) {
- arr = *arg1;
+ if (Z_TYPE_P(arg1) == IS_ARRAY) {
+ arr = arg1;
convert_to_string_ex(arg2);
- delim = *arg2;
- } else if (Z_TYPE_PP(arg2) == IS_ARRAY) {
- arr = *arg2;
+ delim = arg2;
+ } else if (Z_TYPE_P(arg2) == IS_ARRAY) {
+ arr = arg2;
convert_to_string_ex(arg1);
- delim = *arg1;
+ delim = arg1;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid arguments passed");
return;
}
php_implode(delim, arr, return_value TSRMLS_CC);
-
- if (arg2 == NULL) {
- FREE_ZVAL(delim);
- }
}
/* }}} */
{
char *str, *tok = NULL;
int str_len, tok_len = 0;
- zval *zv;
-
char *token;
char *token_end;
char *p;
tok = str;
tok_len = str_len;
} else {
- if (BG(strtok_zval)) {
- zval_ptr_dtor(&BG(strtok_zval));
- }
- MAKE_STD_ZVAL(zv);
- ZVAL_STRINGL(zv, str, str_len, 1);
-
- BG(strtok_zval) = zv;
- BG(strtok_last) = BG(strtok_string) = Z_STRVAL_P(zv);
+ zval_ptr_dtor(&BG(strtok_zval));
+ ZVAL_STRINGL(&BG(strtok_zval), str, str_len);
+ BG(strtok_last) = BG(strtok_string) = Z_STRVAL(BG(strtok_zval));
BG(strtok_len) = str_len;
}
if (p - BG(strtok_last)) {
return_token:
- RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped, 1);
+ RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped);
BG(strtok_last) = p + 1;
} else {
RETVAL_FALSE;
arg = estrndup(arg, arglen);
php_strtoupper(arg, arglen);
- RETURN_STRINGL(arg, arglen, 0);
+//??? RETURN_STRINGL(arg, arglen, 0);
+ RETURN_STRINGL(arg, arglen);
}
/* }}} */
str = estrndup(str, arglen);
php_strtolower(str, arglen);
- RETURN_STRINGL(str, arglen, 0);
+//??? RETURN_STRINGL(str, arglen, 0);
+ RETURN_STRINGL(str, arglen);
}
/* }}} */
}
php_basename(string, string_len, suffix, suffix_len, &ret, &ret_len TSRMLS_CC);
- RETURN_STRINGL(ret, (int)ret_len, 0);
+//??? RETURN_STRINGL(ret, (int)ret_len, 0);
+ RETURN_STRINGL(ret, (int)ret_len);
}
/* }}} */
ret = estrndup(str, str_len);
ret_len = php_dirname(ret, str_len);
- RETURN_STRINGL(ret, ret_len, 0);
+//??? RETURN_STRINGL(ret, ret_len, 0);
+ RETURN_STRINGL(ret, ret_len);
}
/* }}} */
Returns information about a certain string */
PHP_FUNCTION(pathinfo)
{
- zval *tmp;
+ zval tmp;
char *path, *ret = NULL;
int path_len, have_basename;
size_t ret_len;
have_basename = ((opt & PHP_PATHINFO_BASENAME) == PHP_PATHINFO_BASENAME);
- MAKE_STD_ZVAL(tmp);
- array_init(tmp);
+ array_init(&tmp);
if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {
ret = estrndup(path, path_len);
php_dirname(ret, path_len);
if (*ret) {
- add_assoc_string(tmp, "dirname", ret, 1);
+ add_assoc_string(&tmp, "dirname", ret, 1);
}
efree(ret);
ret = NULL;
if (have_basename) {
php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);
- add_assoc_stringl(tmp, "basename", ret, ret_len, 0);
+ add_assoc_stringl(&tmp, "basename", ret, ret_len, 0);
}
if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {
if (p) {
idx = p - ret;
- add_assoc_stringl(tmp, "extension", ret + idx + 1, ret_len - idx - 1, 1);
+ add_assoc_stringl(&tmp, "extension", ret + idx + 1, ret_len - idx - 1, 1);
}
}
p = zend_memrchr(ret, '.', ret_len);
idx = p ? (p - ret) : ret_len;
- add_assoc_stringl(tmp, "filename", ret, idx, 1);
+ add_assoc_stringl(&tmp, "filename", ret, idx, 1);
}
if (!have_basename && ret) {
}
if (opt == PHP_PATHINFO_ALL) {
- RETURN_ZVAL(tmp, 0, 1);
+ RETURN_ZVAL(&tmp, 0, 1);
} else {
- zval **element;
- if (zend_hash_get_current_data(Z_ARRVAL_P(tmp), (void **) &element) == SUCCESS) {
- RETVAL_ZVAL(*element, 1, 0);
+ zval *element;
+ if ((element = zend_hash_get_current_data(Z_ARRVAL(tmp))) != NULL) {
+ RETVAL_ZVAL(element, 1, 0);
} else {
ZVAL_EMPTY_STRING(return_value);
}
{
php_strtolower(s, s_len);
php_strtolower(t, t_len);
- return php_memnstr(s, t, t_len, s + s_len);
+ return (char*)php_memnstr(s, t, t_len, s + s_len);
}
/* }}} */
if (found) {
found_offset = found - haystack_dup;
if (part) {
- RETVAL_STRINGL(haystack, found_offset, 1);
+ RETVAL_STRINGL(haystack, found_offset);
} else {
- RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset, 1);
+ RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset);
}
} else {
RETVAL_FALSE;
RETURN_FALSE;
}
- found = php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len);
+ found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len);
} else {
if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) {
RETURN_FALSE;
}
needle_char[1] = 0;
- found = php_memnstr(haystack, needle_char, 1, haystack + haystack_len);
+ found = (char*)php_memnstr(haystack, needle_char, 1, haystack + haystack_len);
}
if (found) {
found_offset = found - haystack;
if (part) {
- RETURN_STRINGL(haystack, found_offset, 1);
+ RETURN_STRINGL(haystack, found_offset);
} else {
- RETURN_STRINGL(found, haystack_len - found_offset, 1);
+ RETURN_STRINGL(found, haystack_len - found_offset);
}
}
RETURN_FALSE;
RETURN_FALSE;
}
- found = php_memnstr(haystack + offset,
+ found = (char*)php_memnstr(haystack + offset,
Z_STRVAL_P(needle),
Z_STRLEN_P(needle),
haystack + haystack_len);
}
needle_char[1] = 0;
- found = php_memnstr(haystack + offset,
+ found = (char*)php_memnstr(haystack + offset,
needle_char,
1,
haystack + haystack_len);
needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle));
php_strtolower(needle_dup, Z_STRLEN_P(needle));
- found = php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len);
+ found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len);
} else {
if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) {
efree(haystack_dup);
}
needle_char[0] = tolower(needle_char[0]);
needle_char[1] = '\0';
- found = php_memnstr(haystack_dup + offset,
+ found = (char*)php_memnstr(haystack_dup + offset,
needle_char,
sizeof(needle_char) - 1,
haystack_dup + haystack_len);
if (found) {
found_offset = found - haystack;
- RETURN_STRINGL(found, haystack_len - found_offset, 1);
+ RETURN_STRINGL(found, haystack_len - found_offset);
} else {
RETURN_FALSE;
}
memcpy(result, str, str_len);
memcpy(result + str_len, end, endlen);
result[result_len] = '\0';
- RETURN_STRINGL(result, result_len, 0);
+//??? RETURN_STRINGL(result, result_len, 0);
+ RETURN_STRINGL(result, result_len);
}
if (!str_len) {
result = php_chunk_split(str, str_len, end, endlen, chunklen, &result_len);
if (result) {
- RETURN_STRINGL(result, result_len, 0);
+//??? RETURN_STRINGL(result, result_len, 0);
+ RETURN_STRINGL(result, result_len);
} else {
RETURN_FALSE;
}
l = str_len - f;
}
- RETURN_STRINGL(str + f, l, 1);
+ RETURN_STRINGL(str + f, l);
}
/* }}} */
Replaces part of a string with another string */
PHP_FUNCTION(substr_replace)
{
- zval **str;
- zval **from;
- zval **len = NULL;
- zval **repl;
+ zval *str;
+ zval *from;
+ zval *len = NULL;
+ zval *repl;
char *result;
int result_len;
int l = 0;
int argc = ZEND_NUM_ARGS();
HashPosition pos_str, pos_from, pos_repl, pos_len;
- zval **tmp_str = NULL, **tmp_from = NULL, **tmp_repl = NULL, **tmp_len= NULL;
+ zval *tmp_str = NULL, *tmp_from = NULL, *tmp_repl = NULL, *tmp_len= NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &str, &repl, &from, &len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &str, &repl, &from, &len) == FAILURE) {
return;
}
- if (Z_TYPE_PP(str) != IS_ARRAY) {
- if (Z_ISREF_PP(str)) {
- SEPARATE_ZVAL(str);
- }
+ if (Z_TYPE_P(str) != IS_ARRAY) {
+ SEPARATE_ZVAL_IF_REF(str);
convert_to_string_ex(str);
}
- if (Z_TYPE_PP(repl) != IS_ARRAY) {
- if (Z_ISREF_PP(repl)) {
- SEPARATE_ZVAL(repl);
- }
+ if (Z_TYPE_P(repl) != IS_ARRAY) {
+ SEPARATE_ZVAL_IF_REF(repl);
convert_to_string_ex(repl);
}
- if (Z_TYPE_PP(from) != IS_ARRAY) {
- if (Z_ISREF_PP(from)) {
- SEPARATE_ZVAL(from);
- }
+ if (Z_TYPE_P(from) != IS_ARRAY) {
+ SEPARATE_ZVAL_IF_REF(from);
convert_to_long_ex(from);
}
if (argc > 3) {
SEPARATE_ZVAL(len);
- if (Z_TYPE_PP(len) != IS_ARRAY) {
+ if (Z_TYPE_P(len) != IS_ARRAY) {
convert_to_long_ex(len);
- l = Z_LVAL_PP(len);
+ l = Z_LVAL_P(len);
}
} else {
- if (Z_TYPE_PP(str) != IS_ARRAY) {
- l = Z_STRLEN_PP(str);
+ if (Z_TYPE_P(str) != IS_ARRAY) {
+ l = Z_STRLEN_P(str);
}
}
- if (Z_TYPE_PP(str) == IS_STRING) {
+ if (Z_TYPE_P(str) == IS_STRING) {
if (
- (argc == 3 && Z_TYPE_PP(from) == IS_ARRAY) ||
- (argc == 4 && Z_TYPE_PP(from) != Z_TYPE_PP(len))
+ (argc == 3 && Z_TYPE_P(from) == IS_ARRAY) ||
+ (argc == 4 && Z_TYPE_P(from) != Z_TYPE_P(len))
) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should be of same type - numerical or array ");
- RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ RETURN_STR(STR_COPY(Z_STR_P(str)));
}
- if (argc == 4 && Z_TYPE_PP(from) == IS_ARRAY) {
- if (zend_hash_num_elements(Z_ARRVAL_PP(from)) != zend_hash_num_elements(Z_ARRVAL_PP(len))) {
+ if (argc == 4 && Z_TYPE_P(from) == IS_ARRAY) {
+ if (zend_hash_num_elements(Z_ARRVAL_P(from)) != zend_hash_num_elements(Z_ARRVAL_P(len))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should have the same number of elements");
- RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ RETURN_STR(STR_COPY(Z_STR_P(str)));
}
}
}
- if (Z_TYPE_PP(str) != IS_ARRAY) {
- if (Z_TYPE_PP(from) != IS_ARRAY) {
+ if (Z_TYPE_P(str) != IS_ARRAY) {
+ if (Z_TYPE_P(from) != IS_ARRAY) {
int repl_len = 0;
- f = Z_LVAL_PP(from);
+ f = Z_LVAL_P(from);
/* if "from" position is negative, count start position from the end
* of the string
*/
if (f < 0) {
- f = Z_STRLEN_PP(str) + f;
+ f = Z_STRLEN_P(str) + f;
if (f < 0) {
f = 0;
}
- } else if (f > Z_STRLEN_PP(str)) {
- f = Z_STRLEN_PP(str);
+ } else if (f > Z_STRLEN_P(str)) {
+ f = Z_STRLEN_P(str);
}
/* if "length" position is negative, set it to the length
* needed to stop that many chars from the end of the string
*/
if (l < 0) {
- l = (Z_STRLEN_PP(str) - f) + l;
+ l = (Z_STRLEN_P(str) - f) + l;
if (l < 0) {
l = 0;
}
}
- if (f > Z_STRLEN_PP(str) || (f < 0 && -f > Z_STRLEN_PP(str))) {
+ if (f > Z_STRLEN_P(str) || (f < 0 && -f > Z_STRLEN_P(str))) {
RETURN_FALSE;
- } else if (l > Z_STRLEN_PP(str) || (l < 0 && -l > Z_STRLEN_PP(str))) {
- l = Z_STRLEN_PP(str);
+ } else if (l > Z_STRLEN_P(str) || (l < 0 && -l > Z_STRLEN_P(str))) {
+ l = Z_STRLEN_P(str);
}
- if ((f + l) > Z_STRLEN_PP(str)) {
- l = Z_STRLEN_PP(str) - f;
+ if ((f + l) > Z_STRLEN_P(str)) {
+ l = Z_STRLEN_P(str) - f;
}
- if (Z_TYPE_PP(repl) == IS_ARRAY) {
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(repl), &pos_repl);
- if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
+ if (Z_TYPE_P(repl) == IS_ARRAY) {
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl);
+ if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) {
convert_to_string_ex(tmp_repl);
- repl_len = Z_STRLEN_PP(tmp_repl);
+ repl_len = Z_STRLEN_P(tmp_repl);
}
} else {
- repl_len = Z_STRLEN_PP(repl);
+ repl_len = Z_STRLEN_P(repl);
}
- result_len = Z_STRLEN_PP(str) - l + repl_len;
+ result_len = Z_STRLEN_P(str) - l + repl_len;
result = emalloc(result_len + 1);
- memcpy(result, Z_STRVAL_PP(str), f);
+ memcpy(result, Z_STRVAL_P(str), f);
if (repl_len) {
- memcpy((result + f), (Z_TYPE_PP(repl) == IS_ARRAY ? Z_STRVAL_PP(tmp_repl) : Z_STRVAL_PP(repl)), repl_len);
+ memcpy((result + f), (Z_TYPE_P(repl) == IS_ARRAY ? Z_STRVAL_P(tmp_repl) : Z_STRVAL_P(repl)), repl_len);
}
- memcpy((result + f + repl_len), Z_STRVAL_PP(str) + f + l, Z_STRLEN_PP(str) - f - l);
+ memcpy((result + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l);
result[result_len] = '\0';
- RETURN_STRINGL(result, result_len, 0);
+//??? RETURN_STRINGL(result, result_len, 0);
+ RETURN_STRINGL(result, result_len);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented");
- RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+ RETURN_STR(STR_COPY(Z_STR_P(str)));
}
} else { /* str is array of strings */
- char *str_index = NULL;
- uint str_index_len;
+ zend_string *str_index = NULL;
ulong num_index;
array_init(return_value);
- if (Z_TYPE_PP(from) == IS_ARRAY) {
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(from), &pos_from);
+ if (Z_TYPE_P(from) == IS_ARRAY) {
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(from), &pos_from);
}
- if (argc > 3 && Z_TYPE_PP(len) == IS_ARRAY) {
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(len), &pos_len);
+ if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) {
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(len), &pos_len);
}
- if (Z_TYPE_PP(repl) == IS_ARRAY) {
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(repl), &pos_repl);
+ if (Z_TYPE_P(repl) == IS_ARRAY) {
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl);
}
- zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(str), &pos_str);
- while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(str), (void **) &tmp_str, &pos_str) == SUCCESS) {
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(str), &pos_str);
+ while ((tmp_str = zend_hash_get_current_data_ex(Z_ARRVAL_P(str), &pos_str)) != NULL) {
zval *orig_str;
zval dummy;
ulong refcount;
- int was_ref;
+//??? int was_ref;
- if(Z_TYPE_PP(tmp_str) != IS_STRING) {
- dummy = **tmp_str;
+ if(Z_TYPE_P(tmp_str) != IS_STRING) {
+ ZVAL_DUP(&dummy, tmp_str);
+ convert_to_string(&dummy);
orig_str = &dummy;
- zval_copy_ctor(orig_str);
- convert_to_string(orig_str);
} else {
- orig_str = *tmp_str;
+ orig_str = tmp_str;
}
- was_ref = Z_ISREF_P(orig_str);
- Z_UNSET_ISREF_P(orig_str);
+//??? was_ref = Z_ISREF_P(orig_str);
+//??? Z_UNSET_ISREF_P(orig_str);
refcount = Z_REFCOUNT_P(orig_str);
- if (Z_TYPE_PP(from) == IS_ARRAY) {
- if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(from), (void **) &tmp_from, &pos_from)) {
- if(Z_TYPE_PP(tmp_from) != IS_LONG) {
- zval dummy = **tmp_from;
- zval_copy_ctor(&dummy);
+ if (Z_TYPE_P(from) == IS_ARRAY) {
+ if (NULL != (tmp_from = zend_hash_get_current_data_ex(Z_ARRVAL_P(from), &pos_from))) {
+ if(Z_TYPE_P(tmp_from) != IS_LONG) {
+ zval dummy;
+
+ ZVAL_DUP(&dummy, tmp_from);
convert_to_long(&dummy);
f = Z_LVAL(dummy);
} else {
- f = Z_LVAL_PP(tmp_from);
+ f = Z_LVAL_P(tmp_from);
}
if (f < 0) {
} else if (f > Z_STRLEN_P(orig_str)) {
f = Z_STRLEN_P(orig_str);
}
- zend_hash_move_forward_ex(Z_ARRVAL_PP(from), &pos_from);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(from), &pos_from);
} else {
f = 0;
}
} else {
- f = Z_LVAL_PP(from);
+ f = Z_LVAL_P(from);
if (f < 0) {
f = Z_STRLEN_P(orig_str) + f;
if (f < 0) {
}
}
- if (argc > 3 && Z_TYPE_PP(len) == IS_ARRAY) {
- if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(len), (void **) &tmp_len, &pos_len)) {
- if(Z_TYPE_PP(tmp_len) != IS_LONG) {
- zval dummy = **tmp_len;
- zval_copy_ctor(&dummy);
+ if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) {
+ if (NULL != (tmp_len = zend_hash_get_current_data_ex(Z_ARRVAL_P(len), &pos_len))) {
+ if(Z_TYPE_P(tmp_len) != IS_LONG) {
+ zval dummy;
+
+ ZVAL_DUP(&dummy, tmp_len);
convert_to_long(&dummy);
l = Z_LVAL(dummy);
} else {
- l = Z_LVAL_PP(tmp_len);
+ l = Z_LVAL_P(tmp_len);
}
- zend_hash_move_forward_ex(Z_ARRVAL_PP(len), &pos_len);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(len), &pos_len);
} else {
l = Z_STRLEN_P(orig_str);
}
} else if (argc > 3) {
- l = Z_LVAL_PP(len);
+ l = Z_LVAL_P(len);
} else {
l = Z_STRLEN_P(orig_str);
}
result_len = Z_STRLEN_P(orig_str) - l;
- if (Z_TYPE_PP(repl) == IS_ARRAY) {
- if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
+ if (Z_TYPE_P(repl) == IS_ARRAY) {
+ if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) {
zval *repl_str;
zval zrepl;
- if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
- zrepl = **tmp_repl;
+ if(Z_TYPE_P(tmp_repl) != IS_STRING) {
+ ZVAL_DUP(&zrepl, tmp_repl);
+ convert_to_string(&zrepl);
repl_str = &zrepl;
- zval_copy_ctor(repl_str);
- convert_to_string(repl_str);
} else {
- repl_str = *tmp_repl;
+ repl_str = tmp_repl;
}
if(Z_REFCOUNT_P(orig_str) != refcount) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument was modified while replacing");
- if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
+ if(Z_TYPE_P(tmp_repl) != IS_STRING) {
zval_dtor(repl_str);
}
break;
}
result_len += Z_STRLEN_P(repl_str);
- zend_hash_move_forward_ex(Z_ARRVAL_PP(repl), &pos_repl);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(repl), &pos_repl);
result = emalloc(result_len + 1);
memcpy(result, Z_STRVAL_P(orig_str), f);
memcpy((result + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str));
memcpy((result + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
- if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
+ if(Z_TYPE_P(tmp_repl) != IS_STRING) {
zval_dtor(repl_str);
}
} else {
memcpy((result + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
}
} else {
- result_len += Z_STRLEN_PP(repl);
+ result_len += Z_STRLEN_P(repl);
result = emalloc(result_len + 1);
memcpy(result, Z_STRVAL_P(orig_str), f);
- memcpy((result + f), Z_STRVAL_PP(repl), Z_STRLEN_PP(repl));
- memcpy((result + f + Z_STRLEN_PP(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
+ memcpy((result + f), Z_STRVAL_P(repl), Z_STRLEN_P(repl));
+ memcpy((result + f + Z_STRLEN_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
}
result[result_len] = '\0';
- if (zend_hash_get_current_key_ex(Z_ARRVAL_PP(str), &str_index, &str_index_len, &num_index, 0, &pos_str) == HASH_KEY_IS_STRING) {
- add_assoc_stringl_ex(return_value, str_index, str_index_len, result, result_len, 0);
+ if (zend_hash_get_current_key_ex(Z_ARRVAL_P(str), &str_index, &num_index, 0, &pos_str) == HASH_KEY_IS_STRING) {
+//???
+ add_assoc_stringl_ex(return_value, str_index->val, str_index->len, result, result_len, 0);
} else {
add_index_stringl(return_value, num_index, result, result_len, 0);
}
- if(Z_TYPE_PP(tmp_str) != IS_STRING) {
+ if(Z_TYPE_P(tmp_str) != IS_STRING) {
zval_dtor(orig_str);
} else {
- Z_SET_ISREF_TO_P(orig_str, was_ref);
+//??? Z_SET_ISREF_TO_P(orig_str, was_ref);
}
- zend_hash_move_forward_ex(Z_ARRVAL_PP(str), &pos_str);
+ zend_hash_move_forward_ex(Z_ARRVAL_P(str), &pos_str);
} /*while*/
} /* if */
}
}
*q = 0;
- RETURN_STRINGL(erealloc(str, q - str + 1), q - str, 0);
+//??? RETURN_STRINGL(erealloc(str, q - str + 1), q - str, 0);
+ RETURN_STRINGL(erealloc(str, q - str + 1), q - str);
}
/* }}} */
temp[0] = (char)c;
temp[1] = '\0';
- RETURN_STRINGL(temp, 1, 1);
+ RETURN_STRINGL(temp, 1);
}
/* }}} */
RETURN_EMPTY_STRING();
}
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
php_ucfirst(Z_STRVAL_P(return_value));
}
/* }}} */
RETURN_EMPTY_STRING();
}
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
php_lcfirst(Z_STRVAL_P(return_value));
}
/* }}} */
RETURN_EMPTY_STRING();
}
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
r = Z_STRVAL_P(return_value);
*r = toupper((unsigned char) *r);
/* {{{ php_strtr_free_strp */
static void php_strtr_free_strp(void *strp)
{
- STR_FREE(*(char**)strp);
+//??? STR_FREE(*(char**)strp);
}
/* }}} */
/* {{{ php_strtr_array_prepare_repls */
{
PATNREPL *patterns;
HashPosition hpos;
- zval **entry;
+ zval *entry;
int num_pats = zend_hash_num_elements(pats),
i;
zend_llist_init(*allocs, sizeof(void*), &php_strtr_free_strp, 0);
for (i = 0, zend_hash_internal_pointer_reset_ex(pats, &hpos);
- zend_hash_get_current_data_ex(pats, (void **)&entry, &hpos) == SUCCESS;
+ (entry = zend_hash_get_current_data_ex(pats, &hpos)) != NULL;
zend_hash_move_forward_ex(pats, &hpos)) {
- char *string_key;
- uint string_key_len;
+ zend_string *string_key;
ulong num_key;
- zval *tzv = NULL;
+ zval tzv;
- switch (zend_hash_get_current_key_ex(pats, &string_key, &string_key_len, &num_key, 0, &hpos)) {
+ switch (zend_hash_get_current_key_ex(pats, &string_key, &num_key, 0, &hpos)) {
case HASH_KEY_IS_LONG:
- string_key_len = 1 + zend_spprintf(&string_key, 0, "%ld", (long)num_key);
+//??? string_key_len = 1 + zend_spprintf(&string_key, 0, "%ld", (long)num_key);
zend_llist_add_element(*allocs, &string_key);
/* break missing intentionally */
case HASH_KEY_IS_STRING:
- string_key_len--; /* exclude final '\0' */
- if (string_key_len == 0) { /* empty string given as pattern */
+ if (string_key->len == 0) { /* empty string given as pattern */
efree(patterns);
zend_llist_destroy(*allocs);
efree(*allocs);
*allocs = NULL;
return NULL;
}
- if (string_key_len > slen) { /* this pattern can never match */
+ if (string_key->len > slen) { /* this pattern can never match */
continue;
}
- if (Z_TYPE_PP(entry) != IS_STRING) {
- tzv = *entry;
- zval_addref_p(tzv);
- SEPARATE_ZVAL(&tzv);
- convert_to_string(tzv);
+ if (Z_TYPE_P(entry) != IS_STRING) {
+ ZVAL_DUP(&tzv, entry);
+ convert_to_string(&tzv);
entry = &tzv;
- zend_llist_add_element(*allocs, &Z_STRVAL_PP(entry));
+ zend_llist_add_element(*allocs, &Z_STRVAL_P(entry));
}
- S(&patterns[i].pat) = string_key;
- L(&patterns[i].pat) = string_key_len;
- S(&patterns[i].repl) = Z_STRVAL_PP(entry);
- L(&patterns[i].repl) = Z_STRLEN_PP(entry);
+ S(&patterns[i].pat) = string_key->val;
+ L(&patterns[i].pat) = string_key->len;
+ S(&patterns[i].repl) = Z_STRVAL_P(entry);
+ L(&patterns[i].repl) = Z_STRLEN_P(entry);
i++;
-
- if (tzv) {
- efree(tzv);
- }
}
}
if (result.c != NULL) {
smart_str_0(&result);
- RETVAL_STRINGL(result.c, result.len, 0);
+//??? RETVAL_STRINGL(result.c, result.len, 0);
+ RETVAL_STRINGL(result.c, result.len);
} else {
RETURN_EMPTY_STRING();
}
Translates characters in str using given translation tables */
PHP_FUNCTION(strtr)
{
- zval **from;
+ zval *from;
char *str, *to = NULL;
int str_len, to_len = 0;
int ac = ZEND_NUM_ARGS();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
return;
}
- if (ac == 2 && Z_TYPE_PP(from) != IS_ARRAY) {
+ if (ac == 2 && Z_TYPE_P(from) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument is not an array");
RETURN_FALSE;
}
}
if (ac == 2) {
- php_strtr_array(return_value, str, str_len, HASH_OF(*from));
+ php_strtr_array(return_value, str, str_len, HASH_OF(from));
} else {
convert_to_string_ex(from);
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
php_strtr(Z_STRVAL_P(return_value),
Z_STRLEN_P(return_value),
- Z_STRVAL_PP(from),
+ Z_STRVAL_P(from),
to,
- MIN(Z_STRLEN_PP(from),
+ MIN(Z_STRLEN_P(from),
to_len));
}
}
*p = '\0';
- RETVAL_STRINGL(n, str_len, 0);
+//??? RETVAL_STRINGL(n, str_len, 0);
+ RETVAL_STRINGL(n, str_len);
}
/* }}} */
PHP_FUNCTION(similar_text)
{
char *t1, *t2;
- zval **percent = NULL;
+ zval *percent = NULL;
int ac = ZEND_NUM_ARGS();
int sim;
int t1_len, t2_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|Z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
return;
}
if (t1_len + t2_len == 0) {
if (ac > 2) {
- Z_DVAL_PP(percent) = 0;
+ Z_DVAL_P(percent) = 0;
}
RETURN_LONG(0);
sim = php_similar_char(t1, t1_len, t2, t2_len);
if (ac > 2) {
- Z_DVAL_PP(percent) = sim * 200.0 / (t1_len + t2_len);
+ Z_DVAL_P(percent) = sim * 200.0 / (t1_len + t2_len);
}
RETURN_LONG(sim);
}
if (what_len == 0) {
- RETURN_STRINGL(str, str_len, 1);
+ RETURN_STRINGL(str, str_len);
}
- Z_STRVAL_P(return_value) = php_addcslashes(str, str_len, &Z_STRLEN_P(return_value), 0, what, what_len TSRMLS_CC);
- RETURN_STRINGL(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), 0);
+//??? Z_STRVAL_P(return_value) = php_addcslashes(str, str_len, &Z_STRLEN_P(return_value), 0, what, what_len TSRMLS_CC);
+//??? RETURN_STRINGL(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), 0);
}
/* }}} */
RETURN_EMPTY_STRING();
}
+//??? RETURN_STRING(php_addslashes(str,
+//??? str_len,
+//??? &Z_STRLEN_P(return_value), 0
+//??? TSRMLS_CC), 0);
RETURN_STRING(php_addslashes(str,
str_len,
&Z_STRLEN_P(return_value), 0
- TSRMLS_CC), 0);
+ TSRMLS_CC));
}
/* }}} */
return;
}
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value));
}
/* }}} */
return;
}
- ZVAL_STRINGL(return_value, str, str_len, 1);
+ ZVAL_STRINGL(return_value, str, str_len);
php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC);
}
/* }}} */
*new_length = newlen;
}
if (should_free) {
- STR_FREE((char*)str);
+//??? STR_FREE((char*)str);
}
return new_str;
}
*target = 0;
*new_length = target - new_str;
if (should_free) {
- STR_FREE(str);
+//??? STR_FREE(str);
}
new_str = (char *) erealloc(new_str, *new_length + 1);
return new_str;
}
if (char_count == 0 && case_sensitivity) {
- ZVAL_STRINGL(result, str, len, 1);
+ ZVAL_STRINGL(result, str, len);
return 0;
}
- Z_STRLEN_P(result) = len + (char_count * (to_len - 1));
- Z_STRVAL_P(result) = target = safe_emalloc(char_count, to_len, len + 1);
- Z_TYPE_P(result) = IS_STRING;
+ ZVAL_STR(result, STR_ALLOC(len + (char_count * (to_len - 1)), 0));
+ target = Z_STRVAL_P(result); //??? = target = safe_emalloc(char_count, to_len, len + 1);
if (case_sensitivity) {
char *p = str, *e = p + len, *s = str;
if (case_sensitivity) {
end = new_str + length;
- for (p = new_str; (r = php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
+ for (p = new_str; (r = (char*)php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
memcpy(r, str, str_len);
if (replace_count) {
(*replace_count)++;
php_strtolower(haystack_dup, length);
php_strtolower(needle_dup, needle_len);
end = haystack_dup + length;
- for (p = haystack_dup; (r = php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
+ for (p = haystack_dup; (r = (char*)php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
memcpy(new_str + (r - haystack_dup), str, str_len);
if (replace_count) {
(*replace_count)++;
}
endp = o + length;
- while ((o = php_memnstr(o, n, needle_len, endp))) {
+ while ((o = (char*)php_memnstr(o, n, needle_len, endp))) {
o += needle_len;
count++;
}
if (case_sensitivity) {
end = haystack + length;
- for (p = haystack; (r = php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
+ for (p = haystack; (r = (char*)php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
memcpy(e, p, r - p);
e += r - p;
memcpy(e, str, str_len);
} else {
end = haystack_dup + length;
- for (p = haystack_dup; (r = php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
+ for (p = haystack_dup; (r = (char*)php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
memcpy(e, haystack + (p - haystack_dup), r - p);
e += r - p;
memcpy(e, str, str_len);
/* {{{ php_str_replace_in_subject
*/
-static void php_str_replace_in_subject(zval *search, zval *replace, zval **subject, zval *result, int case_sensitivity, int *replace_count)
+static void php_str_replace_in_subject(zval *search, zval *replace, zval *subject, zval *result, int case_sensitivity, int *replace_count)
{
- zval **search_entry,
- **replace_entry = NULL,
- temp_result;
+ zval *search_entry,
+ *replace_entry = NULL,
+ temp_result;
char *replace_value = NULL;
int replace_len = 0;
/* Make sure we're dealing with strings. */
convert_to_string_ex(subject);
Z_TYPE_P(result) = IS_STRING;
- if (Z_STRLEN_PP(subject) == 0) {
- ZVAL_STRINGL(result, "", 0, 1);
+ if (Z_STRLEN_P(subject) == 0) {
+ ZVAL_EMPTY_STRING(result);
return;
}
/* If search is an array */
if (Z_TYPE_P(search) == IS_ARRAY) {
/* Duplicate subject string for repeated replacement */
- MAKE_COPY_ZVAL(subject, result);
+ ZVAL_DUP(result, subject);
zend_hash_internal_pointer_reset(Z_ARRVAL_P(search));
}
/* For each entry in the search array, get the entry */
- while (zend_hash_get_current_data(Z_ARRVAL_P(search), (void **) &search_entry) == SUCCESS) {
+ while ((search_entry = zend_hash_get_current_data(Z_ARRVAL_P(search))) != NULL) {
/* Make sure we're dealing with strings. */
SEPARATE_ZVAL(search_entry);
- convert_to_string(*search_entry);
- if (Z_STRLEN_PP(search_entry) == 0) {
+ convert_to_string(search_entry);
+ if (Z_STRLEN_P(search_entry) == 0) {
zend_hash_move_forward(Z_ARRVAL_P(search));
if (Z_TYPE_P(replace) == IS_ARRAY) {
zend_hash_move_forward(Z_ARRVAL_P(replace));
/* If replace is an array. */
if (Z_TYPE_P(replace) == IS_ARRAY) {
/* Get current entry */
- if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
+ if ((replace_entry = zend_hash_get_current_data(Z_ARRVAL_P(replace))) != NULL) {
/* Make sure we're dealing with strings. */
convert_to_string_ex(replace_entry);
/* Set replacement value to the one we got from array */
- replace_value = Z_STRVAL_PP(replace_entry);
- replace_len = Z_STRLEN_PP(replace_entry);
+ replace_value = Z_STRVAL_P(replace_entry);
+ replace_len = Z_STRLEN_P(replace_entry);
zend_hash_move_forward(Z_ARRVAL_P(replace));
} else {
}
}
- if (Z_STRLEN_PP(search_entry) == 1) {
+ if (Z_STRLEN_P(search_entry) == 1) {
php_char_to_str_ex(Z_STRVAL_P(result),
Z_STRLEN_P(result),
- Z_STRVAL_PP(search_entry)[0],
+ Z_STRVAL_P(search_entry)[0],
replace_value,
replace_len,
&temp_result,
case_sensitivity,
replace_count);
- } else if (Z_STRLEN_PP(search_entry) > 1) {
- Z_STRVAL(temp_result) = php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result),
- Z_STRVAL_PP(search_entry), Z_STRLEN_PP(search_entry),
- replace_value, replace_len, &Z_STRLEN(temp_result), case_sensitivity, replace_count);
+ } else if (Z_STRLEN_P(search_entry) > 1) {
+//??? Z_STRVAL(temp_result) = php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result),
+//??? Z_STRVAL_P(search_entry), Z_STRLEN_P(search_entry),
+//??? replace_value, replace_len, &Z_STRLEN(temp_result), case_sensitivity, replace_count);
}
- str_efree(Z_STRVAL_P(result));
- Z_STRVAL_P(result) = Z_STRVAL(temp_result);
- Z_STRLEN_P(result) = Z_STRLEN(temp_result);
+ STR_FREE(Z_STR_P(result));
+ Z_STR_P(result) = Z_STR(temp_result);
if (Z_STRLEN_P(result) == 0) {
return;
}
} else {
if (Z_STRLEN_P(search) == 1) {
- php_char_to_str_ex(Z_STRVAL_PP(subject),
- Z_STRLEN_PP(subject),
+ php_char_to_str_ex(Z_STRVAL_P(subject),
+ Z_STRLEN_P(subject),
Z_STRVAL_P(search)[0],
Z_STRVAL_P(replace),
Z_STRLEN_P(replace),
case_sensitivity,
replace_count);
} else if (Z_STRLEN_P(search) > 1) {
- Z_STRVAL_P(result) = php_str_to_str_ex(Z_STRVAL_PP(subject), Z_STRLEN_PP(subject),
- Z_STRVAL_P(search), Z_STRLEN_P(search),
- Z_STRVAL_P(replace), Z_STRLEN_P(replace), &Z_STRLEN_P(result), case_sensitivity, replace_count);
+//??? Z_STRVAL_P(result) = php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRLEN_P(subject),
+//??? Z_STRVAL_P(search), Z_STRLEN_P(search),
+//??? Z_STRVAL_P(replace), Z_STRLEN_P(replace), &Z_STRLEN_P(result), case_sensitivity, replace_count);
} else {
- MAKE_COPY_ZVAL(subject, result);
+ ZVAL_DUP(result, subject);
}
}
}
*/
static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensitivity)
{
- zval **subject, **search, **replace, **subject_entry, **zcount = NULL;
- zval *result;
- char *string_key;
- uint string_key_len;
+ zval *subject, *search, *replace, *subject_entry, *zcount = NULL;
+ zval result;
+ zend_string *string_key;
ulong num_key;
int count = 0;
int argc = ZEND_NUM_ARGS();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &search, &replace, &subject, &zcount) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &search, &replace, &subject, &zcount) == FAILURE) {
return;
}
SEPARATE_ZVAL(subject);
/* Make sure we're dealing with strings and do the replacement. */
- if (Z_TYPE_PP(search) != IS_ARRAY) {
+ if (Z_TYPE_P(search) != IS_ARRAY) {
convert_to_string_ex(search);
convert_to_string_ex(replace);
- } else if (Z_TYPE_PP(replace) != IS_ARRAY) {
+ } else if (Z_TYPE_P(replace) != IS_ARRAY) {
convert_to_string_ex(replace);
}
/* if subject is an array */
- if (Z_TYPE_PP(subject) == IS_ARRAY) {
+ if (Z_TYPE_P(subject) == IS_ARRAY) {
array_init(return_value);
- zend_hash_internal_pointer_reset(Z_ARRVAL_PP(subject));
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(subject));
/* For each subject entry, convert it to string, then perform replacement
and add the result to the return_value array. */
- while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) {
- if (Z_TYPE_PP(subject_entry) != IS_ARRAY && Z_TYPE_PP(subject_entry) != IS_OBJECT) {
- MAKE_STD_ZVAL(result);
+ while ((subject_entry = zend_hash_get_current_data(Z_ARRVAL_P(subject))) != NULL) {
+ if (Z_TYPE_P(subject_entry) != IS_ARRAY && Z_TYPE_P(subject_entry) != IS_OBJECT) {
SEPARATE_ZVAL(subject_entry);
- php_str_replace_in_subject(*search, *replace, subject_entry, result, case_sensitivity, (argc > 3) ? &count : NULL);
+ php_str_replace_in_subject(search, replace, subject_entry, &result, case_sensitivity, (argc > 3) ? &count : NULL);
} else {
- ALLOC_ZVAL(result);
- Z_ADDREF_P(*subject_entry);
- COPY_PZVAL_TO_ZVAL(*result, *subject_entry);
+ Z_ADDREF_P(subject_entry);
+ COPY_PZVAL_TO_ZVAL(result, subject_entry);
}
/* Add to return array */
- switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(subject), &string_key,
- &string_key_len, &num_key, 0, NULL)) {
+ switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(subject), &string_key,
+ &num_key, 0, NULL)) {
case HASH_KEY_IS_STRING:
- add_assoc_zval_ex(return_value, string_key, string_key_len, result);
+//???
+ add_assoc_zval_ex(return_value, string_key->val, string_key->len, &result);
break;
case HASH_KEY_IS_LONG:
- add_index_zval(return_value, num_key, result);
+ add_index_zval(return_value, num_key, &result);
break;
}
- zend_hash_move_forward(Z_ARRVAL_PP(subject));
+ zend_hash_move_forward(Z_ARRVAL_P(subject));
}
} else { /* if subject is not an array */
- php_str_replace_in_subject(*search, *replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL);
+ php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL);
}
if (argc > 3) {
- zval_dtor(*zcount);
- ZVAL_LONG(*zcount, count);
+ zval_dtor(zcount);
+ ZVAL_LONG(zcount, count);
}
}
/* }}} */
php_char_to_str(broken_str, str_len,'\n', "<br />\n", 7, return_value);
efree(broken_str);
} else {
- Z_STRVAL_P(return_value) = broken_str;
- Z_STRLEN_P(return_value) = str_len;
- Z_TYPE_P(return_value) = IS_STRING;
+//??? RETURN_STRINGL(broken_str, str_len, 0);
+ RETURN_STRINGL(broken_str, str_len);
}
}
/* }}} */
}
if (repl_cnt == 0) {
- RETURN_STRINGL(str, str_len, 1);
+ RETURN_STRINGL(str, str_len);
}
{
*target = '\0';
- RETURN_STRINGL(tmp, new_length, 0);
+//??? RETURN_STRINGL(tmp, new_length, 0);
+ RETURN_STRINGL(tmp, new_length);
}
/* }}} */
{
char *buf;
char *str;
- zval **allow=NULL;
+ zval *allow=NULL;
char *allowed_tags=NULL;
int allowed_tags_len=0;
int str_len;
size_t retval_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|Z", &str, &str_len, &allow) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &str, &str_len, &allow) == FAILURE) {
return;
}
/* To maintain a certain BC, we allow anything for the second parameter and return original string */
if (allow != NULL) {
convert_to_string_ex(allow);
- allowed_tags = Z_STRVAL_PP(allow);
- allowed_tags_len = Z_STRLEN_PP(allow);
+ allowed_tags = Z_STRVAL_P(allow);
+ allowed_tags_len = Z_STRLEN_P(allow);
}
buf = estrndup(str, str_len);
retval_len = php_strip_tags_ex(buf, str_len, NULL, allowed_tags, allowed_tags_len, 0);
- RETURN_STRINGL(buf, retval_len, 0);
+//??? RETURN_STRINGL(buf, retval_len, 0);
+ RETURN_STRINGL(buf, retval_len);
}
/* }}} */
Set locale information */
PHP_FUNCTION(setlocale)
{
- zval ***args = NULL;
- zval **pcategory, **plocale;
+ zval *args = NULL;
+ zval *pcategory, *plocale;
int num_args, cat, i = 0;
char *loc, *retval;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z+", &pcategory, &args, &num_args) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z+", &pcategory, &args, &num_args) == FAILURE) {
return;
}
#ifdef HAVE_SETLOCALE
- if (Z_TYPE_PP(pcategory) == IS_LONG) {
+ if (Z_TYPE_P(pcategory) == IS_LONG) {
convert_to_long_ex(pcategory);
- cat = Z_LVAL_PP(pcategory);
+ cat = Z_LVAL_P(pcategory);
} else {
/* FIXME: The following behaviour should be removed. */
char *category;
php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "Passing locale category name as string is deprecated. Use the LC_* -constants instead");
convert_to_string_ex(pcategory);
- category = Z_STRVAL_PP(pcategory);
+ category = Z_STRVAL_P(pcategory);
if (!strcasecmp("LC_ALL", category)) {
cat = LC_ALL;
}
}
- if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
- zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args[0]));
+ if (Z_TYPE(args[0]) == IS_ARRAY) {
+ zend_hash_internal_pointer_reset(Z_ARRVAL(args[0]));
}
while (1) {
- if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
- if (!zend_hash_num_elements(Z_ARRVAL_PP(args[0]))) {
+ if (Z_TYPE(args[0]) == IS_ARRAY) {
+ if (!zend_hash_num_elements(Z_ARRVAL(args[0]))) {
break;
}
- zend_hash_get_current_data(Z_ARRVAL_PP(args[0]), (void **)&plocale);
+ plocale = zend_hash_get_current_data(Z_ARRVAL(args[0]));
} else {
- plocale = args[i];
+ plocale = &args[i];
}
convert_to_string_ex(plocale);
- if (!strcmp ("0", Z_STRVAL_PP(plocale))) {
+ if (!strcmp ("0", Z_STRVAL_P(plocale))) {
loc = NULL;
} else {
- loc = Z_STRVAL_PP(plocale);
- if (Z_STRLEN_PP(plocale) >= 255) {
+ loc = Z_STRVAL_P(plocale);
+ if (Z_STRLEN_P(plocale) >= 255) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified locale name is too long");
break;
}
if (retval) {
/* Remember if locale was changed */
if (loc) {
- STR_FREE(BG(locale_string));
+//??? STR_FREE(BG(locale_string));
BG(locale_string) = estrdup(retval);
}
if (args) {
efree(args);
}
- RETURN_STRING(retval, 1);
+ RETURN_STRING(retval);
}
- if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
- if (zend_hash_move_forward(Z_ARRVAL_PP(args[0])) == FAILURE) break;
+ if (Z_TYPE(args[0]) == IS_ARRAY) {
+ if (zend_hash_move_forward(Z_ARRVAL(args[0])) == FAILURE) break;
} else {
if (++i >= num_args) break;
}
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
}
- Z_ARRVAL(tmp) = EG(active_symbol_table);
+//??? Z_ARRVAL(tmp) = EG(active_symbol_table);
sapi_module.treat_data(PARSE_STRING, res, &tmp TSRMLS_CC);
} else {
zval ret;
rp = rbuf;
br = 0;
if (allow) {
- if (IS_INTERNED(allow)) {
- allow_free = allow = zend_str_tolower_dup(allow, allow_len);
- } else {
+//??? if (IS_INTERNED(allow)) {
+//??? allow_free = allow = zend_str_tolower_dup(allow, allow_len);
+//??? } else {
allow_free = NULL;
php_strtolower(allow, allow_len);
- }
+//??? }
tbuf = emalloc(PHP_TAG_BUF_SIZE + 1);
tp = tbuf;
} else {
result[result_len] = '\0';
- RETURN_STRINGL(result, result_len, 0);
+//??? RETURN_STRINGL(result, result_len, 0);
+ RETURN_STRINGL(result, result_len);
}
/* }}} */
}
if (mymode >= 3 && mymode <= 4) {
- RETURN_STRINGL(retstr, retlen, 1);
+ RETURN_STRINGL(retstr, retlen);
}
}
/* }}} */
Returns numeric formatting information based on the current locale */
PHP_FUNCTION(localeconv)
{
- zval *grouping, *mon_grouping;
+ zval grouping, mon_grouping;
int len, i;
/* We don't need no stinkin' parameters... */
return;
}
- MAKE_STD_ZVAL(grouping);
- MAKE_STD_ZVAL(mon_grouping);
-
array_init(return_value);
- array_init(grouping);
- array_init(mon_grouping);
+ array_init(&grouping);
+ array_init(&mon_grouping);
#ifdef HAVE_LOCALECONV
{
len = strlen(currlocdata.grouping);
for (i = 0; i < len; i++) {
- add_index_long(grouping, i, currlocdata.grouping[i]);
+ add_index_long(&grouping, i, currlocdata.grouping[i]);
}
/* Grab the monetary grouping data out of the array */
len = strlen(currlocdata.mon_grouping);
for (i = 0; i < len; i++) {
- add_index_long(mon_grouping, i, currlocdata.mon_grouping[i]);
+ add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]);
}
add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point, 1);
/* Ok, it doesn't look like we have locale info floating around, so I guess it
wouldn't hurt to just go ahead and return the POSIX locale information? */
- add_index_long(grouping, 0, -1);
- add_index_long(mon_grouping, 0, -1);
+ add_index_long(&grouping, 0, -1);
+ add_index_long(&mon_grouping, 0, -1);
add_assoc_string(return_value, "decimal_point", "\x2E", 1);
add_assoc_string(return_value, "thousands_sep", "", 1);
add_assoc_long( return_value, "n_sign_posn", CHAR_MAX );
#endif
- zend_hash_update(Z_ARRVAL_P(return_value), "grouping", 9, &grouping, sizeof(zval *), NULL);
- zend_hash_update(Z_ARRVAL_P(return_value), "mon_grouping", 13, &mon_grouping, sizeof(zval *), NULL);
+ zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping);
+ zend_hash_str_update(Z_ARRVAL_P(return_value), "mon_grouping", sizeof("mon_grouping")-1, &mon_grouping);
}
/* }}} */
p++;
}
} else {
- while ((p = php_memnstr(p, needle, needle_len, endp))) {
+ while ((p = (char*)php_memnstr(p, needle, needle_len, endp))) {
p += needle_len;
count++;
}
/* If resulting string turns out to be shorter than input string,
we simply copy the input and return. */
if (pad_length <= 0 || (pad_length - input_len) <= 0) {
- RETURN_STRINGL(input, input_len, 1);
+ RETURN_STRINGL(input, input_len);
}
if (pad_str_len == 0) {
result[result_len] = '\0';
- RETURN_STRINGL(result, result_len, 0);
+//??? RETURN_STRINGL(result, result_len, 0);
+ RETURN_STRINGL(result, result_len);
}
/* }}} */
return;
}
- RETVAL_STRINGL(arg, arglen, 1);
+ RETVAL_STRINGL(arg, arglen);
php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52);
}
return;
}
- RETVAL_STRINGL(arg, arglen, 1);
+ RETVAL_STRINGL(arg, arglen);
if (Z_STRLEN_P(return_value) > 1) {
php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC);
}
}
str[str_len] = 0;
- RETURN_STRINGL(erealloc(str, str_len + 1), str_len, 0);
+//??? RETURN_STRINGL(erealloc(str, str_len + 1), str_len, 0);
+ RETURN_STRINGL(erealloc(str, str_len + 1), str_len);
}
/* }}} */
#endif
for (haystack_ptr = haystack; haystack_ptr < (haystack + haystack_len); ++haystack_ptr) {
for (cl_ptr = char_list; cl_ptr < (char_list + char_list_len); ++cl_ptr) {
if (*cl_ptr == *haystack_ptr) {
- RETURN_STRINGL(haystack_ptr, (haystack + haystack_len - haystack_ptr), 1);
+ RETURN_STRINGL(haystack_ptr, (haystack + haystack_len - haystack_ptr));
}
}
}
projects / php / commitdiff