archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-15 21:48:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Move more code to use zval_get_string

Browse source
This commit is contained in:
Nikita Popov 2014-04-25 13:23:15 +02:00
parent f979e9afb0
commit b1b7939b0f
5 changed files with 63 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

75
ext/standard/array.c
View file

@ -401,57 +401,30 @@ static int php_array_reverse_data_compare(const void *a, const void *b TSRMLS_DC
}
/* }}} */
static int php_array_natural_general_compare(const void *a, const void *b, int fold_case) /* {{{ */
static int php_array_natural_general_compare(const void *a, const void *b, int fold_case TSRMLS_DC) /* {{{ */
{
Bucket *f, *s;
zval *fval, *sval;
zval first, second;
int result;
Bucket *f = (Bucket *) a;
Bucket *s = (Bucket *) b;
zend_string *str1 = zval_get_string(&f->val);
zend_string *str2 = zval_get_string(&s->val);
f = (Bucket *) a;
s = (Bucket *) b;
fval = &f->val;
sval = &s->val;
ZVAL_DEREF(fval);
ZVAL_DEREF(sval);
ZVAL_COPY_VALUE(&first, fval);
ZVAL_COPY_VALUE(&second, sval);
if (Z_TYPE_P(fval) != IS_STRING) {
zval_copy_ctor(&first);
convert_to_string(&first);
}
if (Z_TYPE_P(sval) != IS_STRING) {
zval_copy_ctor(&second);
convert_to_string(&second);
}
result = strnatcmp_ex(Z_STRVAL(first), Z_STRLEN(first), Z_STRVAL(second), Z_STRLEN(second), fold_case);
if (Z_TYPE_P(fval) != IS_STRING) {
zval_dtor(&first);
}
if (Z_TYPE_P(sval) != IS_STRING) {
zval_dtor(&second);
}
int result = strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, fold_case);
STR_RELEASE(str1);
STR_RELEASE(str2);
return result;
}
/* }}} */
static int php_array_natural_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
{
return php_array_natural_general_compare(a, b, 0);
return php_array_natural_general_compare(a, b, 0 TSRMLS_CC);
}
/* }}} */
static int php_array_natural_case_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
{
return php_array_natural_general_compare(a, b, 1);
return php_array_natural_general_compare(a, b, 1 TSRMLS_CC);
}
/* }}} */
@ -1590,20 +1563,12 @@ PHP_FUNCTION(array_fill_keys)
zval_add_ref(val);
zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val);
} else {
zval key, *key_ptr = entry;
if (Z_TYPE_P(entry) != IS_STRING) {
ZVAL_DUP(&key, entry);
convert_to_string(&key);
key_ptr = &key;
}
zend_string *key = zval_get_string(entry);
zval_add_ref(val);
zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(key_ptr), val);
zend_symtable_update(Z_ARRVAL_P(return_value), key, val);
if (key_ptr != entry) {
zval_dtor(&key);
}
STR_RELEASE(key);
}
} ZEND_HASH_FOREACH_END();
}
@ -4601,20 +4566,12 @@ PHP_FUNCTION(array_combine)
zval_add_ref(entry_values);
add_index_zval(return_value, Z_LVAL_P(entry_keys), entry_values);
} else {
zval key, *key_ptr = entry_keys;
if (Z_TYPE_P(entry_keys) != IS_STRING) {
ZVAL_DUP(&key, entry_keys);
convert_to_string(&key);
key_ptr = &key;
}
zend_string *key = zval_get_string(entry_keys);
zval_add_ref(entry_values);
zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(key_ptr), entry_values);
zend_symtable_update(Z_ARRVAL_P(return_value), key, entry_values);
if (key_ptr != entry_keys) {
zval_dtor(&key);
}
STR_RELEASE(key);
}
zend_hash_move_forward_ex(Z_ARRVAL_P(keys), &pos_keys);

20
ext/standard/assert.c
View file

