}
/* }}} */
-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);
}
/* }}} */
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();
}
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);
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;
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;
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;
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;
/* 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(Z_STRVAL_P(arg_ptr));
+ argv[pos++] = estrdup(arg_str->val);
- 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
/* 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++;
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));
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;
}
/* }}} */
-#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 */
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) ||
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);
}
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');
#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;
*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);
-
- if (NULL == (*pretval = pemalloc(Z_STRLEN(zt) + 1, persistent))) {
- return PHP_CONV_ERR_ALLOC;
- }
+ zend_string *str = zval_get_string(tmpval);
- *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;
}
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;
}
#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))
#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. */
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;
}
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;
}
projects / php / commitdiff