zend_is_callable() and zend_make_callable() were changed to return readable function name as zval (instead of string).

17 files changed, 170 insertions, 170 deletions

diff --git a/ext/fdf/fdf.c b/ext/fdf/fdf.c
index 3ed745b1e3..66ec51d996 100644
--- a/ext/fdf/fdf.c
+++ b/ext/fdf/fdf.c
@@ -1573,7 +1573,7 @@ PHP_FUNCTION(fdf_enum_values) {
 	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, 
@@ -1586,11 +1586,12 @@ PHP_FUNCTION(fdf_enum_values) {
 	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;
 
diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index 777e6acdcc..bffe17c11b 100644
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -2199,7 +2199,7 @@ PHP_FUNCTION(ldap_set_rebind_proc)
 {
 	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;
@@ -2219,11 +2219,11 @@ PHP_FUNCTION(ldap_set_rebind_proc)
 
 	/* 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) {
diff --git a/ext/mysqli/mysqli_api.c b/ext/mysqli/mysqli_api.c
index 042c2b417a..c408690972 100644
--- a/ext/mysqli/mysqli_api.c
+++ b/ext/mysqli/mysqli_api.c
@@ -1105,7 +1105,7 @@ PHP_FUNCTION(mysqli_set_local_infile_handler)
 {
 	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,
@@ -1117,11 +1117,11 @@ PHP_FUNCTION(mysqli_set_local_infile_handler)
 
 	/* 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);	
diff --git a/ext/pcntl/pcntl.c b/ext/pcntl/pcntl.c
index dc347a8fd7..94af3d64ce 100755
--- a/ext/pcntl/pcntl.c
+++ b/ext/pcntl/pcntl.c
@@ -521,7 +521,7 @@ PHP_FUNCTION(pcntl_exec)
 PHP_FUNCTION(pcntl_signal)
 {
 	zval *handle, **dest_handle = NULL;
-	char *func_name;
+	zval func_name;
 	long signo;
 	zend_bool restart_syscalls = 1;
 
@@ -555,11 +555,11 @@ PHP_FUNCTION(pcntl_signal)
 	}
 	
 	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);
diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index ea539803e1..a0846214ba 100644
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -1128,7 +1128,7 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_callabl
 	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; 
 	
@@ -1147,13 +1147,13 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_callabl
 		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);
diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index af0c5d3cf5..085a82270b 100755
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -632,7 +632,6 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 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;
 	
@@ -667,7 +666,7 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
 		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;
 	}
@@ -677,7 +676,6 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
 		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;
diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index b5304410b9..a93aec9eef 100644
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -457,7 +457,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	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;
@@ -470,11 +470,11 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	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;
 
@@ -528,7 +528,7 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	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;
@@ -541,17 +541,17 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	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;
 
diff --git a/ext/readline/readline.c b/ext/readline/readline.c
index f86fdfcd07..8dbfb46157 100644
--- a/ext/readline/readline.c
+++ b/ext/readline/readline.c
@@ -441,16 +441,18 @@ static char **_readline_completion_cb(const char *text, int start, int end)
 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);
@@ -489,7 +491,7 @@ static void php_rl_callback_handler(char *the_line)
 PHP_FUNCTION(readline_callback_handler_install)
 {
 	zval *callback;
-	char *name = NULL;
+	zval name;
 	char *prompt;
 	int prompt_len;
 
@@ -498,9 +500,11 @@ PHP_FUNCTION(readline_callback_handler_install)
 	}
 
 	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();
diff --git a/ext/session/session.c b/ext/session/session.c
index 1cc6a3a3ce..571c4523b6 100644
--- a/ext/session/session.c
+++ b/ext/session/session.c
@@ -1377,7 +1377,7 @@ PHP_FUNCTION(session_set_save_handler)
 	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;
@@ -1388,10 +1388,10 @@ PHP_FUNCTION(session_set_save_handler)
 	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);
diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c
index 1b0fdcc9bb..0dfb10d4cc 100755
--- a/ext/spl/php_spl.c
+++ b/ext/spl/php_spl.c
@@ -371,40 +371,39 @@ PHP_FUNCTION(spl_autoload_call)
  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++;
@@ -414,22 +413,21 @@ PHP_FUNCTION(spl_autoload_register)
 			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;
@@ -439,7 +437,7 @@ PHP_FUNCTION(spl_autoload_register)
 	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);
@@ -449,9 +447,9 @@ PHP_FUNCTION(spl_autoload_register)
 			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)) {
@@ -468,13 +466,13 @@ PHP_FUNCTION(spl_autoload_unregister)
 	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")) {
@@ -486,7 +484,7 @@ PHP_FUNCTION(spl_autoload_unregister)
 			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() */
@@ -498,7 +496,7 @@ PHP_FUNCTION(spl_autoload_unregister)
 		}
 	}
 
-	free_alloca(lc_name);
+	efree(lc_name);
 	
 	RETURN_BOOL(success == SUCCESS);
 } /* }}} */
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index 56e4f1f9c3..3f3e386521 100755
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -672,9 +672,9 @@ int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
 
 	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;
 	}
 