@ -269,10 +269,11 @@ PHP_FUNCTION(assert_options)
case ASSERT_ACTIVE:
oldint = ASSERTG(active);
if (ac == 2) {
convert_to_string_ex(value);
zend_string *value_str = zval_get_string(value);
key = STR_INIT("assert.active", sizeof("assert.active")-1, 0);
zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
zend_alter_ini_entry_ex(key, value_str->val, value_str->len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
STR_RELEASE(key);
STR_RELEASE(value_str);
}
RETURN_LONG(oldint);
break;
@ -280,10 +281,11 @@ PHP_FUNCTION(assert_options)
case ASSERT_BAIL:
oldint = ASSERTG(bail);
if (ac == 2) {
convert_to_string_ex(value);
zend_string *value_str = zval_get_string(value);
key = STR_INIT("assert.bail", sizeof("assert.bail")-1, 0);
zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
zend_alter_ini_entry_ex(key, value_str->val, value_str->len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
STR_RELEASE(key);
STR_RELEASE(value_str);
}
RETURN_LONG(oldint);
break;
@ -291,10 +293,11 @@ PHP_FUNCTION(assert_options)
case ASSERT_QUIET_EVAL:
oldint = ASSERTG(quiet_eval);
if (ac == 2) {
convert_to_string_ex(value);
zend_string *value_str = zval_get_string(value);
key = STR_INIT("assert.quiet_eval", sizeof("assert.quiet_eval")-1, 0);
zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
zend_alter_ini_entry_ex(key, value_str->val, value_str->len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
STR_RELEASE(key);
STR_RELEASE(value_str);
}
RETURN_LONG(oldint);
break;
@ -302,10 +305,11 @@ PHP_FUNCTION(assert_options)
case ASSERT_WARNING:
oldint = ASSERTG(warning);
if (ac == 2) {
convert_to_string_ex(value);
zend_string *value_str = zval_get_string(value);
key = STR_INIT("assert.warning", sizeof("assert.warning")-1, 0);
zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
zend_alter_ini_entry_ex(key, value_str->val, value_str->len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
STR_RELEASE(key);
STR_RELEASE(value_str);
}
RETURN_LONG(oldint);
break;

28
ext/standard/basic_functions.c
View file

@ -4241,19 +4241,11 @@ PHP_FUNCTION(getopt)
/* Iterate over the hash to construct the argv array. */
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(args), entry) {
zval arg, *arg_ptr = entry;
zend_string *arg_str = zval_get_string(entry);
if (Z_TYPE_P(entry) != IS_STRING) {
ZVAL_DUP(&arg, entry);
convert_to_string(&arg);
arg_ptr = &arg;
}
argv[pos++] = estrdup(arg_str->val);
argv[pos++] = estrdup(Z_STRVAL_P(arg_ptr));
if (arg_ptr != entry) {
zval_dtor(&arg);
}
STR_RELEASE(arg_str);
} ZEND_HASH_FOREACH_END();
/* The C Standard requires argv[argc] to be NULL - this might
@ -4282,16 +4274,10 @@ PHP_FUNCTION(getopt)
/* Iterate over the hash to construct the argv array. */
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(p_longopts), entry) {
zval arg, *arg_ptr = entry;
if (Z_TYPE_P(entry) != IS_STRING) {
ZVAL_DUP(&arg, entry);
convert_to_string(&arg);
arg_ptr = &arg;
}
zend_string *arg_str = zval_get_string(entry);
opts->need_param = 0;
opts->opt_name = estrdup(Z_STRVAL_P(arg_ptr));
opts->opt_name = estrdup(arg_str->val);
len = strlen(opts->opt_name);
if ((len > 0) && (opts->opt_name[len - 1] == ':')) {
opts->need_param++;
@ -4304,9 +4290,7 @@ PHP_FUNCTION(getopt)
opts->opt_char = 0;
opts++;
if (arg_ptr != entry) {
zval_dtor(&arg);
}
STR_RELEASE(arg_str);
} ZEND_HASH_FOREACH_END();
} else {
opts = (opt_struct*) erealloc(opts, sizeof(opt_struct) * (len + 1));

39
ext/standard/file.c
View file

@ -653,23 +653,21 @@ PHP_FUNCTION(file_put_contents)
zval *tmp;
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), tmp) {
if (Z_TYPE_P(tmp) != IS_STRING) {
SEPARATE_ZVAL(tmp);
convert_to_string(tmp);
}
if (Z_STRLEN_P(tmp)) {
numbytes += Z_STRLEN_P(tmp);
bytes_written = php_stream_write(stream, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
if (bytes_written < 0 || bytes_written != Z_STRLEN_P(tmp)) {
zend_string *str = zval_get_string(tmp);
if (str->len) {
numbytes += str->len;
bytes_written = php_stream_write(stream, str->val, str->len);
if (bytes_written < 0 || bytes_written != str->len) {
if (bytes_written < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %d bytes to %s", Z_STRLEN_P(tmp), filename);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %d bytes to %s", str->len, filename);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %d of %d bytes written, possibly out of free disk space", bytes_written, Z_STRLEN_P(tmp));
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %d of %d bytes written, possibly out of free disk space", bytes_written, str->len);
}
numbytes = -1;
break;
}
}
STR_RELEASE(str);
} ZEND_HASH_FOREACH_END();
}
break;
@ -1813,7 +1811,7 @@ quit_loop:
}
/* }}} */
#define FPUTCSV_FLD_CHK(c) memchr(Z_STRVAL(field), c, Z_STRLEN(field))
#define FPUTCSV_FLD_CHK(c) memchr(field_str->val, c, field_str->len)
/* {{{ proto int fputcsv(resource fp, array fields [, string delimiter [, string enclosure [, string escape_char]]])
Format line as CSV and write to file pointer */
@ -1881,17 +1879,12 @@ PHP_FUNCTION(fputcsv)
PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC)
{
int count, i = 0, ret;
zval *field_tmp = NULL, field;
zval *field_tmp;
smart_str csvline = {0};
count = zend_hash_num_elements(Z_ARRVAL_P(fields));
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(fields), field_tmp) {
ZVAL_COPY_VALUE(&field, field_tmp);
if (Z_TYPE(field) != IS_STRING) {
zval_copy_ctor(&field);
convert_to_string(&field);
}
zend_string *field_str = zval_get_string(field_tmp);
/* enclose a field that contains a delimiter, an enclosure character, or a newline */
if (FPUTCSV_FLD_CHK(delimiter) ||
@ -1902,8 +1895,8 @@ PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char en
FPUTCSV_FLD_CHK('\t') ||
FPUTCSV_FLD_CHK(' ')
) {
char *ch = Z_STRVAL(field);
char *end = ch + Z_STRLEN(field);
char *ch = field_str->val;
char *end = ch + field_str->len;
int escaped = 0;
smart_str_appendc(&csvline, enclosure);
@ -1920,15 +1913,13 @@ PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char en
}
smart_str_appendc(&csvline, enclosure);
} else {
smart_str_appendl(&csvline, Z_STRVAL(field), Z_STRLEN(field));
smart_str_appendl(&csvline, field_str->val, field_str->len);
}
if (++i != count) {
smart_str_appendl(&csvline, &delimiter, 1);
}
if (Z_TYPE_P(field_tmp) != IS_STRING) {
zval_dtor(&field);
}
STR_RELEASE(field_str);
} ZEND_HASH_FOREACH_END();
smart_str_appendc(&csvline, '\n');

