diff options
Diffstat (limited to 'Zend/zend_exceptions.c')
| -rw-r--r-- | Zend/zend_exceptions.c | 748 |
1 files changed, 358 insertions, 390 deletions
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 3d73e92c50..655542fc30 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -28,38 +28,42 @@ #include "zend_exceptions.h" #include "zend_vm.h" #include "zend_dtrace.h" +#include "zend_smart_str.h" static zend_class_entry *default_exception_ce; static zend_class_entry *error_exception_ce; static zend_object_handlers default_exception_handlers; -ZEND_API void (*zend_throw_exception_hook)(zval *ex TSRMLS_DC); +ZEND_API void (*zend_throw_exception_hook)(zval *ex); -void zend_exception_set_previous(zval *exception, zval *add_previous TSRMLS_DC) +void zend_exception_set_previous(zend_object *exception, zend_object *add_previous) { - zval *previous; + zval tmp, *previous, zv, *pzv, rv; if (exception == add_previous || !add_previous || !exception) { return; } - if (Z_TYPE_P(add_previous) != IS_OBJECT && !instanceof_function(Z_OBJCE_P(add_previous), default_exception_ce TSRMLS_CC)) { + ZVAL_OBJ(&tmp, add_previous); + if (!instanceof_function(Z_OBJCE(tmp), default_exception_ce)) { zend_error(E_ERROR, "Cannot set non exception as previous exception"); return; } - while (exception && exception != add_previous && Z_OBJ_HANDLE_P(exception) != Z_OBJ_HANDLE_P(add_previous)) { - previous = zend_read_property(default_exception_ce, exception, "previous", sizeof("previous")-1, 1 TSRMLS_CC); + ZVAL_OBJ(&zv, exception); + pzv = &zv; + do { + previous = zend_read_property(default_exception_ce, pzv, "previous", sizeof("previous")-1, 1, &rv); if (Z_TYPE_P(previous) == IS_NULL) { - zend_update_property(default_exception_ce, exception, "previous", sizeof("previous")-1, add_previous TSRMLS_CC); - Z_DELREF_P(add_previous); + zend_update_property(default_exception_ce, pzv, "previous", sizeof("previous")-1, &tmp); + GC_REFCOUNT(add_previous)--; return; } - exception = previous; - } + pzv = previous; + } while (pzv && Z_OBJ_P(pzv) != add_previous); } -void zend_exception_save(TSRMLS_D) /* {{{ */ +void zend_exception_save(void) /* {{{ */ { if (EG(prev_exception)) { - zend_exception_set_previous(EG(exception), EG(prev_exception) TSRMLS_CC); + zend_exception_set_previous(EG(exception), EG(prev_exception)); } if (EG(exception)) { EG(prev_exception) = EG(exception); @@ -68,11 +72,11 @@ void zend_exception_save(TSRMLS_D) /* {{{ */ } /* }}} */ -void zend_exception_restore(TSRMLS_D) /* {{{ */ +void zend_exception_restore(void) /* {{{ */ { if (EG(prev_exception)) { if (EG(exception)) { - zend_exception_set_previous(EG(exception), EG(prev_exception) TSRMLS_CC); + zend_exception_set_previous(EG(exception), EG(prev_exception)); } else { EG(exception) = EG(prev_exception); } @@ -81,16 +85,12 @@ void zend_exception_restore(TSRMLS_D) /* {{{ */ } /* }}} */ -void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ +ZEND_API void zend_throw_exception_internal(zval *exception) /* {{{ */ { #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_THROWN_ENABLED()) { - const char *classname; - zend_uint name_len; - if (exception != NULL) { - zend_get_object_classname(exception, &classname, &name_len TSRMLS_CC); - DTRACE_EXCEPTION_THROWN((char *)classname); + DTRACE_EXCEPTION_THROWN(Z_OBJ_P(exception)->ce->name->val); } else { DTRACE_EXCEPTION_THROWN(NULL); } @@ -98,25 +98,26 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ #endif /* HAVE_DTRACE */ if (exception != NULL) { - zval *previous = EG(exception); - zend_exception_set_previous(exception, EG(exception) TSRMLS_CC); - EG(exception) = exception; + zend_object *previous = EG(exception); + zend_exception_set_previous(Z_OBJ_P(exception), EG(exception)); + EG(exception) = Z_OBJ_P(exception); if (previous) { return; } } if (!EG(current_execute_data)) { if(EG(exception)) { - zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); + zend_exception_error(EG(exception), E_ERROR); } zend_error(E_ERROR, "Exception thrown without a stack frame"); } if (zend_throw_exception_hook) { - zend_throw_exception_hook(exception TSRMLS_CC); + zend_throw_exception_hook(exception); } - if (EG(current_execute_data)->opline == NULL || + if (!EG(current_execute_data)->func || + !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) || (EG(current_execute_data)->opline+1)->opcode == ZEND_HANDLE_EXCEPTION) { /* no need to rethrow the exception */ return; @@ -126,16 +127,17 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ } /* }}} */ -ZEND_API void zend_clear_exception(TSRMLS_D) /* {{{ */ +ZEND_API void zend_clear_exception(void) /* {{{ */ { if (EG(prev_exception)) { - zval_ptr_dtor(&EG(prev_exception)); + + OBJ_RELEASE(EG(prev_exception)); EG(prev_exception) = NULL; } if (!EG(exception)) { return; } - zval_ptr_dtor(&EG(exception)); + OBJ_RELEASE(EG(exception)); EG(exception) = NULL; EG(current_execute_data)->opline = EG(opline_before_exception); #if ZEND_DEBUG @@ -144,39 +146,37 @@ ZEND_API void zend_clear_exception(TSRMLS_D) /* {{{ */ } /* }}} */ -static zend_object_value zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces TSRMLS_DC) /* {{{ */ +static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */ { zval obj; zend_object *object; - zval *trace; + zval trace; - Z_OBJVAL(obj) = zend_objects_new(&object, class_type TSRMLS_CC); + Z_OBJ(obj) = object = zend_objects_new(class_type); Z_OBJ_HT(obj) = &default_exception_handlers; object_properties_init(object, class_type); - ALLOC_ZVAL(trace); - Z_UNSET_ISREF_P(trace); - Z_SET_REFCOUNT_P(trace, 0); - zend_fetch_debug_backtrace(trace, skip_top_traces, 0, 0 TSRMLS_CC); + zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0); + Z_SET_REFCOUNT(trace, 0); - zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC); - zend_update_property_long(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC); - zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, trace TSRMLS_CC); + zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename()); + zend_update_property_long(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno()); + zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, &trace); - return Z_OBJVAL(obj); + return object; } /* }}} */ -static zend_object_value zend_default_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */ +static zend_object *zend_default_exception_new(zend_class_entry *class_type) /* {{{ */ { - return zend_default_exception_new_ex(class_type, 0 TSRMLS_CC); + return zend_default_exception_new_ex(class_type, 0); } /* }}} */ -static zend_object_value zend_error_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */ +static zend_object *zend_error_exception_new(zend_class_entry *class_type) /* {{{ */ { - return zend_default_exception_new_ex(class_type, 2 TSRMLS_CC); + return zend_default_exception_new_ex(class_type, 2); } /* }}} */ @@ -185,7 +185,7 @@ static zend_object_value zend_error_exception_new(zend_class_entry *class_type T ZEND_METHOD(exception, __clone) { /* Should never be executable */ - zend_throw_exception(NULL, "Cannot clone object using __clone()", 0 TSRMLS_CC); + zend_throw_exception(NULL, "Cannot clone object using __clone()", 0); } /* }}} */ @@ -193,27 +193,27 @@ ZEND_METHOD(exception, __clone) Exception constructor */ ZEND_METHOD(exception, __construct) { - char *message = NULL; - long code = 0; + zend_string *message = NULL; + zend_long code = 0; zval *object, *previous = NULL; - int argc = ZEND_NUM_ARGS(), message_len; + int argc = ZEND_NUM_ARGS(); - if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|slO!", &message, &message_len, &code, &previous, default_exception_ce) == FAILURE) { + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SlO!", &message, &code, &previous, default_exception_ce) == FAILURE) { zend_error(E_ERROR, "Wrong parameters for Exception([string $exception [, long $code [, Exception $previous = NULL]]])"); } object = getThis(); if (message) { - zend_update_property_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); + zend_update_property_str(default_exception_ce, object, "message", sizeof("message")-1, message); } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code); } if (previous) { - zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous TSRMLS_CC); + zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous); } } /* }}} */ @@ -223,36 +223,37 @@ ZEND_METHOD(exception, __construct) ZEND_METHOD(error_exception, __construct) { char *message = NULL, *filename = NULL; - long code = 0, severity = E_ERROR, lineno; + zend_long code = 0, severity = E_ERROR, lineno; zval *object, *previous = NULL; - int argc = ZEND_NUM_ARGS(), message_len, filename_len; + int argc = ZEND_NUM_ARGS(); + size_t message_len, filename_len; - if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, default_exception_ce) == FAILURE) { + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, default_exception_ce) == FAILURE) { zend_error(E_ERROR, "Wrong parameters for ErrorException([string $exception [, long $code, [ long $severity, [ string $filename, [ long $lineno [, Exception $previous = NULL]]]]]])"); } object = getThis(); if (message) { - zend_update_property_string(default_exception_ce, object, "message", sizeof("message")-1, message TSRMLS_CC); + zend_update_property_string(default_exception_ce, object, "message", sizeof("message")-1, message); } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code); } if (previous) { - zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous TSRMLS_CC); + zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous); } - zend_update_property_long(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC); + zend_update_property_long(default_exception_ce, object, "severity", sizeof("severity")-1, severity); if (argc >= 4) { - zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename TSRMLS_CC); + zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename); if (argc < 5) { lineno = 0; /* invalidate lineno */ } - zend_update_property_long(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC); + zend_update_property_long(default_exception_ce, object, "line", sizeof("line")-1, lineno); } } /* }}} */ @@ -262,25 +263,20 @@ ZEND_METHOD(error_exception, __construct) return; \ } -static void _default_exception_get_entry(zval *object, char *name, int name_len, zval *return_value TSRMLS_DC) /* {{{ */ -{ - zval *value; - - value = zend_read_property(default_exception_ce, object, name, name_len, 0 TSRMLS_CC); - - *return_value = *value; - zval_copy_ctor(return_value); - INIT_PZVAL(return_value); -} -/* }}} */ +#define GET_PROPERTY(object, name) \ + zend_read_property(default_exception_ce, (object), name, sizeof(name) - 1, 0, &rv) +#define GET_PROPERTY_SILENT(object, name) \ + zend_read_property(default_exception_ce, (object), name, sizeof(name) - 1, 1, &rv) /* {{{ proto string Exception::getFile() Get the file in which the exception occurred */ ZEND_METHOD(exception, getFile) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "file", sizeof("file")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "file")); } /* }}} */ @@ -288,9 +284,11 @@ ZEND_METHOD(exception, getFile) Get the line in which the exception occurred */ ZEND_METHOD(exception, getLine) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "line", sizeof("line")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "line")); } /* }}} */ @@ -298,9 +296,11 @@ ZEND_METHOD(exception, getLine) Get the exception message */ ZEND_METHOD(exception, getMessage) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "message", sizeof("message")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "message")); } /* }}} */ @@ -308,9 +308,11 @@ ZEND_METHOD(exception, getMessage) Get the exception code */ ZEND_METHOD(exception, getCode) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "code", sizeof("code")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "code")); } /* }}} */ @@ -318,9 +320,11 @@ ZEND_METHOD(exception, getCode) Get the stack trace for the location in which the exception occurred */ ZEND_METHOD(exception, getTrace) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "trace", sizeof("trace")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "trace")); } /* }}} */ @@ -328,220 +332,161 @@ ZEND_METHOD(exception, getTrace) Get the exception severity */ ZEND_METHOD(error_exception, getSeverity) { + zval rv; + DEFAULT_0_PARAMS; - _default_exception_get_entry(getThis(), "severity", sizeof("severity")-1, return_value TSRMLS_CC); + ZVAL_COPY(return_value, GET_PROPERTY(getThis(), "severity")); } /* }}} */ -/* {{{ gettraceasstring() macros */ -#define TRACE_APPEND_CHR(chr) \ - *str = (char*)erealloc(*str, *len + 1 + 1); \ - (*str)[(*len)++] = chr +#define TRACE_APPEND_KEY(key) do { \ + tmp = zend_hash_str_find(ht, key, sizeof(key)-1); \ + if (tmp) { \ + if (Z_TYPE_P(tmp) != IS_STRING) { \ + zend_error(E_WARNING, "Value for %s is no string", key); \ + smart_str_appends(str, "[unknown]"); \ + } else { \ + smart_str_append(str, Z_STR_P(tmp)); \ + } \ + } \ + } while (0) -#define TRACE_APPEND_STRL(val, vallen) \ - { \ - int l = vallen; \ - *str = (char*)erealloc(*str, *len + l + 1); \ - memcpy((*str) + *len, val, l); \ - *len += l; \ - } - -#define TRACE_APPEND_STR(val) \ - TRACE_APPEND_STRL(val, sizeof(val)-1) +/* Windows uses VK_ESCAPE instead of \e */ +#ifndef VK_ESCAPE +#define VK_ESCAPE '\e' +#endif -#define TRACE_APPEND_KEY(key) \ - if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \ - if (Z_TYPE_PP(tmp) != IS_STRING) { \ - zend_error(E_WARNING, "Value for %s is no string", key); \ - TRACE_APPEND_STR("[unknown]"); \ - } else { \ - TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); \ - } \ +static size_t compute_escaped_string_len(const char *s, size_t l) { + size_t i, len = l; + for (i = 0; i < l; ++i) { + char c = s[i]; + if (c == '\n' || c == '\r' || c == '\t' || + c == '\f' || c == '\v' || c == '\\' || c == VK_ESCAPE) { + len += 1; + } else if (c < 32 || c > 126) { + len += 3; + } } + return len; +} +static void smart_str_append_escaped(smart_str *str, const char *s, size_t l) { + char *res; + size_t i, len = compute_escaped_string_len(s, l); + + smart_str_alloc(str, len, 0); + res = &str->s->val[str->s->len]; + str->s->len += len; + + for (i = 0; i < l; ++i) { + char c = s[i]; + if (c < 32 || c == '\\' || c > 126) { + *res++ = '\\'; + switch (c) { + case '\n': *res++ = 'n'; break; + case '\r': *res++ = 'r'; break; + case '\t': *res++ = 't'; break; + case '\f': *res++ = 'f'; break; + case '\v': *res++ = 'v'; break; + case '\\': *res++ = '\\'; break; + case VK_ESCAPE: *res++ = 'e'; break; + default: + *res++ = 'x'; + if ((c >> 4) < 10) { + *res++ = (c >> 4) + '0'; + } else { + *res++ = (c >> 4) + 'A' - 10; + } + if ((c & 0xf) < 10) { + *res++ = (c & 0xf) + '0'; + } else { + *res++ = (c & 0xf) + 'A' - 10; + } + } + } else { + *res++ = c; + } + } +} -#define TRACE_ARG_APPEND(vallen) \ - *str = (char*)erealloc(*str, *len + 1 + vallen); \ - memmove((*str) + *len - l_added + 1 + vallen, (*str) + *len - l_added + 1, l_added); - -/* }}} */ - -static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +static void _build_trace_args(zval *arg, smart_str *str) /* {{{ */ { - char **str; - int *len; - - str = va_arg(args, char**); - len = va_arg(args, int*); - - /* the trivial way would be to do: + /* the trivial way would be to do * convert_to_string_ex(arg); * append it and kill the now tmp arg. * but that could cause some E_NOTICE and also damn long lines. */ - switch (Z_TYPE_PP(arg)) { + ZVAL_DEREF(arg); + switch (Z_TYPE_P(arg)) { case IS_NULL: - TRACE_APPEND_STR("NULL, "); + smart_str_appends(str, "NULL, "); break; - case IS_STRING: { - int l_added; - TRACE_APPEND_CHR('\''); - if (Z_STRLEN_PP(arg) > 15) { - TRACE_APPEND_STRL(Z_STRVAL_PP(arg), 15); - TRACE_APPEND_STR("...', "); - l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */ + case IS_STRING: + smart_str_appendc(str, '\''); + smart_str_append_escaped(str, Z_STRVAL_P(arg), MIN(Z_STRLEN_P(arg), 15)); + if (Z_STRLEN_P(arg) > 15) { + smart_str_appends(str, "...', "); } else { - l_added = Z_STRLEN_PP(arg); - TRACE_APPEND_STRL(Z_STRVAL_PP(arg), l_added); - TRACE_APPEND_STR("', "); - l_added += 3 + 1; - } - while (--l_added) { - unsigned char chr = (*str)[*len - l_added]; - if (chr < 32 || chr == '\\' || chr > 126) { - (*str)[*len - l_added] = '\\'; - - switch (chr) { - case '\n': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'n'; - break; - case '\r': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'r'; - break; - case '\t': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 't'; - break; - case '\f': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'f'; - break; - case '\v': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'v'; - break; -#ifndef PHP_WIN32 - case '\e': -#else - case VK_ESCAPE: -#endif - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'e'; - break; - case '\\': - TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = '\\'; - break; - default: - TRACE_ARG_APPEND(3); - (*str)[*len - l_added + 1] = 'x'; - if ((chr >> 4) < 10) { - (*str)[*len - l_added + 2] = (chr >> 4) + '0'; - } else { - (*str)[*len - l_added + 2] = (chr >> 4) + 'A' - 10; - } - if (chr % 16 < 10) { - (*str)[*len - l_added + 3] = chr % 16 + '0'; - } else { - (*str)[*len - l_added + 3] = chr % 16 + 'A' - 10; - } - *len += 3; - } - } + smart_str_appends(str, "', "); } break; - } - case IS_BOOL: - if (Z_LVAL_PP(arg)) { - TRACE_APPEND_STR("true, "); - } else { - TRACE_APPEND_STR("false, "); - } + case IS_FALSE: + smart_str_appends(str, "false, "); + break; + case IS_TRUE: + smart_str_appends(str, "true, "); break; case IS_RESOURCE: - TRACE_APPEND_STR("Resource id #"); - /* break; */ - case IS_LONG: { - long lval = Z_LVAL_PP(arg); - char s_tmp[MAX_LENGTH_OF_LONG + 1]; - int l_tmp = zend_sprintf(s_tmp, "%ld", lval); /* SAFE */ - TRACE_APPEND_STRL(s_tmp, l_tmp); - TRACE_APPEND_STR(", "); + smart_str_appends(str, "Resource id #"); + smart_str_append_long(str, Z_RES_HANDLE_P(arg)); + smart_str_appends(str, ", "); + break; + case IS_LONG: + smart_str_append_long(str, Z_LVAL_P(arg)); + smart_str_appends(str, ", "); break; - } case IS_DOUBLE: { - double dval = Z_DVAL_PP(arg); - char *s_tmp; - int l_tmp; - - s_tmp = emalloc(MAX_LENGTH_OF_DOUBLE + EG(precision) + 1); - l_tmp = zend_sprintf(s_tmp, "%.*G", (int) EG(precision), dval); /* SAFE */ - TRACE_APPEND_STRL(s_tmp, l_tmp); - /* %G already handles removing trailing zeros from the fractional part, yay */ + double dval = Z_DVAL_P(arg); + char *s_tmp = emalloc(MAX_LENGTH_OF_DOUBLE + EG(precision) + 1); + int l_tmp = zend_sprintf(s_tmp, "%.*G", (int) EG(precision), dval); /* SAFE */ + smart_str_appendl(str, s_tmp, l_tmp); + smart_str_appends(str, ", "); efree(s_tmp); - TRACE_APPEND_STR(", "); break; } case IS_ARRAY: - TRACE_APPEND_STR("Array, "); + smart_str_appends(str, "Array, "); break; - case IS_OBJECT: { - const char *class_name; - zend_uint class_name_len; - int dup; - - TRACE_APPEND_STR("Object("); - - dup = zend_get_object_classname(*arg, &class_name, &class_name_len TSRMLS_CC); - - TRACE_APPEND_STRL(class_name, class_name_len); - if(!dup) { - efree((char*)class_name); - } - - TRACE_APPEND_STR("), "); - break; - } - default: + case IS_OBJECT: + smart_str_appends(str, "Object("); + smart_str_append(str, Z_OBJCE_P(arg)->name); + smart_str_appends(str, "), "); break; } - return ZEND_HASH_APPLY_KEEP; } /* }}} */ -static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +static void _build_trace_string(smart_str *str, HashTable *ht, uint32_t num) /* {{{ */ { - char *s_tmp, **str; - int *len, *num; - long line; - HashTable *ht = Z_ARRVAL_PP(frame); - zval **file, **tmp; + zval *file, *tmp; - if (Z_TYPE_PP(frame) != IS_ARRAY) { - zend_error(E_WARNING, "Expected array for frame %lu", hash_key->h); - return ZEND_HASH_APPLY_KEEP; - } + smart_str_appendc(str, '#'); + smart_str_append_long(str, num); + smart_str_appendc(str, ' '); - str = va_arg(args, char**); - len = va_arg(args, int*); - num = va_arg(args, int*); - - s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 1 + 1); - sprintf(s_tmp, "#%d ", (*num)++); - TRACE_APPEND_STRL(s_tmp, strlen(s_tmp)); - efree(s_tmp); - if (zend_hash_find(ht, "file", sizeof("file"), (void**)&file) == SUCCESS) { - if (Z_TYPE_PP(file) != IS_STRING) { + file = zend_hash_str_find(ht, "file", sizeof("file")-1); + if (file) { + if (Z_TYPE_P(file) != IS_STRING) { zend_error(E_WARNING, "Function name is no string"); - TRACE_APPEND_STR("[unknown function]"); + smart_str_appends(str, "[unknown function]"); } else{ - if (zend_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) { - if (Z_TYPE_PP(tmp) == IS_LONG) { - line = Z_LVAL_PP(tmp); + zend_long line; + tmp = zend_hash_str_find(ht, "line", sizeof("line")-1); + if (tmp) { + if (Z_TYPE_P(tmp) == IS_LONG) { + line = Z_LVAL_P(tmp); } else { zend_error(E_WARNING, "Line is no long"); line = 0; @@ -549,31 +494,36 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg } else { line = 0; } - s_tmp = emalloc(Z_STRLEN_PP(file) + MAX_LENGTH_OF_LONG + 4 + 1); - sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_PP(file), line); - TRACE_APPEND_STRL(s_tmp, strlen(s_tmp)); - efree(s_tmp); + smart_str_append(str, Z_STR_P(file)); + smart_str_appendc(str, '('); + smart_str_append_long(str, line); + smart_str_appends(str, "): "); } } else { - TRACE_APPEND_STR("[internal function]: "); + smart_str_appends(str, "[internal function]: "); } TRACE_APPEND_KEY("class"); TRACE_APPEND_KEY("type"); TRACE_APPEND_KEY("function"); - TRACE_APPEND_CHR('('); - if (zend_hash_find(ht, "args", sizeof("args"), (void**)&tmp) == SUCCESS) { - if (Z_TYPE_PP(tmp) == IS_ARRAY) { - int last_len = *len; - zend_hash_apply_with_arguments(Z_ARRVAL_PP(tmp) TSRMLS_CC, (apply_func_args_t)_build_trace_args, 2, str, len); - if (last_len != *len) { - *len -= 2; /* remove last ', ' */ + smart_str_appendc(str, '('); + tmp = zend_hash_str_find(ht, "args", sizeof("args")-1); + if (tmp) { + if (Z_TYPE_P(tmp) == IS_ARRAY) { + size_t last_len = str->s->len; + zval *arg; + + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmp), arg) { + _build_trace_args(arg, str); + } ZEND_HASH_FOREACH_END(); + + if (last_len != str->s->len) { + str->s->len -= 2; /* remove last ', ' */ } } else { zend_error(E_WARNING, "args element is no array"); } } - TRACE_APPEND_STR(")\n"); - return ZEND_HASH_APPLY_KEEP; + smart_str_appends(str, ")\n"); } /* }}} */ @@ -581,25 +531,29 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg Obtain the backtrace for the exception as a string (instead of an array) */ ZEND_METHOD(exception, getTraceAsString) { - zval *trace; - char *res, **str, *s_tmp; - int res_len = 0, *len = &res_len, num = 0; + zval *trace, *frame, rv; + zend_ulong index; + smart_str str = {0}; + uint32_t num = 0; DEFAULT_0_PARAMS; - - res = estrdup(""); - str = &res; - trace = zend_read_property(default_exception_ce, getThis(), "trace", sizeof("trace")-1, 1 TSRMLS_CC); - zend_hash_apply_with_arguments(Z_ARRVAL_P(trace) TSRMLS_CC, (apply_func_args_t)_build_trace_string, 3, str, len, &num); + trace = zend_read_property(default_exception_ce, getThis(), "trace", sizeof("trace")-1, 1, &rv); + ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(trace), index, frame) { + if (Z_TYPE_P(frame) != IS_ARRAY) { + zend_error(E_WARNING, "Expected array for frame %pu", index); + continue; + } + + _build_trace_string(&str, Z_ARRVAL_P(frame), num++); + } ZEND_HASH_FOREACH_END(); - s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 7 + 1); - sprintf(s_tmp, "#%d {main}", num); - TRACE_APPEND_STRL(s_tmp, strlen(s_tmp)); - efree(s_tmp); + smart_str_appendc(&str, '#'); + smart_str_append_long(&str, num); + smart_str_appends(&str, " {main}"); + smart_str_0(&str); - res[res_len] = '\0'; - RETURN_STRINGL(res, res_len, 0); + RETURN_NEW_STR(str.s); } /* }}} */ @@ -607,18 +561,17 @@ ZEND_METHOD(exception, getTraceAsString) Return previous Exception or NULL. */ ZEND_METHOD(exception, getPrevious) { - zval *previous; + zval rv; DEFAULT_0_PARAMS; - previous = zend_read_property(default_exception_ce, getThis(), "previous", sizeof("previous")-1, 1 TSRMLS_CC); - RETURN_ZVAL(previous, 1, 0); -} + ZVAL_COPY(return_value, GET_PROPERTY_SILENT(getThis(), "previous")); +} /* }}} */ -int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ */ +size_t zend_spprintf(char **message, size_t max_len, const char *format, ...) /* {{{ */ { va_list arg; - int len; + size_t len; va_start(arg, format); len = zend_vspprintf(message, max_len, format, arg); @@ -627,80 +580,85 @@ int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ * } /* }}} */ +zend_string *zend_strpprintf(size_t max_len, const char *format, ...) /* {{{ */ +{ + va_list arg; + zend_string *str; + + va_start(arg, format); + str = zend_vstrpprintf(max_len, format, arg); + va_end(arg); + return str; +} +/* }}} */ + /* {{{ proto string Exception::__toString() Obtain the string representation of the Exception object */ ZEND_METHOD(exception, __toString) { - zval message, file, line, *trace, *exception; - char *str, *prev_str; - int len = 0; + zval trace, *exception; + zend_string *str; zend_fcall_info fci; - zval fname; - + zval fname, rv; + DEFAULT_0_PARAMS; - - str = estrndup("", 0); + + str = STR_EMPTY_ALLOC(); exception = getThis(); - ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1, 1); + ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1); while (exception && Z_TYPE_P(exception) == IS_OBJECT) { - prev_str = str; - _default_exception_get_entry(exception, "message", sizeof("message")-1, &message TSRMLS_CC); - _default_exception_get_entry(exception, "file", sizeof("file")-1, &file TSRMLS_CC); - _default_exception_get_entry(exception, "line", sizeof("line")-1, &line TSRMLS_CC); - - convert_to_string(&message); - convert_to_string(&file); - convert_to_long(&line); + zend_string *prev_str = str; + zend_string *message = zval_get_string(GET_PROPERTY(exception, "message")); + zend_string *file = zval_get_string(GET_PROPERTY(exception, "file")); + zend_long line = zval_get_long(GET_PROPERTY(exception, "line")); fci.size = sizeof(fci); fci.function_table = &Z_OBJCE_P(exception)->function_table; - fci.function_name = &fname; + ZVAL_COPY_VALUE(&fci.function_name, &fname); fci.symbol_table = NULL; - fci.object_ptr = exception; - fci.retval_ptr_ptr = &trace; + fci.object = Z_OBJ_P(exception); + fci.retval = &trace; fci.param_count = 0; fci.params = NULL; fci.no_separation = 1; - zend_call_function(&fci, NULL TSRMLS_CC); + zend_call_function(&fci, NULL); - if (Z_TYPE_P(trace) != IS_STRING) { + if (Z_TYPE(trace) != IS_STRING) { zval_ptr_dtor(&trace); - trace = NULL; + ZVAL_UNDEF(&trace); } - if (Z_STRLEN(message) > 0) { - len = zend_spprintf(&str, 0, "exception '%s' with message '%s' in %s:%ld\nStack trace:\n%s%s%s", - Z_OBJCE_P(exception)->name, Z_STRVAL(message), Z_STRVAL(file), Z_LVAL(line), - (trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n", - len ? "\n\nNext " : "", prev_str); + if (message->len > 0) { + str = zend_strpprintf(0, "exception '%s' with message '%s' in %s:" ZEND_LONG_FMT + "\nStack trace:\n%s%s%s", + Z_OBJCE_P(exception)->name->val, message->val, file->val, line, + (Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", + prev_str->len ? "\n\nNext " : "", prev_str->val); } else { - len = zend_spprintf(&str, 0, "exception '%s' in %s:%ld\nStack trace:\n%s%s%s", - Z_OBJCE_P(exception)->name, Z_STRVAL(file), Z_LVAL(line), - (trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n", - len ? "\n\nNext " : "", prev_str); + str = zend_strpprintf(0, "exception '%s' in %s:" ZEND_LONG_FMT + "\nStack trace:\n%s%s%s", + Z_OBJCE_P(exception)->name->val, file->val, line, + (Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", + prev_str->len ? "\n\nNext " : "", prev_str->val); } - efree(prev_str); - zval_dtor(&message); - zval_dtor(&file); - zval_dtor(&line); - exception = zend_read_property(default_exception_ce, exception, "previous", sizeof("previous")-1, 0 TSRMLS_CC); - - if (trace) { - zval_ptr_dtor(&trace); - } + zend_string_release(prev_str); + zend_string_release(message); + zend_string_release(file); + zval_ptr_dtor(&trace); + exception = GET_PROPERTY(exception, "previous"); } zval_dtor(&fname); /* We store the result in the private property string so we can access * the result in uncaught exception handlers without memleaks. */ - zend_update_property_string(default_exception_ce, getThis(), "string", sizeof("string")-1, str TSRMLS_CC); + zend_update_property_str(default_exception_ce, getThis(), "string", sizeof("string")-1, str); - RETURN_STRINGL(str, len, 0); + RETURN_STR(str); } /* }}} */ @@ -720,7 +678,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_exception___construct, 0, 0, 0) ZEND_ARG_INFO(0, previous) ZEND_END_ARG_INFO() -const static zend_function_entry default_exception_functions[] = { +static const zend_function_entry default_exception_functions[] = { ZEND_ME(exception, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) ZEND_ME(exception, __construct, arginfo_exception___construct, ZEND_ACC_PUBLIC) ZEND_ME(exception, getMessage, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) @@ -731,7 +689,7 @@ const static zend_function_entry default_exception_functions[] = { ZEND_ME(exception, getPrevious, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) ZEND_ME(exception, getTraceAsString, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) ZEND_ME(exception, __toString, NULL, 0) - {NULL, NULL, NULL} + ZEND_FE_END }; ZEND_BEGIN_ARG_INFO_EX(arginfo_error_exception___construct, 0, 0, 0) @@ -746,95 +704,96 @@ ZEND_END_ARG_INFO() static const zend_function_entry error_exception_functions[] = { ZEND_ME(error_exception, __construct, arginfo_error_exception___construct, ZEND_ACC_PUBLIC) ZEND_ME(error_exception, getSeverity, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) - {NULL, NULL, NULL} + ZEND_FE_END }; /* }}} */ -void zend_register_default_exception(TSRMLS_D) /* {{{ */ +void zend_register_default_exception(void) /* {{{ */ { zend_class_entry ce; INIT_CLASS_ENTRY(ce, "Exception", default_exception_functions); - default_exception_ce = zend_register_internal_class(&ce TSRMLS_CC); + default_exception_ce = zend_register_internal_class(&ce); default_exception_ce->create_object = zend_default_exception_new; memcpy(&default_exception_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); default_exception_handlers.clone_obj = NULL; - zend_declare_property_string(default_exception_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC); - zend_declare_property_string(default_exception_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC); - zend_declare_property_long(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC); - zend_declare_property_null(default_exception_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED TSRMLS_CC); - zend_declare_property_null(default_exception_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED TSRMLS_CC); - zend_declare_property_null(default_exception_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE TSRMLS_CC); - zend_declare_property_null(default_exception_ce, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE TSRMLS_CC); + zend_declare_property_string(default_exception_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED); + zend_declare_property_string(default_exception_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE); + zend_declare_property_long(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED); + zend_declare_property_null(default_exception_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED); + zend_declare_property_null(default_exception_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED); + zend_declare_property_null(default_exception_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE); + zend_declare_property_null(default_exception_ce, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE); INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions); - error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce, NULL TSRMLS_CC); + error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce); error_exception_ce->create_object = zend_error_exception_new; - zend_declare_property_long(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC); + zend_declare_property_long(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED); } /* }}} */ -ZEND_API zend_class_entry *zend_exception_get_default(TSRMLS_D) /* {{{ */ +ZEND_API zend_class_entry *zend_exception_get_default(void) /* {{{ */ { return default_exception_ce; } /* }}} */ -ZEND_API zend_class_entry *zend_get_error_exception(TSRMLS_D) /* {{{ */ +ZEND_API zend_class_entry *zend_get_error_exception(void) /* {{{ */ { return error_exception_ce; } /* }}} */ -ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC) /* {{{ */ +ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_long code) /* {{{ */ { - zval *ex; + zval ex; - MAKE_STD_ZVAL(ex); if (exception_ce) { - if (!instanceof_function(exception_ce, default_exception_ce TSRMLS_CC)) { + if (!instanceof_function(exception_ce, default_exception_ce)) { zend_error(E_NOTICE, "Exceptions must be derived from the Exception base class"); exception_ce = default_exception_ce; } } else { exception_ce = default_exception_ce; } - object_init_ex(ex, exception_ce); + object_init_ex(&ex, exception_ce); if (message) { - zend_update_property_string(default_exception_ce, ex, "message", sizeof("message")-1, message TSRMLS_CC); + zend_update_property_string(default_exception_ce, &ex, "message", sizeof("message")-1, message); } if (code) { - zend_update_property_long(default_exception_ce, ex, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_long(default_exception_ce, &ex, "code", sizeof("code")-1, code); } - zend_throw_exception_internal(ex TSRMLS_CC); - return ex; + zend_throw_exception_internal(&ex); + return Z_OBJ(ex); } /* }}} */ -ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...) /* {{{ */ +ZEND_API zend_object *zend_throw_exception_ex(zend_class_entry *exception_ce, zend_long code, const char *format, ...) /* {{{ */ { va_list arg; char *message; - zval *zexception; + zend_object *obj; va_start(arg, format); zend_vspprintf(&message, 0, format, arg); va_end(arg); - zexception = zend_throw_exception(exception_ce, message, code TSRMLS_CC); + obj = zend_throw_exception(exception_ce, message, code); efree(message); - return zexception; + return obj; } /* }}} */ -ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC) /* {{{ */ +ZEND_API zend_object *zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, zend_long code, int severity) /* {{{ */ { - zval *ex = zend_throw_exception(exception_ce, message, code TSRMLS_CC); - zend_update_property_long(default_exception_ce, ex, "severity", sizeof("severity")-1, severity TSRMLS_CC); - return ex; + zval ex; + zend_object *obj = zend_throw_exception(exception_ce, message, code); + ZVAL_OBJ(&ex, obj); + zend_update_property_long(default_exception_ce, &ex, "severity", sizeof("severity")-1, severity); + return obj; } /* }}} */ @@ -849,56 +808,65 @@ static void zend_error_va(int type, const char *file, uint lineno, const char *f /* }}} */ /* This function doesn't return if it uses E_ERROR */ -ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {{{ */ +ZEND_API void zend_exception_error(zend_object *ex, int severity) /* {{{ */ { - zend_class_entry *ce_exception = Z_OBJCE_P(exception); - if (instanceof_function(ce_exception, default_exception_ce TSRMLS_CC)) { - zval *str, *file, *line; + zval exception; + zend_class_entry *ce_exception; + + ZVAL_OBJ(&exception, ex); + ce_exception = Z_OBJCE(exception); + if (instanceof_function(ce_exception, default_exception_ce)) { + zval tmp, rv; + zend_string *str, *file = NULL; + zend_long line = 0; EG(exception) = NULL; - zend_call_method_with_0_params(&exception, ce_exception, NULL, "__tostring", &str); + zend_call_method_with_0_params(&exception, ce_exception, NULL, "__tostring", &tmp); if (!EG(exception)) { - if (Z_TYPE_P(str) != IS_STRING) { - zend_error(E_WARNING, "%s::__toString() must return a string", ce_exception->name); + if (Z_TYPE(tmp) != IS_STRING) { + zend_error(E_WARNING, "%s::__toString() must return a string", ce_exception->name->val); } else { - zend_update_property_string(default_exception_ce, exception, "string", sizeof("string")-1, EG(exception) ? ce_exception->name : Z_STRVAL_P(str) TSRMLS_CC); + zend_update_property_string(default_exception_ce, &exception, "string", sizeof("string")-1, EG(exception) ? ce_exception->name->val : Z_STRVAL(tmp)); } } - zval_ptr_dtor(&str); + zval_ptr_dtor(&tmp); if (EG(exception)) { + zval zv; + + ZVAL_OBJ(&zv, EG(exception)); /* do the best we can to inform about the inner exception */ - if (instanceof_function(ce_exception, default_exception_ce TSRMLS_CC)) { - file = zend_read_property(default_exception_ce, EG(exception), "file", sizeof("file")-1, 1 TSRMLS_CC); - line = zend_read_property(default_exception_ce, EG(exception), "line", sizeof("line")-1, 1 TSRMLS_CC); + if (instanceof_function(ce_exception, default_exception_ce)) { + file = zval_get_string(GET_PROPERTY_SILENT(&zv, "file")); + line = zval_get_long(GET_PROPERTY_SILENT(&zv, "line")); + } - convert_to_string(file); - file = (Z_STRLEN_P(file) > 0) ? file : NULL; - line = (Z_TYPE_P(line) == IS_LONG) ? line : NULL; - } else { - file = NULL; - line = NULL; + zend_error_va(E_WARNING, (file && file->len > 0) ? file->val : NULL, line, + "Uncaught %s in exception handling during call to %s::__tostring()", + Z_OBJCE(zv)->name->val, ce_exception->name->val); + + if (file) { + zend_string_release(file); } - zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE_P(EG(exception))->name, ce_exception->name); } - str = zend_read_property(default_exception_ce, exception, "string", sizeof("string")-1, 1 TSRMLS_CC); - file = zend_read_property(default_exception_ce, exception, "file", sizeof("file")-1, 1 TSRMLS_CC); - line = zend_read_property(default_exception_ce, exception, "line", sizeof("line")-1, 1 TSRMLS_CC); + str = zval_get_string(GET_PROPERTY_SILENT(&exception, "string")); + file = zval_get_string(GET_PROPERTY_SILENT(&exception, "file")); + line = zval_get_long(GET_PROPERTY_SILENT(&exception, "line")); - convert_to_string(str); - convert_to_string(file); - convert_to_long(line); + zend_error_va(severity, (file && file->len > 0) ? file->val : NULL, line, + "Uncaught %s\n thrown", str->val); - zend_error_va(severity, (Z_STRLEN_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_LVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str)); + zend_string_release(str); + zend_string_release(file); } else { - zend_error(severity, "Uncaught exception '%s'", ce_exception->name); + zend_error(severity, "Uncaught exception '%s'", ce_exception->name->val); } } /* }}} */ -ZEND_API void zend_throw_exception_object(zval *exception TSRMLS_DC) /* {{{ */ +ZEND_API void zend_throw_exception_object(zval *exception) /* {{{ */ { zend_class_entry *exception_ce; @@ -908,10 +876,10 @@ ZEND_API void zend_throw_exception_object(zval *exception TSRMLS_DC) /* {{{ */ exception_ce = Z_OBJCE_P(exception); - if (!exception_ce || !instanceof_function(exception_ce, default_exception_ce TSRMLS_CC)) { + if (!exception_ce || !instanceof_function(exception_ce, default_exception_ce)) { zend_error(E_ERROR, "Exceptions must be valid objects derived from the Exception base class"); } - zend_throw_exception_internal(exception TSRMLS_CC); + zend_throw_exception_internal(exception); } /* }}} */ |