diff --git a/ext/sqlite/sqlite.c b/ext/sqlite/sqlite.c
index 2395d9909c..bbd0ccfe8b 100644
--- a/ext/sqlite/sqlite.c
+++ b/ext/sqlite/sqlite.c
@@ -430,7 +430,8 @@ static void php_sqlite_generic_function_callback(sqlite_func *func, int argc, co
 	zval ***zargs = NULL;
 	zval funcname;
 	int i, res;
-	char *callable = NULL, *errbuf=NULL;
+	zval callable;
+	char *errbuf=NULL;
 	TSRMLS_FETCH();
 
 	/* sanity check the args */
@@ -442,10 +443,10 @@ static void php_sqlite_generic_function_callback(sqlite_func *func, int argc, co
 	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;
 	}
@@ -492,12 +493,12 @@ static void php_sqlite_generic_function_callback(sqlite_func *func, int argc, co
 		}
 	} 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);
@@ -3000,7 +3001,7 @@ PHP_FUNCTION(sqlite_create_aggregate)
 	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();
 
@@ -3017,18 +3018,18 @@ PHP_FUNCTION(sqlite_create_aggregate)
 	}
 
 	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) {
@@ -3050,7 +3051,7 @@ PHP_FUNCTION(sqlite_create_function)
 	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();
@@ -3068,11 +3069,11 @@ PHP_FUNCTION(sqlite_create_function)
 	}
 
 	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);
diff --git a/ext/standard/array.c b/ext/standard/array.c
index 10a2f8955e..10e181c291 100644
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -1139,18 +1139,18 @@ static int php_array_walk(HashTable *target_hash, zval **userdata, int recursive
 					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;
 			}
 		}
@@ -3127,7 +3127,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 	int argc, arr_argc, i, c = 0;
 	Bucket ***lists, **list, ***ptrs, *p;
 	
-	char *callback_name;
+	zval callback_name;
 	PHP_ARRAY_CMP_FUNC_VARS;
 
 	
@@ -3165,12 +3165,12 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 			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 {
@@ -3206,12 +3206,12 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 			}
 			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
@@ -3225,12 +3225,12 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 				}
 				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];
@@ -3245,19 +3245,19 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 				}
 				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 */
@@ -3511,7 +3511,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 	HashTable *hash;
 	int argc, arr_argc, i, c;
 	Bucket ***lists, **list, ***ptrs, *p;
-	char *callback_name;
+	zval callback_name;
 	
 	PHP_ARRAY_CMP_FUNC_VARS;
 
@@ -3550,12 +3550,12 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			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 {
@@ -3591,12 +3591,12 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			}
 			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 
@@ -3610,12 +3610,12 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			}
 			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];
@@ -3630,19 +3630,19 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			}
 			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*/
@@ -4294,7 +4294,7 @@ PHP_FUNCTION(array_reduce)
 	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;
 	
@@ -4309,11 +4309,11 @@ PHP_FUNCTION(array_reduce)
 	}
 
 	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);
