diff options
Diffstat (limited to 'Zend/zend_exceptions.c')
| -rw-r--r-- | Zend/zend_exceptions.c | 473 |
1 files changed, 247 insertions, 226 deletions
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index e4570269e3..6d5aa720fa 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -34,26 +34,29 @@ 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); -void zend_exception_set_previous(zval *exception, zval *add_previous TSRMLS_DC) +void zend_exception_set_previous(zend_object *exception, zend_object *add_previous TSRMLS_DC) { - zval *previous; + zval tmp, *previous, zv, *pzv; 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 TSRMLS_CC)) { 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 TSRMLS_CC); 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 TSRMLS_CC); + GC_REFCOUNT(add_previous)--; return; } - exception = previous; - } + pzv = previous; + } while (pzv && Z_OBJ_P(pzv) != add_previous); } void zend_exception_save(TSRMLS_D) /* {{{ */ @@ -85,12 +88,11 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ { #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_THROWN_ENABLED()) { - const char *classname; - zend_uint name_len; + zend_string *classname; if (exception != NULL) { - zend_get_object_classname(exception, &classname, &name_len TSRMLS_CC); - DTRACE_EXCEPTION_THROWN((char *)classname); + classname = zend_get_object_classname(Z_OBJ_P(exception) TSRMLS_CC); + DTRACE_EXCEPTION_THROWN(classname->val); } else { DTRACE_EXCEPTION_THROWN(NULL); } @@ -98,9 +100,9 @@ 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) TSRMLS_CC); + EG(exception) = Z_OBJ_P(exception); if (previous) { return; } @@ -116,7 +118,8 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ zend_throw_exception_hook(exception TSRMLS_CC); } - 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; @@ -129,13 +132,14 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */ ZEND_API void zend_clear_exception(TSRMLS_D) /* {{{ */ { 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,37 +148,35 @@ 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 TSRMLS_DC) /* {{{ */ { 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 TSRMLS_CC); 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 TSRMLS_CC); + 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_int(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); - 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 TSRMLS_DC) /* {{{ */ { return zend_default_exception_new_ex(class_type, 0 TSRMLS_CC); } /* }}} */ -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 TSRMLS_DC) /* {{{ */ { return zend_default_exception_new_ex(class_type, 2 TSRMLS_CC); } @@ -193,23 +195,23 @@ ZEND_METHOD(exception, __clone) Exception constructor */ ZEND_METHOD(exception, __construct) { - char *message = NULL; + zend_string *message = NULL; 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 TSRMLS_CC, "|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 TSRMLS_CC); } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); } if (previous) { @@ -238,21 +240,21 @@ ZEND_METHOD(error_exception, __construct) } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); } if (previous) { zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous TSRMLS_CC); } - zend_update_property_long(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC); if (argc >= 4) { zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename TSRMLS_CC); 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_int(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC); } } /* }}} */ @@ -267,10 +269,7 @@ static void _default_exception_get_entry(zval *object, char *name, int name_len, 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); + ZVAL_COPY(return_value, value); } /* }}} */ @@ -335,45 +334,43 @@ ZEND_METHOD(error_exception, getSeverity) /* }}} */ /* {{{ gettraceasstring() macros */ -#define TRACE_APPEND_CHR(chr) \ - *str = (char*)erealloc(*str, *len + 1 + 1); \ - (*str)[(*len)++] = chr +#define TRACE_APPEND_CHR(chr) \ + str = STR_REALLOC(str, str->len + 1, 0); \ + str->val[str->len - 1] = chr -#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_STRL(v, l) \ + { \ + str = STR_REALLOC(str, str->len + (l), 0); \ + memcpy(str->val + str->len - (l), (v), (l)); \ } -#define TRACE_APPEND_STR(val) \ - TRACE_APPEND_STRL(val, sizeof(val)-1) +#define TRACE_APPEND_STR(v) \ + TRACE_APPEND_STRL((v), sizeof((v))-1) -#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)); \ - } \ - } +#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); \ + TRACE_APPEND_STR("[unknown]"); \ + } else { \ + TRACE_APPEND_STRL(Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); \ + } \ + } \ + } while (0) -#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); +#define TRACE_ARG_APPEND(vallen) do { \ + int len = str->len; \ + str = STR_REALLOC(str, len + vallen, 0); \ + memmove(str->val + len - l_added + 1 + vallen, str->val + len - l_added + 1, l_added); \ + } while (0) /* }}} */ -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, zend_string **str_ptr TSRMLS_DC) /* {{{ */ { - char **str; - int *len; - - str = va_arg(args, char**); - len = va_arg(args, int*); + zend_string *str = *str_ptr; /* the trivial way would be to do: * convert_to_string_ex(arg); @@ -381,48 +378,49 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z * 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, "); break; case IS_STRING: { int l_added; TRACE_APPEND_CHR('\''); - if (Z_STRLEN_PP(arg) > 15) { - TRACE_APPEND_STRL(Z_STRVAL_PP(arg), 15); + if (Z_STRSIZE_P(arg) > 15) { + TRACE_APPEND_STRL(Z_STRVAL_P(arg), 15); TRACE_APPEND_STR("...', "); l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */ } else { - l_added = Z_STRLEN_PP(arg); - TRACE_APPEND_STRL(Z_STRVAL_PP(arg), l_added); + l_added = Z_STRSIZE_P(arg); + TRACE_APPEND_STRL(Z_STRVAL_P(arg), l_added); TRACE_APPEND_STR("', "); l_added += 3 + 1; } while (--l_added) { - unsigned char chr = (*str)[*len - l_added]; + unsigned char chr = str->val[str->len - l_added]; if (chr < 32 || chr == '\\' || chr > 126) { - (*str)[*len - l_added] = '\\'; + str->val[str->len - l_added] = '\\'; switch (chr) { case '\n': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'n'; + str->val[str->len - l_added] = 'n'; break; case '\r': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'r'; + str->val[str->len - l_added] = 'r'; break; case '\t': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 't'; + str->val[str->len - l_added] = 't'; break; case '\f': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'f'; + str->val[str->len - l_added] = 'f'; break; case '\v': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'v'; + str->val[str->len - l_added] = 'v'; break; #ifndef PHP_WIN32 case '\e': @@ -430,51 +428,55 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z case VK_ESCAPE: #endif TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = 'e'; + str->val[str->len - l_added] = 'e'; break; case '\\': TRACE_ARG_APPEND(1); - (*str)[++(*len) - l_added] = '\\'; + str->val[str->len - l_added] = '\\'; break; default: TRACE_ARG_APPEND(3); - (*str)[*len - l_added + 1] = 'x'; + str->val[str->len - l_added - 2] = 'x'; if ((chr >> 4) < 10) { - (*str)[*len - l_added + 2] = (chr >> 4) + '0'; + str->val[str->len - l_added - 1] = (chr >> 4) + '0'; } else { - (*str)[*len - l_added + 2] = (chr >> 4) + 'A' - 10; + str->val[str->len - l_added - 1] = (chr >> 4) + 'A' - 10; } if (chr % 16 < 10) { - (*str)[*len - l_added + 3] = chr % 16 + '0'; + str->val[str->len - l_added] = chr % 16 + '0'; } else { - (*str)[*len - l_added + 3] = chr % 16 + 'A' - 10; + str->val[str->len - l_added] = chr % 16 + 'A' - 10; } - *len += 3; } } } break; } - case IS_BOOL: - if (Z_LVAL_PP(arg)) { - TRACE_APPEND_STR("true, "); - } else { - TRACE_APPEND_STR("false, "); - } + case IS_FALSE: + TRACE_APPEND_STR("false, "); break; - case IS_RESOURCE: + case IS_TRUE: + TRACE_APPEND_STR("true, "); + break; + case IS_RESOURCE: { + zend_int_t lval = Z_RES_HANDLE_P(arg); + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 1]; + int l_tmp = zend_sprintf(s_tmp, "%ld", lval); /* SAFE */ TRACE_APPEND_STR("Resource id #"); - /* break; */ - case IS_LONG: { - long lval = Z_LVAL_PP(arg); - char s_tmp[MAX_LENGTH_OF_LONG + 1]; + TRACE_APPEND_STRL(s_tmp, l_tmp); + TRACE_APPEND_STR(", "); + break; + } + case IS_INT: { + zend_int_t lval = Z_IVAL_P(arg); + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 1]; int l_tmp = zend_sprintf(s_tmp, "%ld", lval); /* SAFE */ TRACE_APPEND_STRL(s_tmp, l_tmp); TRACE_APPEND_STR(", "); break; } case IS_DOUBLE: { - double dval = Z_DVAL_PP(arg); + double dval = Z_DVAL_P(arg); char *s_tmp; int l_tmp; @@ -490,58 +492,52 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z TRACE_APPEND_STR("Array, "); break; case IS_OBJECT: { - const char *class_name; - zend_uint class_name_len; - int dup; + zend_string *class_name; 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); - } + class_name = zend_get_object_classname(Z_OBJ_P(arg) TSRMLS_CC); + TRACE_APPEND_STRL(class_name->val, class_name->len); TRACE_APPEND_STR("), "); break; } default: break; } - return ZEND_HASH_APPLY_KEEP; + *str_ptr = str; } /* }}} */ -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(zval *frame, zend_uint_t index, zend_string **str_ptr, int *num TSRMLS_DC) /* {{{ */ { - char *s_tmp, **str; - int *len, *num; + char *s_tmp; + int len; long line; - HashTable *ht = Z_ARRVAL_PP(frame); - zval **file, **tmp; + HashTable *ht; + zval *file, *tmp; + zend_string *str = *str_ptr; - if (Z_TYPE_PP(frame) != IS_ARRAY) { - zend_error(E_WARNING, "Expected array for frame %lu", hash_key->h); - return ZEND_HASH_APPLY_KEEP; + if (Z_TYPE_P(frame) != IS_ARRAY) { + zend_error(E_WARNING, "Expected array for frame %lu", index); + return; } - 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)); + ht = Z_ARRVAL_P(frame); + s_tmp = emalloc(1 + MAX_LENGTH_OF_ZEND_INT + 1 + 1); + len = sprintf(s_tmp, "#%d ", (*num)++); + TRACE_APPEND_STRL(s_tmp, len); 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]"); } else{ - if (zend_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) { - if (Z_TYPE_PP(tmp) == IS_LONG) { - line = Z_LVAL_PP(tmp); + tmp = zend_hash_str_find(ht, "line", sizeof("line")-1); + if (tmp) { + if (Z_TYPE_P(tmp) == IS_INT) { + line = Z_IVAL_P(tmp); } else { zend_error(E_WARNING, "Line is no long"); line = 0; @@ -549,9 +545,9 @@ 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)); + s_tmp = emalloc(Z_STRSIZE_P(file) + MAX_LENGTH_OF_ZEND_INT + 4 + 1); + len = sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_P(file), line); + TRACE_APPEND_STRL(s_tmp, len); efree(s_tmp); } } else { @@ -561,19 +557,25 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg 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 ', ' */ + tmp = zend_hash_str_find(ht, "args", sizeof("args")-1); + if (tmp) { + if (Z_TYPE_P(tmp) == IS_ARRAY) { + int last_len = str->len; + zval *arg; + + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmp), arg) { + _build_trace_args(arg, &str TSRMLS_CC); + } ZEND_HASH_FOREACH_END(); + + if (last_len != str->len) { + str->len -= 2; /* remove last ', ' */ } } else { zend_error(E_WARNING, "args element is no array"); } } TRACE_APPEND_STR(")\n"); - return ZEND_HASH_APPLY_KEEP; + *str_ptr = str; } /* }}} */ @@ -581,25 +583,27 @@ 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; + zend_uint_t index; + zend_string *str, *key; + int num = 0, len; + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 7 + 1 + 1]; DEFAULT_0_PARAMS; - res = estrdup(""); - str = &res; + str = STR_ALLOC(0, 0); 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); + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(trace), index, key, frame) { + _build_trace_string(frame, index, &str, &num TSRMLS_CC); + } 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); + len = sprintf(s_tmp, "#%d {main}", num); + TRACE_APPEND_STRL(s_tmp, len); - res[res_len] = '\0'; - RETURN_STRINGL(res, res_len, 0); + str->val[str->len] = '\0'; + + RETURN_NEW_STR(str); } /* }}} */ @@ -613,7 +617,7 @@ ZEND_METHOD(exception, getPrevious) previous = zend_read_property(default_exception_ce, getThis(), "previous", sizeof("previous")-1, 1 TSRMLS_CC); RETURN_ZVAL(previous, 1, 0); -} +} /* }}} */ int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ */ { @@ -627,22 +631,33 @@ int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ * } /* }}} */ +zend_string *zend_strpprintf(int 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 message, file, line, trace, *exception; + zend_string *str, *prev_str; zend_fcall_info fci; zval fname; 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; @@ -650,57 +665,55 @@ ZEND_METHOD(exception, __toString) _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); + convert_to_string_ex(&message); + convert_to_string_ex(&file); + convert_to_int_ex(&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); - 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 (Z_STRSIZE(message) > 0) { + str = zend_strpprintf(0, "exception '%s' with message '%s' in %s:%ld\nStack trace:\n%s%s%s", + Z_OBJCE_P(exception)->name->val, Z_STRVAL(message), Z_STRVAL(file), Z_IVAL(line), + (Z_TYPE(trace) == IS_STRING && Z_STRSIZE(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:%ld\nStack trace:\n%s%s%s", + Z_OBJCE_P(exception)->name->val, Z_STRVAL(file), Z_IVAL(line), + (Z_TYPE(trace) == IS_STRING && Z_STRSIZE(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", + prev_str->len ? "\n\nNext " : "", prev_str->val); } - efree(prev_str); + STR_RELEASE(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); - } + zval_ptr_dtor(&trace); } 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 TSRMLS_CC); - RETURN_STRINGL(str, len, 0); + RETURN_STR(str); } /* }}} */ @@ -762,16 +775,16 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */ 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_int(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); 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 TSRMLS_CC); 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_int(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC); } /* }}} */ @@ -787,11 +800,10 @@ ZEND_API zend_class_entry *zend_get_error_exception(TSRMLS_D) /* {{{ */ } /* }}} */ -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, long code TSRMLS_DC) /* {{{ */ { - zval *ex; + zval ex; - MAKE_STD_ZVAL(ex); if (exception_ce) { if (!instanceof_function(exception_ce, default_exception_ce TSRMLS_CC)) { zend_error(E_NOTICE, "Exceptions must be derived from the Exception base class"); @@ -800,41 +812,43 @@ ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char } 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 TSRMLS_CC); } if (code) { - zend_update_property_long(default_exception_ce, ex, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, &ex, "code", sizeof("code")-1, code TSRMLS_CC); } - zend_throw_exception_internal(ex TSRMLS_CC); - return ex; + zend_throw_exception_internal(&ex TSRMLS_CC); + 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, long code TSRMLS_DC, 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 TSRMLS_CC); 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, long code, int severity TSRMLS_DC) /* {{{ */ { - 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 TSRMLS_CC); + ZVAL_OBJ(&ex, obj); + zend_update_property_int(default_exception_ce, &ex, "severity", sizeof("severity")-1, severity TSRMLS_CC); + return obj; } /* }}} */ @@ -849,51 +863,58 @@ 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 TSRMLS_DC) /* {{{ */ { - zend_class_entry *ce_exception = Z_OBJCE_P(exception); + zval exception; + zend_class_entry *ce_exception; + + ZVAL_OBJ(&exception, ex); + ce_exception = Z_OBJCE(exception); if (instanceof_function(ce_exception, default_exception_ce TSRMLS_CC)) { - zval *str, *file, *line; + zval tmp, *str, *file, *line; 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) TSRMLS_CC); } } - 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); + file = zend_read_property(default_exception_ce, &zv, "file", sizeof("file")-1, 1 TSRMLS_CC); + line = zend_read_property(default_exception_ce, &zv, "line", sizeof("line")-1, 1 TSRMLS_CC); - convert_to_string(file); - file = (Z_STRLEN_P(file) > 0) ? file : NULL; - line = (Z_TYPE_P(line) == IS_LONG) ? line : NULL; + convert_to_string_ex(file); + file = (Z_STRSIZE_P(file) > 0) ? file : NULL; + line = (Z_TYPE_P(line) == IS_INT) ? line : NULL; } else { file = NULL; line = NULL; } - 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); + zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_IVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val); } - 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 = 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); - convert_to_string(str); - convert_to_string(file); - convert_to_long(line); + convert_to_string_ex(str); + convert_to_string_ex(file); + convert_to_int_ex(line); - 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_error_va(severity, (Z_STRSIZE_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_IVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str)); } else { - zend_error(severity, "Uncaught exception '%s'", ce_exception->name); + zend_error(severity, "Uncaught exception '%s'", ce_exception->name->val); } } /* }}} */ |