39
ext/standard/filters.c
View file

@ -1208,7 +1208,7 @@ typedef struct _php_convert_filter {
#define PHP_CONV_QPRINT_ENCODE 3
#define PHP_CONV_QPRINT_DECODE 4
static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pretval, size_t *pretval_len, char *field_name, size_t field_name_len, int persistent)
static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pretval, size_t *pretval_len, char *field_name, size_t field_name_len, int persistent TSRMLS_DC)
{
zval *tmpval;
@ -1216,26 +1216,15 @@ static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pr
*pretval_len = 0;
if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) {
if (Z_TYPE_P(tmpval) != IS_STRING) {
zval zt;
ZVAL_COPY_VALUE(&zt, tmpval);
convert_to_string(&zt);
zend_string *str = zval_get_string(tmpval);
if (NULL == (*pretval = pemalloc(Z_STRLEN(zt) + 1, persistent))) {
return PHP_CONV_ERR_ALLOC;
}
*pretval_len = Z_STRLEN(zt);
memcpy(*pretval, Z_STRVAL(zt), Z_STRLEN(zt) + 1);
zval_dtor(&zt);
} else {
if (NULL == (*pretval = pemalloc(Z_STRLEN_P(tmpval) + 1, persistent))) {
return PHP_CONV_ERR_ALLOC;
}
*pretval_len = Z_STRLEN_P(tmpval);
memcpy(*pretval, Z_STRVAL_P(tmpval), Z_STRLEN_P(tmpval) + 1);
if (NULL == (*pretval = pemalloc(str->len + 1, persistent))) {
return PHP_CONV_ERR_ALLOC;
}
*pretval_len = str->len;
memcpy(*pretval, str->val, str->len + 1);
STR_RELEASE(str);
} else {
return PHP_CONV_ERR_NOT_FOUND;
}
@ -1331,7 +1320,7 @@ static int php_conv_get_int_prop_ex(const HashTable *ht, int *pretval, char *fie
static int php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval, char *field_name, size_t field_name_len)
{
long l;
unsigned long l;
php_conv_err_t err;
*pretval = 0;
@ -1343,7 +1332,7 @@ static int php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval,
}
#define GET_STR_PROP(ht, var, var_len, fldname, persistent) \
php_conv_get_string_prop_ex(ht, &var, &var_len, fldname, sizeof(fldname), persistent)
php_conv_get_string_prop_ex(ht, &var, &var_len, fldname, sizeof(fldname), persistent TSRMLS_CC)
#define GET_INT_PROP(ht, var, fldname) \
php_conv_get_int_prop_ex(ht, &var, fldname, sizeof(fldname))
@ -1354,7 +1343,7 @@ static int php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval,
#define GET_BOOL_PROP(ht, var, fldname) \
php_conv_get_bool_prop_ex(ht, &var, fldname, sizeof(fldname))
static php_conv *php_conv_open(int conv_mode, const HashTable *options, int persistent)
static php_conv *php_conv_open(int conv_mode, const HashTable *options, int persistent TSRMLS_DC)
{
/* FIXME: I'll have to replace this ugly code by something neat
(factories?) in the near future. */
@ -1490,13 +1479,13 @@ out_failure:
static int php_convert_filter_ctor(php_convert_filter *inst,
int conv_mode, HashTable *conv_opts,
const char *filtername, int persistent)
const char *filtername, int persistent TSRMLS_DC)
{
inst->persistent = persistent;
inst->filtername = pestrdup(filtername, persistent);
inst->stub_len = 0;
if ((inst->cd = php_conv_open(conv_mode, conv_opts, persistent)) == NULL) {
if ((inst->cd = php_conv_open(conv_mode, conv_opts, persistent TSRMLS_CC)) == NULL) {
goto out_failure;
}
@ -1822,7 +1811,7 @@ static php_stream_filter *strfilter_convert_create(const char *filtername, zval
if (php_convert_filter_ctor(inst, conv_mode,
(filterparams != NULL ? Z_ARRVAL_P(filterparams) : NULL),
filtername, persistent) != SUCCESS) {
filtername, persistent TSRMLS_CC) != SUCCESS) {
goto out;
}