@@ -4385,7 +4385,7 @@ PHP_FUNCTION(array_filter)
 	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;
@@ -4404,11 +4404,11 @@ PHP_FUNCTION(array_filter)
 
 	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);
@@ -4484,7 +4484,7 @@ PHP_FUNCTION(array_map)
 	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;
@@ -4505,12 +4505,12 @@ PHP_FUNCTION(array_map)
 
 	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);
diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index e758b2d3e3..f4f59c6d56 100644
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -2029,7 +2029,7 @@ PHP_FUNCTION(call_user_func)
 {
 	zval ***params;
 	zval *retval_ptr;
-	char *name;
+	zval name;
 	int argc = ZEND_NUM_ARGS();
 
 	if (argc < 1) {
@@ -2051,8 +2051,9 @@ PHP_FUNCTION(call_user_func)
 	}
 
 	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();
 	}
@@ -2062,22 +2063,23 @@ PHP_FUNCTION(call_user_func)
 			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);
 }
 /* }}} */
@@ -2089,7 +2091,7 @@ PHP_FUNCTION(call_user_func_array)
 	zval ***func_params, **func, **params;
 	zval *retval_ptr;
 	HashTable *func_params_ht;
-	char *name;
+	zval name;
 	int count;
 	int current = 0;
 
@@ -2108,8 +2110,8 @@ PHP_FUNCTION(call_user_func_array)
 	}
 
 	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();
 	}
 
@@ -2134,10 +2136,10 @@ PHP_FUNCTION(call_user_func_array)
 			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);
 	}
@@ -2256,10 +2258,10 @@ void user_tick_function_dtor(user_tick_function_entry *tick_function_entry)
 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, 
@@ -2269,9 +2271,7 @@ static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_fun
 	{
 		zval_dtor(&retval);
 	} 
-	if (function_name) {
-		efree(function_name);
-	}
+	zval_dtor(&function_name);
 	return 0;
 }
 
@@ -2363,7 +2363,7 @@ void php_free_shutdown_functions(TSRMLS_D)
 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();
@@ -2380,7 +2380,7 @@ PHP_FUNCTION(register_shutdown_function)
 	
 	/* 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 {
@@ -2394,9 +2394,7 @@ PHP_FUNCTION(register_shutdown_function)
 		}
 		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);
 }
 /* }}} */
 
diff --git a/ext/standard/type.c b/ext/standard/type.c
index c4be0c3395..161ce7f5f0 100644
--- a/ext/standard/type.c
+++ b/ext/standard/type.c
@@ -407,7 +407,7 @@ PHP_FUNCTION(is_scalar)
 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();
@@ -424,7 +424,7 @@ PHP_FUNCTION(is_callable)
 	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);
 	}
diff --git a/ext/sybase_ct/php_sybase_ct.c b/ext/sybase_ct/php_sybase_ct.c
index 0442c5a6f2..e524db7160 100644
--- a/ext/sybase_ct/php_sybase_ct.c
+++ b/ext/sybase_ct/php_sybase_ct.c
@@ -2182,7 +2182,7 @@ PHP_FUNCTION(sybase_deadlock_retry_count)
 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()) {
@@ -2221,11 +2221,11 @@ PHP_FUNCTION(sybase_set_message_handler)
 		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:
diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c
index 2e321312e8..f67af7e311 100644
--- a/ext/xsl/xsltprocessor.c
+++ b/ext/xsl/xsltprocessor.c
@@ -134,7 +134,7 @@ static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int t
 	zval handler;
 	xmlXPathObjectPtr obj;
 	char *str;
-	char *callable = NULL;
+	zval callable;
 	xsl_object *intern;
 	
 	TSRMLS_FETCH();
@@ -265,10 +265,10 @@ static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int t
 	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 {
@@ -304,7 +304,7 @@ static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int t
 			zval_ptr_dtor(&retval);
 		}
 	}
-	efree(callable);
+	zval_dtor(&callable);
 	zval_dtor(&handler);
 	if (fci.param_count > 0) {
 		for (i = 0; i < nargs - 1; i++) {