1 /*
2    +----------------------------------------------------------------------+
3    | Zend Engine                                                          |
4    +----------------------------------------------------------------------+
5    | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 2.00 of the Zend license,     |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.zend.com/license/2_00.txt.                                |
11    | If you did not receive a copy of the Zend license and are unable to  |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@zend.com so we can mail you a copy immediately.              |
14    +----------------------------------------------------------------------+
15    | Authors: Andi Gutmans <andi@php.net>                                 |
16    |          Marcus Boerger <helly@php.net>                              |
17    |          Sterling Hughes <sterling@php.net>                          |
18    |          Zeev Suraski <zeev@php.net>                                 |
19    +----------------------------------------------------------------------+
20 */
21 
22 #include "zend.h"
23 #include "zend_API.h"
24 #include "zend_builtin_functions.h"
25 #include "zend_interfaces.h"
26 #include "zend_exceptions.h"
27 #include "zend_vm.h"
28 #include "zend_dtrace.h"
29 #include "zend_smart_str.h"
30 
31 ZEND_API zend_class_entry *zend_ce_throwable;
32 ZEND_API zend_class_entry *zend_ce_exception;
33 ZEND_API zend_class_entry *zend_ce_error_exception;
34 ZEND_API zend_class_entry *zend_ce_error;
35 ZEND_API zend_class_entry *zend_ce_compile_error;
36 ZEND_API zend_class_entry *zend_ce_parse_error;
37 ZEND_API zend_class_entry *zend_ce_type_error;
38 ZEND_API zend_class_entry *zend_ce_argument_count_error;
39 ZEND_API zend_class_entry *zend_ce_arithmetic_error;
40 ZEND_API zend_class_entry *zend_ce_division_by_zero_error;
41 
42 ZEND_API void (*zend_throw_exception_hook)(zval *ex);
43 
44 static zend_object_handlers default_exception_handlers;
45 
46 /* {{{ zend_implement_throwable */
zend_implement_throwable(zend_class_entry *interface, zend_class_entry *class_type)47 static int zend_implement_throwable(zend_class_entry *interface, zend_class_entry *class_type)
48 {
49 	if (instanceof_function(class_type, zend_ce_exception) || instanceof_function(class_type, zend_ce_error)) {
50 		return SUCCESS;
51 	}
52 	zend_error_noreturn(E_ERROR, "Class %s cannot implement interface %s, extend %s or %s instead",
53 		ZSTR_VAL(class_type->name),
54 		ZSTR_VAL(interface->name),
55 		ZSTR_VAL(zend_ce_exception->name),
56 		ZSTR_VAL(zend_ce_error->name));
57 	return FAILURE;
58 }
59 /* }}} */
60 
i_get_exception_base(zval *object)61 static inline zend_class_entry *i_get_exception_base(zval *object) /* {{{ */
62 {
63 	return instanceof_function(Z_OBJCE_P(object), zend_ce_exception) ? zend_ce_exception : zend_ce_error;
64 }
65 /* }}} */
66 
zend_get_exception_base(zval *object)67 ZEND_API zend_class_entry *zend_get_exception_base(zval *object) /* {{{ */
68 {
69 	return i_get_exception_base(object);
70 }
71 /* }}} */
72 
zend_exception_set_previous(zend_object *exception, zend_object *add_previous)73 void zend_exception_set_previous(zend_object *exception, zend_object *add_previous) /* {{{ */
74 {
75     zval *previous, *ancestor, *ex;
76 	zval  pv, zv, rv;
77 	zend_class_entry *base_ce;
78 
79 	if (!exception || !add_previous) {
80 		return;
81 	}
82 
83 	if (exception == add_previous) {
84 		OBJ_RELEASE(add_previous);
85 		return;
86 	}
87 
88 	ZVAL_OBJ(&pv, add_previous);
89 	if (!instanceof_function(Z_OBJCE(pv), zend_ce_throwable)) {
90 		zend_error_noreturn(E_CORE_ERROR, "Previous exception must implement Throwable");
91 		return;
92 	}
93 	ZVAL_OBJ(&zv, exception);
94 	ex = &zv;
95 	do {
96 		ancestor = zend_read_property_ex(i_get_exception_base(&pv), &pv, ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
97 		while (Z_TYPE_P(ancestor) == IS_OBJECT) {
98 			if (Z_OBJ_P(ancestor) == Z_OBJ_P(ex)) {
99 				OBJ_RELEASE(add_previous);
100 				return;
101 			}
102 			ancestor = zend_read_property_ex(i_get_exception_base(ancestor), ancestor, ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
103 		}
104 		base_ce = i_get_exception_base(ex);
105 		previous = zend_read_property_ex(base_ce, ex, ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
106 		if (Z_TYPE_P(previous) == IS_NULL) {
107 			zend_update_property_ex(base_ce, ex, ZSTR_KNOWN(ZEND_STR_PREVIOUS), &pv);
108 			GC_DELREF(add_previous);
109 			return;
110 		}
111 		ex = previous;
112 	} while (Z_OBJ_P(ex) != add_previous);
113 }
114 /* }}} */
115 
zend_exception_save(void)116 void zend_exception_save(void) /* {{{ */
117 {
118 	if (EG(prev_exception)) {
119 		zend_exception_set_previous(EG(exception), EG(prev_exception));
120 	}
121 	if (EG(exception)) {
122 		EG(prev_exception) = EG(exception);
123 	}
124 	EG(exception) = NULL;
125 }
126 /* }}} */
127 
zend_exception_restore(void)128 void zend_exception_restore(void) /* {{{ */
129 {
130 	if (EG(prev_exception)) {
131 		if (EG(exception)) {
132 			zend_exception_set_previous(EG(exception), EG(prev_exception));
133 		} else {
134 			EG(exception) = EG(prev_exception);
135 		}
136 		EG(prev_exception) = NULL;
137 	}
138 }
139 /* }}} */
140 
zend_throw_exception_internal(zval *exception)141 ZEND_API ZEND_COLD void zend_throw_exception_internal(zval *exception) /* {{{ */
142 {
143 #ifdef HAVE_DTRACE
144 	if (DTRACE_EXCEPTION_THROWN_ENABLED()) {
145 		if (exception != NULL) {
146 			DTRACE_EXCEPTION_THROWN(ZSTR_VAL(Z_OBJ_P(exception)->ce->name));
147 		} else {
148 			DTRACE_EXCEPTION_THROWN(NULL);
149 		}
150 	}
151 #endif /* HAVE_DTRACE */
152 
153 	if (exception != NULL) {
154 		zend_object *previous = EG(exception);
155 		zend_exception_set_previous(Z_OBJ_P(exception), EG(exception));
156 		EG(exception) = Z_OBJ_P(exception);
157 		if (previous) {
158 			return;
159 		}
160 	}
161 	if (!EG(current_execute_data)) {
162 		if (exception && (Z_OBJCE_P(exception) == zend_ce_parse_error || Z_OBJCE_P(exception) == zend_ce_compile_error)) {
163 			return;
164 		}
165 		if(EG(exception)) {
166 			zend_exception_error(EG(exception), E_ERROR);
167 		}
168 		zend_error_noreturn(E_CORE_ERROR, "Exception thrown without a stack frame");
169 	}
170 
171 	if (zend_throw_exception_hook) {
172 		zend_throw_exception_hook(exception);
173 	}
174 
175 	if (!EG(current_execute_data)->func ||
176 	    !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) ||
177 	    EG(current_execute_data)->opline->opcode == ZEND_HANDLE_EXCEPTION) {
178 		/* no need to rethrow the exception */
179 		return;
180 	}
181 	EG(opline_before_exception) = EG(current_execute_data)->opline;
182 	EG(current_execute_data)->opline = EG(exception_op);
183 }
184 /* }}} */
185 
zend_clear_exception(void)186 ZEND_API void zend_clear_exception(void) /* {{{ */
187 {
188 	zend_object *exception;
189 	if (EG(prev_exception)) {
190 		OBJ_RELEASE(EG(prev_exception));
191 		EG(prev_exception) = NULL;
192 	}
193 	if (!EG(exception)) {
194 		return;
195 	}
196 	/* exception may have destructor */
197 	exception = EG(exception);
198 	EG(exception) = NULL;
199 	OBJ_RELEASE(exception);
200 	if (EG(current_execute_data)) {
201 		EG(current_execute_data)->opline = EG(opline_before_exception);
202 	}
203 #if ZEND_DEBUG
204 	EG(opline_before_exception) = NULL;
205 #endif
206 }
207 /* }}} */
208 
zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces)209 static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */
210 {
211 	zval obj, tmp;
212 	zend_object *object;
213 	zval trace;
214 	zend_class_entry *base_ce;
215 	zend_string *filename;
216 
217 	Z_OBJ(obj) = object = zend_objects_new(class_type);
218 	Z_OBJ_HT(obj) = &default_exception_handlers;
219 
220 	object_properties_init(object, class_type);
221 
222 	if (EG(current_execute_data)) {
223 		zend_fetch_debug_backtrace(&trace,
224 			skip_top_traces,
225 			EG(exception_ignore_args) ? DEBUG_BACKTRACE_IGNORE_ARGS : 0, 0);
226 	} else {
227 		array_init(&trace);
228 	}
229 	Z_SET_REFCOUNT(trace, 0);
230 
231 	base_ce = i_get_exception_base(&obj);
232 
233 	if (EXPECTED((class_type != zend_ce_parse_error && class_type != zend_ce_compile_error)
234 			|| !(filename = zend_get_compiled_filename()))) {
235 		ZVAL_STRING(&tmp, zend_get_executed_filename());
236 		zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_FILE), &tmp);
237 		zval_ptr_dtor(&tmp);
238 		ZVAL_LONG(&tmp, zend_get_executed_lineno());
239 		zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_LINE), &tmp);
240 	} else {
241 		ZVAL_STR(&tmp, filename);
242 		zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_FILE), &tmp);
243 		ZVAL_LONG(&tmp, zend_get_compiled_lineno());
244 		zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_LINE), &tmp);
245 	}
246 	zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_TRACE), &trace);
247 
248 	return object;
249 }
250 /* }}} */
251 
zend_default_exception_new(zend_class_entry *class_type)252 static zend_object *zend_default_exception_new(zend_class_entry *class_type) /* {{{ */
253 {
254 	return zend_default_exception_new_ex(class_type, 0);
255 }
256 /* }}} */
257 
zend_error_exception_new(zend_class_entry *class_type)258 static zend_object *zend_error_exception_new(zend_class_entry *class_type) /* {{{ */
259 {
260 	return zend_default_exception_new_ex(class_type, 2);
261 }
262 /* }}} */
263 
264 /* {{{ proto Exception|Error Exception|Error::__clone()
265    Clone the exception object */
ZEND_METHODnull266 ZEND_COLD ZEND_METHOD(exception, __clone)
267 {
268 	/* Should never be executable */
269 	zend_throw_exception(NULL, "Cannot clone object using __clone()", 0);
270 }
271 /* }}} */
272 
273 /* {{{ proto Exception|Error::__construct(string message, int code [, Throwable previous])
274    Exception constructor */
ZEND_METHODnull275 ZEND_METHOD(exception, __construct)
276 {
277 	zend_string *message = NULL;
278 	zend_long   code = 0;
279 	zval  tmp, *object, *previous = NULL;
280 	zend_class_entry *base_ce;
281 	int    argc = ZEND_NUM_ARGS();
282 
283 	object = ZEND_THIS;
284 	base_ce = i_get_exception_base(object);
285 
286 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SlO!", &message, &code, &previous, zend_ce_throwable) == FAILURE) {
287 		zend_class_entry *ce;
288 
289 		if (Z_TYPE(EX(This)) == IS_OBJECT) {
290 			ce = Z_OBJCE(EX(This));
291 		} else if (Z_CE(EX(This))) {
292 			ce = Z_CE(EX(This));
293 		} else {
294 			ce = base_ce;
295 		}
296 		zend_throw_error(NULL, "Wrong parameters for %s([string $message [, long $code [, Throwable $previous = NULL]]])", ZSTR_VAL(ce->name));
297 		return;
298 	}
299 
300 	if (message) {
301 		ZVAL_STR(&tmp, message);
302 		zend_update_property_ex(base_ce, object, ZSTR_KNOWN(ZEND_STR_MESSAGE), &tmp);
303 	}
304 
305 	if (code) {
306 		ZVAL_LONG(&tmp, code);
307 		zend_update_property_ex(base_ce, object, ZSTR_KNOWN(ZEND_STR_CODE), &tmp);
308 	}
309 
310 	if (previous) {
311 		zend_update_property_ex(base_ce, object, ZSTR_KNOWN(ZEND_STR_PREVIOUS), previous);
312 	}
313 }
314 /* }}} */
315 
316 /* {{{ proto Exception::__wakeup()
317    Exception unserialize checks */
318 #define CHECK_EXC_TYPE(id, type) \
319 	pvalue = zend_read_property_ex(i_get_exception_base(object), (object), ZSTR_KNOWN(id), 1, &value); \
320 	if (Z_TYPE_P(pvalue) != IS_NULL && Z_TYPE_P(pvalue) != type) { \
321 		zend_unset_property(i_get_exception_base(object), object, ZSTR_VAL(ZSTR_KNOWN(id)), ZSTR_LEN(ZSTR_KNOWN(id))); \
322 	}
323 
ZEND_METHODnull324 ZEND_METHOD(exception, __wakeup)
325 {
326 	zval value, *pvalue;
327 	zval *object = ZEND_THIS;
328 	CHECK_EXC_TYPE(ZEND_STR_MESSAGE,  IS_STRING);
329 	CHECK_EXC_TYPE(ZEND_STR_STRING,   IS_STRING);
330 	CHECK_EXC_TYPE(ZEND_STR_CODE,     IS_LONG);
331 	CHECK_EXC_TYPE(ZEND_STR_FILE,     IS_STRING);
332 	CHECK_EXC_TYPE(ZEND_STR_LINE,     IS_LONG);
333 	CHECK_EXC_TYPE(ZEND_STR_TRACE,    IS_ARRAY);
334 	pvalue = zend_read_property(i_get_exception_base(object), object, "previous", sizeof("previous")-1, 1, &value);
335 	if (pvalue && Z_TYPE_P(pvalue) != IS_NULL && (Z_TYPE_P(pvalue) != IS_OBJECT ||
336 			!instanceof_function(Z_OBJCE_P(pvalue), zend_ce_throwable) ||
337 			pvalue == object)) {
338 		zend_unset_property(i_get_exception_base(object), object, "previous", sizeof("previous")-1);
339 	}
340 }
341 /* }}} */
342 
343 /* {{{ proto ErrorException::__construct(string message, int code, int severity [, string filename [, int lineno [, Throwable previous]]])
344    ErrorException constructor */
ZEND_METHODnull345 ZEND_METHOD(error_exception, __construct)
346 {
347 	zend_string *message = NULL, *filename = NULL;
348 	zend_long   code = 0, severity = E_ERROR, lineno;
349 	zval   tmp, *object, *previous = NULL;
350 	int    argc = ZEND_NUM_ARGS();
351 
352 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SllSlO!", &message, &code, &severity, &filename, &lineno, &previous, zend_ce_throwable) == FAILURE) {
353 		zend_class_entry *ce;
354 
355 		if (Z_TYPE(EX(This)) == IS_OBJECT) {
356 			ce = Z_OBJCE(EX(This));
357 		} else if (Z_CE(EX(This))) {
358 			ce = Z_CE(EX(This));
359 		} else {
360 			ce = zend_ce_error_exception;
361 		}
362 		zend_throw_error(NULL, "Wrong parameters for %s([string $message [, long $code, [ long $severity, [ string $filename, [ long $lineno  [, Throwable $previous = NULL]]]]]])", ZSTR_VAL(ce->name));
363 		return;
364 	}
365 
366 	object = ZEND_THIS;
367 
368 	if (message) {
369 		ZVAL_STR_COPY(&tmp, message);
370 		zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_MESSAGE), &tmp);
371 		zval_ptr_dtor(&tmp);
372 	}
373 
374 	if (code) {
375 		ZVAL_LONG(&tmp, code);
376 		zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_CODE), &tmp);
377 	}
378 
379 	if (previous) {
380 		zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_PREVIOUS), previous);
381 	}
382 
383 	ZVAL_LONG(&tmp, severity);
384 	zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_SEVERITY), &tmp);
385 
386 	if (argc >= 4) {
387 		ZVAL_STR_COPY(&tmp, filename);
388 		zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_FILE), &tmp);
389 		zval_ptr_dtor(&tmp);
390     	if (argc < 5) {
391     	    lineno = 0; /* invalidate lineno */
392     	}
393 		ZVAL_LONG(&tmp, lineno);
394 		zend_update_property_ex(zend_ce_exception, object, ZSTR_KNOWN(ZEND_STR_LINE), &tmp);
395 	}
396 }
397 /* }}} */
398 
399 #define DEFAULT_0_PARAMS \
400 	if (zend_parse_parameters_none() == FAILURE) { \
401 		return; \
402 	}
403 
404 #define GET_PROPERTY(object, id) \
405 	zend_read_property_ex(i_get_exception_base(object), (object), ZSTR_KNOWN(id), 0, &rv)
406 #define GET_PROPERTY_SILENT(object, id) \
407 	zend_read_property_ex(i_get_exception_base(object), (object), ZSTR_KNOWN(id), 1, &rv)
408 
409 /* {{{ proto string Exception|Error::getFile()
410    Get the file in which the exception occurred */
ZEND_METHODnull411 ZEND_METHOD(exception, getFile)
412 {
413 	zval *prop, rv;
414 
415 	DEFAULT_0_PARAMS;
416 
417 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_FILE);
418 	ZVAL_DEREF(prop);
419 	ZVAL_COPY(return_value, prop);
420 }
421 /* }}} */
422 
423 /* {{{ proto int Exception|Error::getLine()
424    Get the line in which the exception occurred */
ZEND_METHODnull425 ZEND_METHOD(exception, getLine)
426 {
427 	zval *prop, rv;
428 
429 	DEFAULT_0_PARAMS;
430 
431 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_LINE);
432 	ZVAL_DEREF(prop);
433 	ZVAL_COPY(return_value, prop);
434 }
435 /* }}} */
436 
437 /* {{{ proto string Exception|Error::getMessage()
438    Get the exception message */
ZEND_METHODnull439 ZEND_METHOD(exception, getMessage)
440 {
441 	zval *prop, rv;
442 
443 	DEFAULT_0_PARAMS;
444 
445 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_MESSAGE);
446 	ZVAL_DEREF(prop);
447 	ZVAL_COPY(return_value, prop);
448 }
449 /* }}} */
450 
451 /* {{{ proto int Exception|Error::getCode()
452    Get the exception code */
ZEND_METHODnull453 ZEND_METHOD(exception, getCode)
454 {
455 	zval *prop, rv;
456 
457 	DEFAULT_0_PARAMS;
458 
459 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_CODE);
460 	ZVAL_DEREF(prop);
461 	ZVAL_COPY(return_value, prop);
462 }
463 /* }}} */
464 
465 /* {{{ proto array Exception|Error::getTrace()
466    Get the stack trace for the location in which the exception occurred */
ZEND_METHODnull467 ZEND_METHOD(exception, getTrace)
468 {
469 	zval *prop, rv;
470 
471 	DEFAULT_0_PARAMS;
472 
473 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_TRACE);
474 	ZVAL_DEREF(prop);
475 	ZVAL_COPY(return_value, prop);
476 }
477 /* }}} */
478 
479 /* {{{ proto int ErrorException::getSeverity()
480    Get the exception severity */
ZEND_METHODnull481 ZEND_METHOD(error_exception, getSeverity)
482 {
483 	zval *prop, rv;
484 
485 	DEFAULT_0_PARAMS;
486 
487 	prop = GET_PROPERTY(ZEND_THIS, ZEND_STR_SEVERITY);
488 	ZVAL_DEREF(prop);
489 	ZVAL_COPY(return_value, prop);
490 }
491 /* }}} */
492 
493 #define TRACE_APPEND_KEY(key) do {                                          \
494 		tmp = zend_hash_find(ht, key);                                      \
495 		if (tmp) {                                                          \
496 			if (Z_TYPE_P(tmp) != IS_STRING) {                               \
497 				zend_error(E_WARNING, "Value for %s is no string",          \
498 					ZSTR_VAL(key));                                         \
499 				smart_str_appends(str, "[unknown]");                        \
500 			} else {                                                        \
501 				smart_str_appends(str, Z_STRVAL_P(tmp));                    \
502 			}                                                               \
503 		} \
504 	} while (0)
505 
_build_trace_args(zval *arg, smart_str *str)506 static void _build_trace_args(zval *arg, smart_str *str) /* {{{ */
507 {
508 	/* the trivial way would be to do
509 	 * convert_to_string_ex(arg);
510 	 * append it and kill the now tmp arg.
511 	 * but that could cause some E_NOTICE and also damn long lines.
512 	 */
513 
514 	ZVAL_DEREF(arg);
515 	switch (Z_TYPE_P(arg)) {
516 		case IS_NULL:
517 			smart_str_appends(str, "NULL, ");
518 			break;
519 		case IS_STRING:
520 			smart_str_appendc(str, '\'');
521 			smart_str_append_escaped(str, Z_STRVAL_P(arg), MIN(Z_STRLEN_P(arg), 15));
522 			if (Z_STRLEN_P(arg) > 15) {
523 				smart_str_appends(str, "...', ");
524 			} else {
525 				smart_str_appends(str, "', ");
526 			}
527 			break;
528 		case IS_FALSE:
529 			smart_str_appends(str, "false, ");
530 			break;
531 		case IS_TRUE:
532 			smart_str_appends(str, "true, ");
533 			break;
534 		case IS_RESOURCE:
535 			smart_str_appends(str, "Resource id #");
536 			smart_str_append_long(str, Z_RES_HANDLE_P(arg));
537 			smart_str_appends(str, ", ");
538 			break;
539 		case IS_LONG:
540 			smart_str_append_long(str, Z_LVAL_P(arg));
541 			smart_str_appends(str, ", ");
542 			break;
543 		case IS_DOUBLE: {
544 			smart_str_append_printf(str, "%.*G", (int) EG(precision), Z_DVAL_P(arg));
545 			smart_str_appends(str, ", ");
546 			break;
547 		}
548 		case IS_ARRAY:
549 			smart_str_appends(str, "Array, ");
550 			break;
551 		case IS_OBJECT: {
552 			zend_string *class_name = Z_OBJ_HANDLER_P(arg, get_class_name)(Z_OBJ_P(arg));
553 			smart_str_appends(str, "Object(");
554 			smart_str_appends(str, ZSTR_VAL(class_name));
555 			smart_str_appends(str, "), ");
556 			zend_string_release_ex(class_name, 0);
557 			break;
558 		}
559 	}
560 }
561 /* }}} */
562 
_build_trace_string(smart_str *str, HashTable *ht, uint32_t num)563 static void _build_trace_string(smart_str *str, HashTable *ht, uint32_t num) /* {{{ */
564 {
565 	zval *file, *tmp;
566 
567 	smart_str_appendc(str, '#');
568 	smart_str_append_long(str, num);
569 	smart_str_appendc(str, ' ');
570 
571 	file = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_FILE), 1);
572 	if (file) {
573 		if (Z_TYPE_P(file) != IS_STRING) {
574 			zend_error(E_WARNING, "Function name is no string");
575 			smart_str_appends(str, "[unknown function]");
576 		} else{
577 			zend_long line;
578 			tmp = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_LINE), 1);
579 			if (tmp) {
580 				if (Z_TYPE_P(tmp) == IS_LONG) {
581 					line = Z_LVAL_P(tmp);
582 				} else {
583 					zend_error(E_WARNING, "Line is no long");
584 					line = 0;
585 				}
586 			} else {
587 				line = 0;
588 			}
589 			smart_str_append(str, Z_STR_P(file));
590 			smart_str_appendc(str, '(');
591 			smart_str_append_long(str, line);
592 			smart_str_appends(str, "): ");
593 		}
594 	} else {
595 		smart_str_appends(str, "[internal function]: ");
596 	}
597 	TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_CLASS));
598 	TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_TYPE));
599 	TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_FUNCTION));
600 	smart_str_appendc(str, '(');
601 	tmp = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_ARGS), 1);
602 	if (tmp) {
603 		if (Z_TYPE_P(tmp) == IS_ARRAY) {
604 			size_t last_len = ZSTR_LEN(str->s);
605 			zval *arg;
606 
607 			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmp), arg) {
608 				_build_trace_args(arg, str);
609 			} ZEND_HASH_FOREACH_END();
610 
611 			if (last_len != ZSTR_LEN(str->s)) {
612 				ZSTR_LEN(str->s) -= 2; /* remove last ', ' */
613 			}
614 		} else {
615 			zend_error(E_WARNING, "args element is no array");
616 		}
617 	}
618 	smart_str_appends(str, ")\n");
619 }
620 /* }}} */
621 
622 /* {{{ proto string Exception|Error::getTraceAsString()
623    Obtain the backtrace for the exception as a string (instead of an array) */
ZEND_METHODnull624 ZEND_METHOD(exception, getTraceAsString)
625 {
626 	zval *trace, *frame, rv;
627 	zend_ulong index;
628 	zval *object;
629 	zend_class_entry *base_ce;
630 	smart_str str = {0};
631 	uint32_t num = 0;
632 
633 	DEFAULT_0_PARAMS;
634 
635 	object = ZEND_THIS;
636 	base_ce = i_get_exception_base(object);
637 
638 	trace = zend_read_property_ex(base_ce, object, ZSTR_KNOWN(ZEND_STR_TRACE), 1, &rv);
639 	if (Z_TYPE_P(trace) != IS_ARRAY) {
640 		RETURN_FALSE;
641 	}
642 	ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(trace), index, frame) {
643 		if (Z_TYPE_P(frame) != IS_ARRAY) {
644 			zend_error(E_WARNING, "Expected array for frame " ZEND_ULONG_FMT, index);
645 			continue;
646 		}
647 
648 		_build_trace_string(&str, Z_ARRVAL_P(frame), num++);
649 	} ZEND_HASH_FOREACH_END();
650 
651 	smart_str_appendc(&str, '#');
652 	smart_str_append_long(&str, num);
653 	smart_str_appends(&str, " {main}");
654 	smart_str_0(&str);
655 
656 	RETURN_NEW_STR(str.s);
657 }
658 /* }}} */
659 
660 /* {{{ proto Throwable Exception|Error::getPrevious()
661    Return previous Throwable or NULL. */
ZEND_METHODnull662 ZEND_METHOD(exception, getPrevious)
663 {
664 	zval rv;
665 
666 	DEFAULT_0_PARAMS;
667 
668 	ZVAL_COPY(return_value, GET_PROPERTY_SILENT(ZEND_THIS, ZEND_STR_PREVIOUS));
669 } /* }}} */
670 
671 /* {{{ proto string Exception|Error::__toString()
672    Obtain the string representation of the Exception object */
ZEND_METHODnull673 ZEND_METHOD(exception, __toString)
674 {
675 	zval trace, *exception;
676 	zend_class_entry *base_ce;
677 	zend_string *str;
678 	zend_fcall_info fci;
679 	zval rv, tmp;
680 	zend_string *fname;
681 
682 	DEFAULT_0_PARAMS;
683 
684 	str = ZSTR_EMPTY_ALLOC();
685 
686 	exception = ZEND_THIS;
687 	fname = zend_string_init("gettraceasstring", sizeof("gettraceasstring")-1, 0);
688 
689 	while (exception && Z_TYPE_P(exception) == IS_OBJECT && instanceof_function(Z_OBJCE_P(exception), zend_ce_throwable)) {
690 		zend_string *prev_str = str;
691 		zend_string *message = zval_get_string(GET_PROPERTY(exception, ZEND_STR_MESSAGE));
692 		zend_string *file = zval_get_string(GET_PROPERTY(exception, ZEND_STR_FILE));
693 		zend_long line = zval_get_long(GET_PROPERTY(exception, ZEND_STR_LINE));
694 
695 		fci.size = sizeof(fci);
696 		ZVAL_STR(&fci.function_name, fname);
697 		fci.object = Z_OBJ_P(exception);
698 		fci.retval = &trace;
699 		fci.param_count = 0;
700 		fci.params = NULL;
701 		fci.no_separation = 1;
702 
703 		zend_call_function(&fci, NULL);
704 
705 		if (Z_TYPE(trace) != IS_STRING) {
706 			zval_ptr_dtor(&trace);
707 			ZVAL_UNDEF(&trace);
708 		}
709 
710 		if ((Z_OBJCE_P(exception) == zend_ce_type_error || Z_OBJCE_P(exception) == zend_ce_argument_count_error) && strstr(ZSTR_VAL(message), ", called in ")) {
711 			zend_string *real_message = zend_strpprintf(0, "%s and defined", ZSTR_VAL(message));
712 			zend_string_release_ex(message, 0);
713 			message = real_message;
714 		}
715 
716 		if (ZSTR_LEN(message) > 0) {
717 			str = zend_strpprintf(0, "%s: %s in %s:" ZEND_LONG_FMT
718 					"\nStack trace:\n%s%s%s",
719 					ZSTR_VAL(Z_OBJCE_P(exception)->name), ZSTR_VAL(message), ZSTR_VAL(file), line,
720 					(Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n",
721 					ZSTR_LEN(prev_str) ? "\n\nNext " : "", ZSTR_VAL(prev_str));
722 		} else {
723 			str = zend_strpprintf(0, "%s in %s:" ZEND_LONG_FMT
724 					"\nStack trace:\n%s%s%s",
725 					ZSTR_VAL(Z_OBJCE_P(exception)->name), ZSTR_VAL(file), line,
726 					(Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n",
727 					ZSTR_LEN(prev_str) ? "\n\nNext " : "", ZSTR_VAL(prev_str));
728 		}
729 
730 		zend_string_release_ex(prev_str, 0);
731 		zend_string_release_ex(message, 0);
732 		zend_string_release_ex(file, 0);
733 		zval_ptr_dtor(&trace);
734 
735 		Z_PROTECT_RECURSION_P(exception);
736 		exception = GET_PROPERTY(exception, ZEND_STR_PREVIOUS);
737 		if (exception && Z_TYPE_P(exception) == IS_OBJECT && Z_IS_RECURSIVE_P(exception)) {
738 			break;
739 		}
740 	}
741 	zend_string_release_ex(fname, 0);
742 
743 	exception = ZEND_THIS;
744 	/* Reset apply counts */
745 	while (exception && Z_TYPE_P(exception) == IS_OBJECT && (base_ce = i_get_exception_base(exception)) && instanceof_function(Z_OBJCE_P(exception), base_ce)) {
746 		if (Z_IS_RECURSIVE_P(exception)) {
747 			Z_UNPROTECT_RECURSION_P(exception);
748 		} else {
749 			break;
750 		}
751 		exception = GET_PROPERTY(exception, ZEND_STR_PREVIOUS);
752 	}
753 
754 	exception = ZEND_THIS;
755 	base_ce = i_get_exception_base(exception);
756 
757 	/* We store the result in the private property string so we can access
758 	 * the result in uncaught exception handlers without memleaks. */
759 	ZVAL_STR(&tmp, str);
760 	zend_update_property_ex(base_ce, exception, ZSTR_KNOWN(ZEND_STR_STRING), &tmp);
761 
762 	RETURN_STR(str);
763 }
764 /* }}} */
765 
766 /** {{{ Throwable method definition */
767 static const zend_function_entry zend_funcs_throwable[] = {
768 	ZEND_ABSTRACT_ME(throwable, getMessage,       NULL)
769 	ZEND_ABSTRACT_ME(throwable, getCode,          NULL)
770 	ZEND_ABSTRACT_ME(throwable, getFile,          NULL)
771 	ZEND_ABSTRACT_ME(throwable, getLine,          NULL)
772 	ZEND_ABSTRACT_ME(throwable, getTrace,         NULL)
773 	ZEND_ABSTRACT_ME(throwable, getPrevious,      NULL)
774 	ZEND_ABSTRACT_ME(throwable, getTraceAsString, NULL)
775 	ZEND_ABSTRACT_ME(throwable, __toString,       NULL)
776 	ZEND_FE_END
777 };
778 /* }}} */
779 
780 /* {{{ internal structs */
781 /* All functions that may be used in uncaught exception handlers must be final
782  * and must not throw exceptions. Otherwise we would need a facility to handle
783  * such exceptions in that handler.
784  * Also all getXY() methods are final because thy serve as read only access to
785  * their corresponding properties, no more, no less. If after all you need to
786  * override something then it is method __toString().
787  * And never try to change the state of exceptions and never implement anything
788  * that gives the user anything to accomplish this.
789  */
790 ZEND_BEGIN_ARG_INFO_EX(arginfo_exception___construct, 0, 0, 0)
791 	ZEND_ARG_INFO(0, message)
792 	ZEND_ARG_INFO(0, code)
793 	ZEND_ARG_INFO(0, previous)
794 ZEND_END_ARG_INFO()
795 
796 static const zend_function_entry default_exception_functions[] = {
797 	ZEND_ME(exception, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
798 	ZEND_ME(exception, __construct, arginfo_exception___construct, ZEND_ACC_PUBLIC)
799 	ZEND_ME(exception, __wakeup, NULL, ZEND_ACC_PUBLIC)
800 	ZEND_ME(exception, getMessage, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
801 	ZEND_ME(exception, getCode, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
802 	ZEND_ME(exception, getFile, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
803 	ZEND_ME(exception, getLine, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
804 	ZEND_ME(exception, getTrace, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
805 	ZEND_ME(exception, getPrevious, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
806 	ZEND_ME(exception, getTraceAsString, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
807 	ZEND_ME(exception, __toString, NULL, 0)
808 	ZEND_FE_END
809 };
810 
811 ZEND_BEGIN_ARG_INFO_EX(arginfo_error_exception___construct, 0, 0, 0)
812 	ZEND_ARG_INFO(0, message)
813 	ZEND_ARG_INFO(0, code)
814 	ZEND_ARG_INFO(0, severity)
815 	ZEND_ARG_INFO(0, filename)
816 	ZEND_ARG_INFO(0, lineno)
817 	ZEND_ARG_INFO(0, previous)
818 ZEND_END_ARG_INFO()
819 
820 static const zend_function_entry error_exception_functions[] = {
821 	ZEND_ME(error_exception, __construct, arginfo_error_exception___construct, ZEND_ACC_PUBLIC)
822 	ZEND_ME(error_exception, getSeverity, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
823 	ZEND_FE_END
824 };
825 /* }}} */
826 
zend_register_default_exception(void)827 void zend_register_default_exception(void) /* {{{ */
828 {
829 	zend_class_entry ce;
830 
831 	REGISTER_MAGIC_INTERFACE(throwable, Throwable);
832 
833 	memcpy(&default_exception_handlers, &std_object_handlers, sizeof(zend_object_handlers));
834 	default_exception_handlers.clone_obj = NULL;
835 
836 	INIT_CLASS_ENTRY(ce, "Exception", default_exception_functions);
837 	zend_ce_exception = zend_register_internal_class_ex(&ce, NULL);
838 	zend_ce_exception->create_object = zend_default_exception_new;
839 	zend_class_implements(zend_ce_exception, 1, zend_ce_throwable);
840 
841 	zend_declare_property_string(zend_ce_exception, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
842 	zend_declare_property_string(zend_ce_exception, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
843 	zend_declare_property_long(zend_ce_exception, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
844 	zend_declare_property_null(zend_ce_exception, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
845 	zend_declare_property_null(zend_ce_exception, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
846 	zend_declare_property_null(zend_ce_exception, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
847 	zend_declare_property_null(zend_ce_exception, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
848 
849 	INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions);
850 	zend_ce_error_exception = zend_register_internal_class_ex(&ce, zend_ce_exception);
851 	zend_ce_error_exception->create_object = zend_error_exception_new;
852 	zend_declare_property_long(zend_ce_error_exception, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED);
853 
854 	INIT_CLASS_ENTRY(ce, "Error", default_exception_functions);
855 	zend_ce_error = zend_register_internal_class_ex(&ce, NULL);
856 	zend_ce_error->create_object = zend_default_exception_new;
857 	zend_class_implements(zend_ce_error, 1, zend_ce_throwable);
858 
859 	zend_declare_property_string(zend_ce_error, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED);
860 	zend_declare_property_string(zend_ce_error, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE);
861 	zend_declare_property_long(zend_ce_error, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED);
862 	zend_declare_property_null(zend_ce_error, "file", sizeof("file")-1, ZEND_ACC_PROTECTED);
863 	zend_declare_property_null(zend_ce_error, "line", sizeof("line")-1, ZEND_ACC_PROTECTED);
864 	zend_declare_property_null(zend_ce_error, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE);
865 	zend_declare_property_null(zend_ce_error, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE);
866 
867 	INIT_CLASS_ENTRY(ce, "CompileError", NULL);
868 	zend_ce_compile_error = zend_register_internal_class_ex(&ce, zend_ce_error);
869 	zend_ce_compile_error->create_object = zend_default_exception_new;
870 
871 	INIT_CLASS_ENTRY(ce, "ParseError", NULL);
872 	zend_ce_parse_error = zend_register_internal_class_ex(&ce, zend_ce_compile_error);
873 	zend_ce_parse_error->create_object = zend_default_exception_new;
874 
875 	INIT_CLASS_ENTRY(ce, "TypeError", NULL);
876 	zend_ce_type_error = zend_register_internal_class_ex(&ce, zend_ce_error);
877 	zend_ce_type_error->create_object = zend_default_exception_new;
878 
879 	INIT_CLASS_ENTRY(ce, "ArgumentCountError", NULL);
880 	zend_ce_argument_count_error = zend_register_internal_class_ex(&ce, zend_ce_type_error);
881 	zend_ce_argument_count_error->create_object = zend_default_exception_new;
882 
883 	INIT_CLASS_ENTRY(ce, "ArithmeticError", NULL);
884 	zend_ce_arithmetic_error = zend_register_internal_class_ex(&ce, zend_ce_error);
885 	zend_ce_arithmetic_error->create_object = zend_default_exception_new;
886 
887 	INIT_CLASS_ENTRY(ce, "DivisionByZeroError", NULL);
888 	zend_ce_division_by_zero_error = zend_register_internal_class_ex(&ce, zend_ce_arithmetic_error);
889 	zend_ce_division_by_zero_error->create_object = zend_default_exception_new;
890 }
891 /* }}} */
892 
893 /* {{{ Deprecated - Use zend_ce_exception directly instead */
zend_exception_get_default(void)894 ZEND_API zend_class_entry *zend_exception_get_default(void)
895 {
896 	return zend_ce_exception;
897 }
898 /* }}} */
899 
900 /* {{{ Deprecated - Use zend_ce_error_exception directly instead */
zend_get_error_exception(void)901 ZEND_API zend_class_entry *zend_get_error_exception(void)
902 {
903 	return zend_ce_error_exception;
904 }
905 /* }}} */
906 
zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_long code)907 ZEND_API ZEND_COLD zend_object *zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_long code) /* {{{ */
908 {
909 	zval ex, tmp;
910 
911 	if (exception_ce) {
912 		if (!instanceof_function(exception_ce, zend_ce_throwable)) {
913 			zend_error(E_NOTICE, "Exceptions must implement Throwable");
914 			exception_ce = zend_ce_exception;
915 		}
916 	} else {
917 		exception_ce = zend_ce_exception;
918 	}
919 	object_init_ex(&ex, exception_ce);
920 
921 
922 	if (message) {
923 		ZVAL_STRING(&tmp, message);
924 		zend_update_property_ex(exception_ce, &ex, ZSTR_KNOWN(ZEND_STR_MESSAGE), &tmp);
925 		zval_ptr_dtor(&tmp);
926 	}
927 	if (code) {
928 		ZVAL_LONG(&tmp, code);
929 		zend_update_property_ex(exception_ce, &ex, ZSTR_KNOWN(ZEND_STR_CODE), &tmp);
930 	}
931 
932 	zend_throw_exception_internal(&ex);
933 	return Z_OBJ(ex);
934 }
935 /* }}} */
936 
zend_throw_exception_ex(zend_class_entry *exception_ce, zend_long code, const char *format, ...)937 ZEND_API ZEND_COLD zend_object *zend_throw_exception_ex(zend_class_entry *exception_ce, zend_long code, const char *format, ...) /* {{{ */
938 {
939 	va_list arg;
940 	char *message;
941 	zend_object *obj;
942 
943 	va_start(arg, format);
944 	zend_vspprintf(&message, 0, format, arg);
945 	va_end(arg);
946 	obj = zend_throw_exception(exception_ce, message, code);
947 	efree(message);
948 	return obj;
949 }
950 /* }}} */
951 
zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, zend_long code, int severity)952 ZEND_API ZEND_COLD zend_object *zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, zend_long code, int severity) /* {{{ */
953 {
954 	zval ex, tmp;
955 	zend_object *obj = zend_throw_exception(exception_ce, message, code);
956 	ZVAL_OBJ(&ex, obj);
957 	ZVAL_LONG(&tmp, severity);
958 	zend_update_property_ex(zend_ce_error_exception, &ex, ZSTR_KNOWN(ZEND_STR_SEVERITY), &tmp);
959 	return obj;
960 }
961 /* }}} */
962 
zend_error_va(int type, const char *file, uint32_t lineno, const char *format, ...)963 static void zend_error_va(int type, const char *file, uint32_t lineno, const char *format, ...) /* {{{ */
964 {
965 	va_list args;
966 
967 	va_start(args, format);
968 	zend_error_cb(type, file, lineno, format, args);
969 	va_end(args);
970 }
971 /* }}} */
972 
zend_error_helper(int type, const char *filename, const uint32_t lineno, const char *format, ...)973 static void zend_error_helper(int type, const char *filename, const uint32_t lineno, const char *format, ...) /* {{{ */
974 {
975 	va_list va;
976 
977 	va_start(va, format);
978 	zend_error_cb(type, filename, lineno, format, va);
979 	va_end(va);
980 }
981 /* }}} */
982 
983 /* This function doesn't return if it uses E_ERROR */
zend_exception_error(zend_object *ex, int severity)984 ZEND_API ZEND_COLD void zend_exception_error(zend_object *ex, int severity) /* {{{ */
985 {
986 	zval exception, rv;
987 	zend_class_entry *ce_exception;
988 
989 	ZVAL_OBJ(&exception, ex);
990 	ce_exception = ex->ce;
991 	EG(exception) = NULL;
992 	if (ce_exception == zend_ce_parse_error || ce_exception == zend_ce_compile_error) {
993 		zend_string *message = zval_get_string(GET_PROPERTY(&exception, ZEND_STR_MESSAGE));
994 		zend_string *file = zval_get_string(GET_PROPERTY_SILENT(&exception, ZEND_STR_FILE));
995 		zend_long line = zval_get_long(GET_PROPERTY_SILENT(&exception, ZEND_STR_LINE));
996 
997 		zend_error_helper(ce_exception == zend_ce_parse_error ? E_PARSE : E_COMPILE_ERROR,
998 			ZSTR_VAL(file), line, "%s", ZSTR_VAL(message));
999 
1000 		zend_string_release_ex(file, 0);
1001 		zend_string_release_ex(message, 0);
1002 	} else if (instanceof_function(ce_exception, zend_ce_throwable)) {
1003 		zval tmp;
1004 		zend_string *str, *file = NULL;
1005 		zend_long line = 0;
1006 
1007 		zend_call_method_with_0_params(&exception, ce_exception, &ex->ce->__tostring, "__tostring", &tmp);
1008 		if (!EG(exception)) {
1009 			if (Z_TYPE(tmp) != IS_STRING) {
1010 				zend_error(E_WARNING, "%s::__toString() must return a string", ZSTR_VAL(ce_exception->name));
1011 			} else {
1012 				zend_update_property_ex(i_get_exception_base(&exception), &exception, ZSTR_KNOWN(ZEND_STR_STRING), &tmp);
1013 			}
1014 		}
1015 		zval_ptr_dtor(&tmp);
1016 
1017 		if (EG(exception)) {
1018 			zval zv;
1019 
1020 			ZVAL_OBJ(&zv, EG(exception));
1021 			/* do the best we can to inform about the inner exception */
1022 			if (instanceof_function(ce_exception, zend_ce_exception) || instanceof_function(ce_exception, zend_ce_error)) {
1023 				file = zval_get_string(GET_PROPERTY_SILENT(&zv, ZEND_STR_FILE));
1024 				line = zval_get_long(GET_PROPERTY_SILENT(&zv, ZEND_STR_LINE));
1025 			}
1026 
1027 			zend_error_va(E_WARNING, (file && ZSTR_LEN(file) > 0) ? ZSTR_VAL(file) : NULL, line,
1028 				"Uncaught %s in exception handling during call to %s::__tostring()",
1029 				ZSTR_VAL(Z_OBJCE(zv)->name), ZSTR_VAL(ce_exception->name));
1030 
1031 			if (file) {
1032 				zend_string_release_ex(file, 0);
1033 			}
1034 		}
1035 
1036 		str = zval_get_string(GET_PROPERTY_SILENT(&exception, ZEND_STR_STRING));
1037 		file = zval_get_string(GET_PROPERTY_SILENT(&exception, ZEND_STR_FILE));
1038 		line = zval_get_long(GET_PROPERTY_SILENT(&exception, ZEND_STR_LINE));
1039 
1040 		zend_error_va(severity, (file && ZSTR_LEN(file) > 0) ? ZSTR_VAL(file) : NULL, line,
1041 			"Uncaught %s\n  thrown", ZSTR_VAL(str));
1042 
1043 		zend_string_release_ex(str, 0);
1044 		zend_string_release_ex(file, 0);
1045 	} else {
1046 		zend_error(severity, "Uncaught exception '%s'", ZSTR_VAL(ce_exception->name));
1047 	}
1048 
1049 	OBJ_RELEASE(ex);
1050 }
1051 /* }}} */
1052 
zend_throw_exception_object(zval *exception)1053 ZEND_API ZEND_COLD void zend_throw_exception_object(zval *exception) /* {{{ */
1054 {
1055 	zend_class_entry *exception_ce;
1056 
1057 	if (exception == NULL || Z_TYPE_P(exception) != IS_OBJECT) {
1058 		zend_error_noreturn(E_CORE_ERROR, "Need to supply an object when throwing an exception");
1059 	}
1060 
1061 	exception_ce = Z_OBJCE_P(exception);
1062 
1063 	if (!exception_ce || !instanceof_function(exception_ce, zend_ce_throwable)) {
1064 		zend_throw_error(NULL, "Cannot throw objects that do not implement Throwable");
1065 		zval_ptr_dtor(exception);
1066 		return;
1067 	}
1068 	zend_throw_exception_internal(exception);
1069 }
1070 /* }}} */
1071