return 1;
}
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **callable_name, int *callable_name_len, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC)
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, zval *callable_name, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC)
{
unsigned int lcname_len;
char *lcname;
zend_bool retval = 0;
- int callable_name_len_local;
zend_function *fptr_local;
zval **zobj_ptr_local;
- if (callable_name_len == NULL) {
- callable_name_len = &callable_name_len_local;
- }
if (fptr_ptr == NULL) {
fptr_ptr = &fptr_local;
}
case IS_STRING:
case IS_UNICODE:
if (callable_name) {
- /* UTODO: we need to return callable name type as well */
- if (Z_TYPE_P(callable) == IS_UNICODE) {
- *callable_name = (char*)eustrndup(Z_USTRVAL_P(callable), Z_USTRLEN_P(callable));
- } else {
- *callable_name = estrndup(Z_STRVAL_P(callable), Z_STRLEN_P(callable));
- }
- *callable_name_len = Z_UNILEN_P(callable);
+ *callable_name = *callable;
+ zval_copy_ctor(callable_name);
+ convert_to_text(callable_name);
}
if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) {
return 1;
if (Z_TYPE_PP(obj) == IS_STRING || Z_TYPE_PP(obj) == IS_UNICODE) {
if (callable_name) {
- char *ptr;
-
- *callable_name_len = Z_STRLEN_PP(obj) + Z_STRLEN_PP(method) + sizeof("::") - 1;
- ptr = *callable_name = emalloc(*callable_name_len + 1);
- memcpy(ptr, Z_STRVAL_PP(obj), Z_STRLEN_PP(obj));
- ptr += Z_STRLEN_PP(obj);
- memcpy(ptr, "::", sizeof("::") - 1);
- ptr += sizeof("::") - 1;
- memcpy(ptr, Z_STRVAL_PP(method), Z_STRLEN_PP(method) + 1);
+ if (UG(unicode)) {
+ Z_TYPE_P(callable_name) = IS_UNICODE;
+ Z_USTRLEN_P(callable_name) = Z_UNILEN_PP(obj) + Z_UNILEN_PP(method) + 2;
+ Z_USTRVAL_P(callable_name) = eumalloc(Z_USTRLEN_P(callable_name)+1);
+ if (Z_TYPE_PP(obj) == IS_UNICODE) {
+ memcpy(Z_USTRVAL_P(callable_name), Z_USTRVAL_PP(obj), UBYTES(Z_USTRLEN_PP(obj)));
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_unicode_zval(*obj, ©, &use_copy);
+ memcpy(Z_USTRVAL_P(callable_name), Z_USTRVAL(copy), UBYTES(Z_USTRLEN(copy)));
+ zval_dtor(©);
+ }
+ Z_USTRVAL_P(callable_name)[Z_UNILEN_PP(obj)] = ':';
+ Z_USTRVAL_P(callable_name)[Z_UNILEN_PP(obj)+1] = ':';
+ if (Z_TYPE_PP(method) == IS_UNICODE) {
+ memcpy(Z_USTRVAL_P(callable_name)+Z_UNILEN_PP(obj)+2, Z_USTRVAL_PP(method), UBYTES(Z_USTRLEN_PP(method)+1));
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_unicode_zval(*method, ©, &use_copy);
+ memcpy(Z_USTRVAL_P(callable_name)+Z_UNILEN_PP(obj)+2, Z_USTRVAL(copy), UBYTES(Z_USTRLEN(copy)+1));
+ zval_dtor(©);
+ }
+ } else {
+ Z_TYPE_P(callable_name) = IS_STRING;
+ Z_STRLEN_P(callable_name) = Z_UNILEN_PP(obj) + Z_UNILEN_PP(method) + 2;
+ Z_STRVAL_P(callable_name) = emalloc(Z_STRLEN_P(callable_name)+1);
+ if (Z_TYPE_PP(obj) == IS_STRING) {
+ memcpy(Z_STRVAL_P(callable_name), Z_STRVAL_PP(obj), Z_STRLEN_PP(obj));
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_string_zval(*obj, ©, &use_copy);
+ memcpy(Z_STRVAL_P(callable_name), Z_STRVAL(copy), Z_STRLEN(copy));
+ zval_dtor(©);
+ }
+ Z_STRVAL_P(callable_name)[Z_UNILEN_PP(obj)] = ':';
+ Z_STRVAL_P(callable_name)[Z_UNILEN_PP(obj)+1] = ':';
+ if (Z_TYPE_PP(method) == IS_STRING) {
+ memcpy(Z_STRVAL_P(callable_name)+Z_UNILEN_PP(obj)+2, Z_STRVAL_PP(method), Z_STRLEN_PP(method)+1);
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_string_zval(*method, ©, &use_copy);
+ memcpy(Z_STRVAL_P(callable_name)+Z_UNILEN_PP(obj)+2, Z_STRVAL(copy), Z_STRLEN(copy)+1);
+ zval_dtor(©);
+ }
+ }
}
if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY)
*zobj_ptr_ptr = obj;
if (callable_name) {
- char *ptr;
-
- *callable_name_len = ce->name_length + Z_STRLEN_PP(method) + sizeof("::") - 1;
- ptr = *callable_name = emalloc(*callable_name_len + 1);
- memcpy(ptr, ce->name, ce->name_length);
- ptr += ce->name_length;
- memcpy(ptr, "::", sizeof("::") - 1);
- ptr += sizeof("::") - 1;
- memcpy(ptr, Z_STRVAL_PP(method), Z_STRLEN_PP(method) + 1);
+ if (UG(unicode)) {
+ Z_TYPE_P(callable_name) = IS_UNICODE;
+ Z_USTRLEN_P(callable_name) = ce->name_length + Z_UNILEN_PP(method) + 2;
+ Z_USTRVAL_P(callable_name) = eumalloc(Z_USTRLEN_P(callable_name)+1);
+ memcpy(Z_USTRVAL_P(callable_name), ce->name, UBYTES(ce->name_length));
+ Z_USTRVAL_P(callable_name)[ce->name_length] = ':';
+ Z_USTRVAL_P(callable_name)[ce->name_length+1] = ':';
+ if (Z_TYPE_PP(method) == IS_UNICODE) {
+ memcpy(Z_USTRVAL_P(callable_name)+ce->name_length+2, Z_USTRVAL_PP(method), UBYTES(Z_USTRLEN_PP(method)+1));
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_unicode_zval(*method, ©, &use_copy);
+ memcpy(Z_USTRVAL_P(callable_name)+ce->name_length+2, Z_USTRVAL(copy), UBYTES(Z_USTRLEN(copy)+1));
+ zval_dtor(©);
+ }
+ } else {
+ Z_TYPE_P(callable_name) = IS_STRING;
+ Z_STRLEN_P(callable_name) = ce->name_length + Z_UNILEN_PP(method) + 2;
+ Z_STRVAL_P(callable_name) = emalloc(Z_STRLEN_P(callable_name)+1);
+ memcpy(Z_STRVAL_P(callable_name), ce->name, ce->name_length);
+ Z_STRVAL_P(callable_name)[ce->name_length] = ':';
+ Z_STRVAL_P(callable_name)[ce->name_length+1] = ':';
+ if (Z_TYPE_PP(method) == IS_STRING) {
+ memcpy(Z_STRVAL_P(callable_name)+ce->name_length+2, Z_STRVAL_PP(method), Z_STRLEN_PP(method)+1);
+ } else {
+ zval copy;
+ int use_copy;
+
+ zend_make_string_zval(*method, ©, &use_copy);
+ memcpy(Z_STRVAL_P(callable_name)+ce->name_length+2, Z_STRVAL(copy), Z_STRLEN(copy)+1);
+ zval_dtor(©);
+ }
+ }
}
if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY)
efree(lcname);
}
} else if (callable_name) {
- *callable_name = estrndup("Array", sizeof("Array")-1);
- *callable_name_len = sizeof("Array") - 1;
+ ZVAL_ASCII_STRINGL(callable_name, "Array", sizeof("Array")-1, 1);
}
}
break;
default:
if (callable_name) {
- zval expr_copy;
- int use_copy;
-
- zend_make_printable_zval(callable, &expr_copy, &use_copy);
- *callable_name = estrndup(Z_STRVAL(expr_copy), Z_STRLEN(expr_copy));
- *callable_name_len = Z_STRLEN(expr_copy);
- zval_dtor(&expr_copy);
+ *callable_name = *callable;
+ zval_copy_ctor(callable_name);
+ convert_to_text(callable_name);
}
break;
}
}
-ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name)
+ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, zval *callable_name)
{
TSRMLS_FETCH();
- return zend_is_callable_ex(callable, check_flags, callable_name, NULL, NULL, NULL TSRMLS_CC);
+ return zend_is_callable_ex(callable, check_flags, callable_name, NULL, NULL TSRMLS_CC);
}
-ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC)
+ZEND_API zend_bool zend_make_callable(zval *callable, zval *callable_name TSRMLS_DC)
{
char *lcname, *func, *class_name;
zend_bool retval = 0;
zend_class_entry **pce;
int class_name_len;
- if (zend_is_callable_ex(callable, 0, callable_name, NULL, NULL, NULL TSRMLS_CC)) {
+ if (zend_is_callable_ex(callable, 0, callable_name, NULL, NULL TSRMLS_CC)) {
return 1;
}
switch (Z_TYPE_P(callable)) {
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
-ZEND_API void zend_update_property_unicode(zend_class_entry *scope, zval *object, UChar *name, int name_length, char *value TSRMLS_DC)
+ZEND_API void zend_update_property_unicode(zend_class_entry *scope, zval *object, char *name, int name_length, UChar *value TSRMLS_DC)
{
zval *tmp;
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
-ZEND_API void zend_update_property_unicodel(zend_class_entry *scope, zval *object, UChar *name, int name_length, char *value, int value_len TSRMLS_DC)
+ZEND_API void zend_update_property_unicodel(zend_class_entry *scope, zval *object, char *name, int name_length, UChar *value, int value_len TSRMLS_DC)
{
zval *tmp;
#define IS_CALLABLE_CHECK_NO_ACCESS (1<<1)
#define IS_CALLABLE_CHECK_IS_STATIC (1<<2)
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **callable_name, int *callable_name_len, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC);
-ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name);
-ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, zval *callable_name, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, zval *callable_name);
+ZEND_API zend_bool zend_make_callable(zval *callable, zval *callable_name TSRMLS_DC);
ZEND_API char *zend_get_module_version(char *module_name);
ZEND_API int zend_get_module_started(char *module_name);
ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC);
ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, char *name, int name_length, double value TSRMLS_DC);
ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, char *name, int name_length, char *value TSRMLS_DC);
ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, char *name, int name_length, char *value, int value_length TSRMLS_DC);
-ZEND_API void zend_update_property_unicode(zend_class_entry *scope, zval *object, UChar *name, int name_length, char *value TSRMLS_DC);
-ZEND_API void zend_update_property_unicodel(zend_class_entry *scope, zval *object, UChar *name, int name_length, char *value, int value_length TSRMLS_DC);
+ZEND_API void zend_update_property_unicode(zend_class_entry *scope, zval *object, char *name, int name_length, UChar *value TSRMLS_DC);
+ZEND_API void zend_update_property_unicodel(zend_class_entry *scope, zval *object, char *name, int name_length, UChar *value, int value_length TSRMLS_DC);
ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *name, int name_length, zend_bool silent TSRMLS_DC);
{
zval *error_handler;
zend_bool had_orig_error_handler=0;
- char *error_handler_name = NULL;
+ zval error_handler_name;
long error_type = E_ALL | E_STRICT;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
}
if (!zend_is_callable(error_handler, 0, &error_handler_name)) {
- zend_error(E_WARNING, "%v() expects the argument (%s) to be a valid callback",
- get_active_function_name(TSRMLS_C), error_handler_name?error_handler_name:"unknown");
- efree(error_handler_name);
+ zend_error(E_WARNING, "%v() expects the argument (%R) to be a valid callback",
+ get_active_function_name(TSRMLS_C), Z_TYPE(error_handler_name), Z_UNIVAL(error_handler_name));
+ zval_dtor(&error_handler_name);
return;
}
- efree(error_handler_name);
+ zval_dtor(&error_handler_name);
if (EG(user_error_handler)) {
had_orig_error_handler = 1;
ZEND_FUNCTION(set_exception_handler)
{
zval **exception_handler;
- char *exception_handler_name = NULL;
+ zval exception_handler_name;
zend_bool had_orig_exception_handler=0;
if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &exception_handler)==FAILURE) {
if (Z_TYPE_PP(exception_handler) != IS_NULL) { /* NULL == unset */
if (!zend_is_callable(*exception_handler, 0, &exception_handler_name)) {
- zend_error(E_WARNING, "%v() expects the argument (%s) to be a valid callback",
- get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name:"unknown");
- efree(exception_handler_name);
+ zend_error(E_WARNING, "%v() expects the argument (%R) to be a valid callback",
+ get_active_function_name(TSRMLS_C), Z_TYPE(exception_handler_name), Z_UNIVAL(exception_handler_name));
+ zval_dtor(&exception_handler_name);
return;
}
- efree(exception_handler_name);
+ zval_dtor(&exception_handler_name);
}
if (EG(user_exception_handler)) {
array_init(params_array);
call_via_handler = 1;
} else {
+ if (old_func_name) {
+ efree(Z_STRVAL_P(fci->function_name));
+ Z_TYPE_P(fci->function_name) = IS_STRING;
+ Z_STRVAL_P(fci->function_name) = old_func_name;
+ }
return FAILURE;
}
}
zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) (long) i, NULL);
zend_ptr_stack_clear_multiple(TSRMLS_C);
}
+ if (old_func_name) {
+ efree(Z_STRVAL_P(fci->function_name));
+ Z_TYPE_P(fci->function_name) = IS_STRING;
+ Z_STRVAL_P(fci->function_name) = old_func_name;
+ }
return FAILURE;
}
ALLOC_ZVAL(new_zval);
retval = zend_call_function(&fcall_info, &fcall_cache TSRMLS_CC);
EG(autoload_func) = fcall_cache.function_handler;
- if (UG(unicode)) {
- zval_dtor(&autoload_function);
- }
-
zval_ptr_dtor(&class_name_ptr);
zend_u_hash_del(EG(in_autoload), type, lc_name, lc_name_len+1);
zval *userdata = NULL;
FDFDoc fdf;
FDFErc err;
- char *name;
+ zval name;
char namebuf[1024], valbuf[1024];
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &r_fdf,
ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
if (!zend_is_callable(callback, 0, &name)) {
- php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "Second argument is expected to be a valid callback");
- efree(name);
+ convert_to_string(&name);
+ php_error_docref1(NULL TSRMLS_CC, Z_STRVAL(name), E_WARNING, "Second argument is expected to be a valid callback");
+ zval_ptr_dtor(&name);
RETURN_FALSE;
}
- efree(name);
+ zval_ptr_dtor(&name);
FDF_G(enum_callback) = callback;
FDF_G(enum_fdf) = fdf;
{
zval *link, *callback;
ldap_linkdata *ld;
- char *callback_name;
+ zval callback_name;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &link, &callback) == FAILURE) {
RETURN_FALSE;
/* callable? */
if (!zend_is_callable(callback, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Two arguments expected for '%s' to be a valid callback", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Two arguments expected for '%R' to be a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
/* register rebind procedure */
if (ld->rebindproc == NULL) {
{
MY_MYSQL *mysql;
zval *mysql_link;
- char *callback_name;
+ zval callback_name;
zval *callback_func;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oz", &mysql_link, mysqli_link_class_entry,
/* check callback function */
if (!zend_is_callable(callback_func, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
/* save callback function */
ALLOC_ZVAL(mysql->li_read);
PHP_FUNCTION(pcntl_signal)
{
zval *handle, **dest_handle = NULL;
- char *func_name;
+ zval func_name;
long signo;
zend_bool restart_syscalls = 1;
}
if (!zend_is_callable(handle, 0, &func_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a callable function name error", func_name);
- efree(func_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "%R is not a callable function name error", Z_TYPE(func_name), Z_UNIVAL(func_name));
+ zval_dtor(&func_name);
RETURN_FALSE;
}
- efree(func_name);
+ zval_dtor(&func_name);
/* Add the function name to our signal table */
zend_hash_index_update(&PCNTL_G(php_signal_table), signo, (void **) &handle, sizeof(zval *), (void **) &dest_handle);
int limit_val = -1;
char *string_key;
ulong num_key;
- char *callback_name = NULL;
+ zval callback_name;
int replace_count=0;
int *replace_count_ptr=NULL;
convert_to_string_ex(replace);
if (is_callable_replace) {
if (!zend_is_callable(*replace, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "requires argument 2, '%s', to be a valid callback", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "requires argument 2, '%R', to be a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
*return_value = **subject;
zval_copy_ctor(return_value);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
}
SEPARATE_ZVAL(regex);
static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info * fci, zend_fcall_info_cache * fcc, int num_args TSRMLS_DC) /* {{{ */
{
zval **object = NULL, **method;
- char *fname;
zend_class_entry * ce = NULL, **pce;
zend_function *function_handler;
method = &callable;
}
- if (!zend_is_callable(callable, 0, &fname)) {
+ if (!zend_is_callable(callable, 0, NULL)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied function must be a valid callback" TSRMLS_CC);
return 0;
}
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied function does not exist" TSRMLS_CC);
return 0;
}
- efree(fname);
fci->size = sizeof(zend_fcall_info);
fci->function_name = NULL;
char *func_name;
int func_name_len;
long argc = -1;
- char *cbname = NULL;
+ zval cbname;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (!zend_is_callable(callback, 0, &cbname)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
- efree(cbname);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%R' is not callable", Z_TYPE(cbname), Z_UNIVAL(cbname));
+ zval_dtor(&cbname);
RETURN_FALSE;
}
- efree(cbname);
+ zval_dtor(&cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
char *func_name;
int func_name_len;
long argc = -1;
- char *cbname = NULL;
+ zval cbname;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (!zend_is_callable(step_callback, 0, &cbname)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
- efree(cbname);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%R' is not callable", Z_TYPE(cbname), Z_UNIVAL(cbname));
+ zval_dtor(&cbname);
RETURN_FALSE;
}
- efree(cbname);
+ zval_dtor(&cbname);
if (!zend_is_callable(fini_callback, 0, &cbname)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
- efree(cbname);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%R' is not callable", Z_TYPE(cbname), Z_UNIVAL(cbname));
+ zval_dtor(&cbname);
RETURN_FALSE;
}
- efree(cbname);
+ zval_dtor(&cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
PHP_FUNCTION(readline_completion_function)
{
zval *arg = NULL;
- char *name = NULL;
+ zval name;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg)) {
RETURN_FALSE;
}
if (!zend_is_callable(arg, 0, &name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not callable", name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "%R is not callable", Z_TYPE(name), Z_UNIVAL(name));
+ zval_dtor(&name);
RETURN_FALSE;
}
+ zval_dtor(&name);
if (_readline_completion)
FREE_ZVAL(_readline_completion);
PHP_FUNCTION(readline_callback_handler_install)
{
zval *callback;
- char *name = NULL;
+ zval name;
char *prompt;
int prompt_len;
}
if (!zend_is_callable(callback, 0, &name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not callable", name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "%R is not callable", Z_TYPE(name), Z_UNIVAL(name));
+ zval_dtor(&name);
RETURN_FALSE;
}
+ zval_dtor(&name);
if (_prepped_callback) {
rl_callback_handler_remove();
zval **args[6];
int i;
ps_user *mdata;
- char *name;
+ zval name;
if (ZEND_NUM_ARGS() != 6 || zend_get_parameters_array_ex(6, args) == FAILURE)
WRONG_PARAM_COUNT;
for (i = 0; i < 6; i++) {
if (!zend_is_callable(*args[i], 0, &name)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument %d is not a valid callback", i+1);
- efree(name);
+ zval_dtor(&name);
RETURN_FALSE;
}
- efree(name);
+ zval_dtor(&name);
}
zend_alter_ini_entry("session.save_handler", sizeof("session.save_handler"), "user", sizeof("user")-1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
Register given function as __autoload() implementation */
PHP_FUNCTION(spl_autoload_register)
{
- char *func_name = NULL, *lc_name = NULL;
+ char *func_name;
+ uint func_name_len;
+ char *lc_name = NULL;
zval *zcallable = NULL;
- int func_name_len;
zend_bool do_throw = 1;
zend_function *spl_func_ptr;
autoload_func_info alfi;
zval **obj_ptr;
+ zend_uchar func_name_type;
+
+ if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|tb", &func_name, &func_name_len, &func_name_type, &do_throw) == FAILURE) {
+ zval func_name;
- if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|sb", &func_name, &func_name_len, &do_throw) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &zcallable, &func_name_len, &do_throw) == FAILURE) {
return;
}
- if (!zend_is_callable_ex(zcallable, 0, &func_name, &func_name_len, &alfi.func_ptr, &obj_ptr TSRMLS_CC)) {
+ if (!zend_is_callable_ex(zcallable, 0, &func_name, &alfi.func_ptr, &obj_ptr TSRMLS_CC)) {
if (do_throw) {
zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Passed array does not specify a callable static method");
}
- if (func_name) {
- efree(func_name);
- }
+ zval_dtor(&func_name);
return;
} else if (!obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
if (do_throw) {
zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Passed array specifies a non static method but no object");
}
- if (func_name) {
- efree(func_name);
- }
+ zval_dtor(&func_name);
return;
}
- lc_name = do_alloca(func_name_len + 1);
- zend_str_tolower_copy(lc_name, func_name, func_name_len);
- if (func_name) {
- efree(func_name);
- }
+ func_name_type = Z_TYPE(func_name);
+ func_name_len = Z_UNILEN(func_name);
+ lc_name = zend_u_str_tolower_dup(func_name_type, Z_UNIVAL(func_name), func_name_len);
+ zval_dtor(&func_name);
if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
alfi.obj = *obj_ptr;
alfi.obj->refcount++;
alfi.ce = NULL;
}
} else if (ZEND_NUM_ARGS()) {
- lc_name = do_alloca(func_name_len + 1);
- zend_str_tolower_copy(lc_name, func_name, func_name_len);
+ lc_name = zend_u_str_tolower_dup(func_name_type, func_name, func_name_len);
if (!strcmp(lc_name, "spl_autoload_call")) {
if (do_throw) {
- zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Function spl_autoload_call() cannot be registered", func_name);
+ zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Function spl_autoload_call() cannot be registered");
}
- free_alloca(lc_name);
+ efree(lc_name);
return;
}
- if (zend_hash_find(EG(function_table), lc_name, func_name_len+1, (void **) &alfi.func_ptr) == FAILURE) {
+ if (zend_u_hash_find(EG(function_table), func_name_type, lc_name, func_name_len+1, (void **) &alfi.func_ptr) == FAILURE) {
if (do_throw) {
- zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Function '%s' not found", func_name);
+ zend_throw_exception_ex(U_CLASS_ENTRY(spl_ce_LogicException), 0 TSRMLS_CC, "Function '%R' not found", func_name_type, func_name);
}
- free_alloca(lc_name);
+ efree(lc_name);
return;
}
alfi.obj = NULL;
if (ZEND_NUM_ARGS()) {
if (!SPL_G(autoload_functions)) {
ALLOC_HASHTABLE(SPL_G(autoload_functions));
- zend_hash_init(SPL_G(autoload_functions), 1, NULL, (dtor_func_t) autoload_func_info_dtor, 0);
+ zend_u_hash_init(SPL_G(autoload_functions), 1, NULL, (dtor_func_t) autoload_func_info_dtor, 0, UG(unicode));
}
zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &spl_func_ptr);
zend_hash_add(SPL_G(autoload_functions), "spl_autoload", sizeof("spl_autoload"), &spl_alfi, sizeof(autoload_func_info), NULL);
}
- zend_hash_add(SPL_G(autoload_functions), lc_name, func_name_len+1, &alfi, sizeof(autoload_func_info), NULL);
+ zend_u_hash_add(SPL_G(autoload_functions), func_name_type, lc_name, func_name_len+1, &alfi, sizeof(autoload_func_info), NULL);
- free_alloca(lc_name);
+ efree(lc_name);
}
if (SPL_G(autoload_functions)) {
char *func_name, *lc_name;
int func_name_len, success = FAILURE;
zend_function *spl_func_ptr;
+ zend_uchar func_name_type;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &func_name, &func_name_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "t", &func_name, &func_name_len, &func_name_type) == FAILURE) {
return;
}
- lc_name = do_alloca(func_name_len + 1);
- zend_str_tolower_copy(lc_name, func_name, func_name_len);
+ lc_name = zend_u_str_tolower_dup(func_name_type, func_name, func_name_len);
if (SPL_G(autoload_functions)) {
if (!strcmp(lc_name, "spl_autoload_call")) {
success = SUCCESS;
} else {
/* remove specific */
- success = zend_hash_del(SPL_G(autoload_functions), lc_name, func_name_len+1);
+ success = zend_u_hash_del(SPL_G(autoload_functions), func_name_type, lc_name, func_name_len+1);
}
} else if (!strcmp(lc_name, "spl_autoload")) {
/* register single spl_autoload() */
}
}
- free_alloca(lc_name);
+ efree(lc_name);
RETURN_BOOL(success == SUCCESS);
} /* }}} */
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
- ZVAL_STRING(&func, method, 0);
+ ZVAL_TEXT(&func, method, 0);
if (!zend_is_callable(&func, 0, &method)) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "Method %s::%s() does not exist", intern->inner.ce->name, method);
+ php_error_docref(NULL TSRMLS_CC, E_ERROR, "Method %v::%R() does not exist", intern->inner.ce->name, Z_TYPE(method), Z_UNIVAL(method));
return FAILURE;
}
zval ***zargs = NULL;
zval funcname;
int i, res;
- char *callable = NULL, *errbuf=NULL;
+ zval callable;
+ char *errbuf=NULL;
TSRMLS_FETCH();
/* sanity check the args */
ZVAL_STRING(&funcname, (char*)argv[0], 1);
if (!zend_make_callable(&funcname, &callable TSRMLS_CC)) {
- spprintf(&errbuf, 0, "function `%s' is not a function name", callable);
+ spprintf(&errbuf, 0, "function `%R' is not a function name", Z_TYPE(callable), Z_UNIVAL(callable));
sqlite_set_result_error(func, errbuf, -1);
efree(errbuf);
- efree(callable);
+ zval_dtor(&callable);
zval_dtor(&funcname);
return;
}
}
} else {
char *errbuf;
- spprintf(&errbuf, 0, "call_user_function_ex failed for function %s()", callable);
+ spprintf(&errbuf, 0, "call_user_function_ex failed for function %R()", Z_TYPE(callable), Z_UNIVAL(callable));
sqlite_set_result_error(func, errbuf, -1);
efree(errbuf);
}
- efree(callable);
+ zval_dtor(&callable);
if (retval) {
zval_ptr_dtor(&retval);
zval *zstep, *zfinal, *zdb;
struct php_sqlite_db *db;
struct php_sqlite_agg_functions *funcs;
- char *callable = NULL;
+ zval callable;
long num_args = -1;
zval *object = getThis();
}
if (!zend_is_callable(zstep, 0, &callable)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "step function `%s' is not callable", callable);
- efree(callable);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "step function `%R' is not callable", Z_TYPE(callable), Z_UNIVAL(callable));
+ zval_dtor(&callable);
return;
}
- efree(callable);
+ zval_dtor(&callable);
if (!zend_is_callable(zfinal, 0, &callable)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "finalize function `%s' is not callable", callable);
- efree(callable);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "finalize function `%R' is not callable", Z_TYPE(callable), Z_UNIVAL(callable));
+ zval_dtor(&callable);
return;
}
- efree(callable);
+ zval_dtor(&callable);
if (prep_callback_struct(db, 1, funcname, zstep, zfinal, &funcs) == DO_REG) {
zval *zcall, *zdb;
struct php_sqlite_db *db;
struct php_sqlite_agg_functions *funcs;
- char *callable = NULL;
+ zval callable;
long num_args = -1;
zval *object = getThis();
}
if (!zend_is_callable(zcall, 0, &callable)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "function `%s' is not callable", callable);
- efree(callable);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "function `%R' is not callable", Z_TYPE(callable), Z_UNIVAL(callable));
+ zval_dtor(&callable);
return;
}
- efree(callable);
+ zval_dtor(&callable);
if (prep_callback_struct(db, 0, funcname, zcall, NULL, &funcs) == DO_REG) {
sqlite_create_function(db->db, funcname, num_args, php_sqlite_function_callback, funcs);
zval_ptr_dtor(&retval_ptr);
}
} else {
- char *func_name;
+ zval func_name;
if (zend_is_callable(*BG(array_walk_func_name), 0, &func_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", func_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %R()", Z_TYPE(func_name), Z_UNIVAL(func_name));
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s() - function does not exist", func_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %R() - function does not exist", Z_TYPE(func_name), Z_UNIVAL(func_name));
}
if (key) {
zval_ptr_dtor(&key);
key = NULL;
}
- efree(func_name);
+ zval_dtor(&func_name);
break;
}
}
int argc, arr_argc, i, c = 0;
Bucket ***lists, **list, ***ptrs, *p;
- char *callback_name;
+ zval callback_name;
PHP_ARRAY_CMP_FUNC_VARS;
arr_argc = argc - 1;
intersect_data_compare_func = array_user_compare;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
BG(user_compare_func_name) = args[arr_argc];
} else {
}
arr_argc = argc - 1;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
intersect_key_compare_func = array_key_compare;
intersect_data_compare_func = array_user_compare;
} else if (data_compare_type == INTERSECT_COMP_DATA_INTERNAL
}
arr_argc = argc - 1;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
intersect_key_compare_func = array_user_key_compare;
intersect_data_compare_func = array_data_compare;
BG(user_compare_func_name) = args[arr_argc];
}
arr_argc = argc - 2;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
if (!zend_is_callable(*args[arr_argc + 1], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
intersect_key_compare_func = array_user_key_compare;
intersect_data_compare_func = array_user_compare;
BG(user_compare_func_name) = args[arr_argc + 1];/* data - key */
HashTable *hash;
int argc, arr_argc, i, c;
Bucket ***lists, **list, ***ptrs, *p;
- char *callback_name;
+ zval callback_name;
PHP_ARRAY_CMP_FUNC_VARS;
arr_argc = argc - 1;
diff_data_compare_func = array_user_compare;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
BG(user_compare_func_name) = args[arr_argc];
} else {
}
arr_argc = argc - 1;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
diff_key_compare_func = array_key_compare;
diff_data_compare_func = array_user_compare;
} else if (data_compare_type == DIFF_COMP_DATA_INTERNAL
}
arr_argc = argc - 1;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
diff_key_compare_func = array_user_key_compare;
diff_data_compare_func = array_data_compare;
BG(user_compare_func_name) = args[arr_argc];
}
arr_argc = argc - 2;
if (!zend_is_callable(*args[arr_argc], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
if (!zend_is_callable(*args[arr_argc + 1], 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %s", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(args);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
diff_key_compare_func = array_user_key_compare;
diff_data_compare_func = array_user_compare;
BG(user_compare_func_name) = args[arr_argc + 1];/* data - key*/
zval *result = NULL;
zval *retval;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
- char *callback_name;
+ zval callback_name;
HashPosition pos;
HashTable *htbl;
}
if (!zend_is_callable(*callback, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument, '%s', should be a valid callback", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument, '%R', should be a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
if (ZEND_NUM_ARGS() > 2) {
ALLOC_ZVAL(result);
zval **operand;
zval **args[1];
zval *retval = NULL;
- char *callback_name;
+ zval callback_name;
char *string_key;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
uint string_key_len;
if (ZEND_NUM_ARGS() > 1) {
if (!zend_is_callable(*callback, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument, '%s', should be a valid callback", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument, '%R', should be a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
}
array_init(return_value);
zval *result, *null;
HashPosition *array_pos;
zval **args;
- char *callback_name;
+ zval callback_name;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
int i, k, maxlen = 0;
int *array_len;
if (Z_TYPE_P(callback) != IS_NULL) {
if (!zend_is_callable(callback, 0, &callback_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "The first argument, '%s', should be either NULL or a valid callback", callback_name);
- efree(callback_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "The first argument, '%R', should be either NULL or a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
+ zval_dtor(&callback_name);
efree(pargs);
return;
}
- efree(callback_name);
+ zval_dtor(&callback_name);
}
args = (zval **)safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval *), 0);
{
zval ***params;
zval *retval_ptr;
- char *name;
+ zval name;
int argc = ZEND_NUM_ARGS();
if (argc < 1) {
}
if (!zend_is_callable(*params[0], IS_CALLABLE_CHECK_NO_ACCESS, &name)) {
- php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "First argument is expected to be a valid callback");
- efree(name);
+ convert_to_string(&name);
+ php_error_docref1(NULL TSRMLS_CC, Z_STRVAL(name), E_WARNING, "First argument is expected to be a valid callback");
+ zval_dtor(&name);
efree(params);
RETURN_NULL();
}
COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
}
} else {
+ convert_to_string(&name);
if (argc > 1) {
SEPARATE_ZVAL(params[1]);
convert_to_string_ex(params[1]);
if (argc > 2) {
SEPARATE_ZVAL(params[2]);
convert_to_string_ex(params[2]);
- php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "Unable to call %s(%s,%s)", name, Z_STRVAL_PP(params[1]), Z_STRVAL_PP(params[2]));
+ php_error_docref1(NULL TSRMLS_CC, Z_STRVAL(name), E_WARNING, "Unable to call %R(%s,%s)", Z_TYPE(name), Z_UNIVAL(name), Z_STRVAL_PP(params[1]), Z_STRVAL_PP(params[2]));
} else {
- php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "Unable to call %s(%s)", name, Z_STRVAL_PP(params[1]));
+ php_error_docref1(NULL TSRMLS_CC, Z_STRVAL(name), E_WARNING, "Unable to call %R(%s)", Z_TYPE(name), Z_UNIVAL(name), Z_STRVAL_PP(params[1]));
}
} else {
- php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "Unable to call %s()", name);
+ php_error_docref1(NULL TSRMLS_CC, Z_STRVAL(name), E_WARNING, "Unable to call %R()", Z_TYPE(name), Z_UNIVAL(name));
}
}
- efree(name);
+ zval_dtor(&name);
efree(params);
}
/* }}} */
zval ***func_params, **func, **params;
zval *retval_ptr;
HashTable *func_params_ht;
- char *name;
+ zval name;
int count;
int current = 0;
}
if (!zend_is_callable(*func, IS_CALLABLE_CHECK_NO_ACCESS, &name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback, '%s' was given", name);
- efree(name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback, '%R' was given", Z_TYPE(name), Z_UNIVAL(name));
+ zval_dtor(&name);
RETURN_NULL();
}
COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
}
} else {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %R()", Z_TYPE(name), Z_UNIVAL(name));
}
- efree(name);
+ zval_dtor(&name);
if (func_params) {
efree(func_params);
}
static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry TSRMLS_DC)
{
zval retval;
- char *function_name = NULL;
+ zval function_name;
if (!zend_is_callable(shutdown_function_entry->arguments[0], 0, &function_name)) {
- php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name);
+ php_error(E_WARNING, "(Registered shutdown functions) Unable to call %R() - function does not exist", Z_TYPE(function_name), Z_UNIVAL(function_name));
} else if (call_user_function(EG(function_table), NULL,
shutdown_function_entry->arguments[0],
&retval,
{
zval_dtor(&retval);
}
- if (function_name) {
- efree(function_name);
- }
+ zval_dtor(&function_name);
return 0;
}
PHP_FUNCTION(register_shutdown_function)
{
php_shutdown_function_entry shutdown_function_entry;
- char *function_name = NULL;
+ zval function_name;
int i;
shutdown_function_entry.arg_count = ZEND_NUM_ARGS();
/* Prevent entering of anything but valid callback (syntax check only!) */
if (!zend_is_callable(shutdown_function_entry.arguments[0], 1, &function_name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid shutdown callback '%s' passed", function_name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid shutdown callback '%R' passed", Z_TYPE(function_name), Z_UNIVAL(function_name));
efree(shutdown_function_entry.arguments);
RETVAL_FALSE;
} else {
}
zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL);
}
- if (function_name) {
- efree(function_name);
- }
+ zval_dtor(&function_name);
}
/* }}} */
PHP_FUNCTION(is_callable)
{
zval **var, **syntax_only, **callable_name;
- char *name;
+ zval name;
zend_bool retval;
zend_bool syntax = 0;
int argc=ZEND_NUM_ARGS();
if (argc > 2) {
retval = zend_is_callable(*var, syntax, &name);
zval_dtor(*callable_name);
- ZVAL_STRING(*callable_name, name, 0);
+ **callable_name = name;
} else {
retval = zend_is_callable(*var, syntax, NULL);
}
PHP_FUNCTION(sybase_set_message_handler)
{
zval **callback, **param, **sybase_link_index= NULL;
- char *name;
+ zval name;
sybase_link *sybase_ptr;
switch (ZEND_NUM_ARGS()) {
case IS_STRING:
/* Either "function", array("class", "function") or array($object, "function") */
if (!zend_is_callable(*param, 0, &name)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argumented is expected to be a valid callback, '%s' was given", name);
- efree(name);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argumented is expected to be a valid callback, '%R' was given", Z_TYPE(name), Z_UNIVAL(name));
+ zval_dtor(&name);
RETURN_FALSE;
}
- efree(name);
+ zval_dtor(&name);
break;
default:
zval handler;
xmlXPathObjectPtr obj;
char *str;
- char *callable = NULL;
+ zval callable;
xsl_object *intern;
TSRMLS_FETCH();
fci.no_separation = 0;
/*fci.function_handler_cache = &function_ptr;*/
if (!zend_make_callable(&handler, &callable TSRMLS_CC)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", callable);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %R()", Z_TYPE(callable), Z_UNIVAL(callable));
- } else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable, strlen(callable) + 1) == 0) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%s()'.", callable);
+ } else if ( intern->registerPhpFunctions == 2 && zend_u_hash_exists(intern->registered_phpfunctions, Z_TYPE(callable), Z_UNIVLA(callable), Z_UNILEN(callable) + 1) == 0) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%R()'.", Z_TYPE(callable), Z_UNILEN(callable));
// Push an empty string, so that we at least have an xslt result...
valuePush(ctxt, xmlXPathNewString(""));
} else {
zval_ptr_dtor(&retval);
}
}
- efree(callable);
+ zval_dtor(&callable);
zval_dtor(&handler);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
}
}
} else if (output_handler && output_handler->type == IS_ARRAY) {
- char* handler_name;
+ zval handler_name;
/* do we have array(object,method) */
if (zend_is_callable(output_handler, 0, &handler_name)) {
SEPARATE_ZVAL(&output_handler);
output_handler->refcount++;
- result = php_ob_init_named(initial_size, block_size, UG(unicode)?IS_UNICODE:IS_STRING, handler_name, output_handler, chunk_size, erase TSRMLS_CC);
- efree(handler_name);
+ result = php_ob_init_named(initial_size, block_size, Z_TYPE(handler_name), Z_UNIVAL(handler_name), output_handler, chunk_size, erase TSRMLS_CC);
+ zval_dtor(&handler_name);
} else {
- efree(handler_name);
+ zval_dtor(&handler_name);
/* init all array elements recursively */
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(output_handler), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(output_handler), (void **)&tmp, &pos) == SUCCESS) {
trim()
ucwords()
ucfirst()
+ZE
+--
+ Status: In Progress
+ debug_backtrace()
+ extension_loaded()
+ get_extension_funcs()
+ get_included_files()
+ strcasecmp()
+ strncasecmp()
+ Completed:
+ class_exists()
+ create_function()
+ debug_print_backtrace()
+ define()
+ defined()
+ each()
+ error_reporting()
+ func_get_arg()
+ func_get_args()
+ func_num_args()
+ function_exists()
+ get_class()
+ get_class_methods()
+ get_class_vars()
+ get_declared_classes()
+ get_declared_interfaces()
+ get_defined_constants()
+ get_defined_functions()
+ get_defined_vars()
+ get_loaded_extensions()
+ get_object_vars()
+ get_parent_class()
+ get_resource_type()
+ interface_exists()
+ is_a()
+ is_subclass_of()
+ method_exists()
+ property_exists()
+ restore_error_handler()
+ restore_exception_handler()
+ set_error_handler()
+ set_exception_handler()
+ strcmp()
+ strlen()
+ strncmp()
+ trigger_error()
+ zend_thread_id()
+ zend_version()
projects / php / commitdiff