xref: /PHP-5.4/Zend/zend_builtin_functions.c (revision e51eaaf6)
1 /*
2    +----------------------------------------------------------------------+
3    | Zend Engine                                                          |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1998-2014 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@zend.com>                                |
16    |          Zeev Suraski <zeev@zend.com>                                |
17    +----------------------------------------------------------------------+
18 */
19 
20 /* $Id$ */
21 
22 #include "zend.h"
23 #include "zend_API.h"
24 #include "zend_builtin_functions.h"
25 #include "zend_constants.h"
26 #include "zend_ini.h"
27 #include "zend_exceptions.h"
28 #include "zend_extensions.h"
29 #include "zend_closures.h"
30 
31 #undef ZEND_TEST_EXCEPTIONS
32 
33 static ZEND_FUNCTION(zend_version);
34 static ZEND_FUNCTION(func_num_args);
35 static ZEND_FUNCTION(func_get_arg);
36 static ZEND_FUNCTION(func_get_args);
37 static ZEND_FUNCTION(strlen);
38 static ZEND_FUNCTION(strcmp);
39 static ZEND_FUNCTION(strncmp);
40 static ZEND_FUNCTION(strcasecmp);
41 static ZEND_FUNCTION(strncasecmp);
42 static ZEND_FUNCTION(each);
43 static ZEND_FUNCTION(error_reporting);
44 static ZEND_FUNCTION(define);
45 static ZEND_FUNCTION(defined);
46 static ZEND_FUNCTION(get_class);
47 static ZEND_FUNCTION(get_called_class);
48 static ZEND_FUNCTION(get_parent_class);
49 static ZEND_FUNCTION(method_exists);
50 static ZEND_FUNCTION(property_exists);
51 static ZEND_FUNCTION(class_exists);
52 static ZEND_FUNCTION(interface_exists);
53 static ZEND_FUNCTION(trait_exists);
54 static ZEND_FUNCTION(function_exists);
55 static ZEND_FUNCTION(class_alias);
56 #if ZEND_DEBUG
57 static ZEND_FUNCTION(leak);
58 static ZEND_FUNCTION(leak_variable);
59 #ifdef ZEND_TEST_EXCEPTIONS
60 static ZEND_FUNCTION(crash);
61 #endif
62 #endif
63 static ZEND_FUNCTION(get_included_files);
64 static ZEND_FUNCTION(is_subclass_of);
65 static ZEND_FUNCTION(is_a);
66 static ZEND_FUNCTION(get_class_vars);
67 static ZEND_FUNCTION(get_object_vars);
68 static ZEND_FUNCTION(get_class_methods);
69 static ZEND_FUNCTION(trigger_error);
70 static ZEND_FUNCTION(set_error_handler);
71 static ZEND_FUNCTION(restore_error_handler);
72 static ZEND_FUNCTION(set_exception_handler);
73 static ZEND_FUNCTION(restore_exception_handler);
74 static ZEND_FUNCTION(get_declared_classes);
75 static ZEND_FUNCTION(get_declared_traits);
76 static ZEND_FUNCTION(get_declared_interfaces);
77 static ZEND_FUNCTION(get_defined_functions);
78 static ZEND_FUNCTION(get_defined_vars);
79 static ZEND_FUNCTION(create_function);
80 static ZEND_FUNCTION(get_resource_type);
81 static ZEND_FUNCTION(get_loaded_extensions);
82 static ZEND_FUNCTION(extension_loaded);
83 static ZEND_FUNCTION(get_extension_funcs);
84 static ZEND_FUNCTION(get_defined_constants);
85 static ZEND_FUNCTION(debug_backtrace);
86 static ZEND_FUNCTION(debug_print_backtrace);
87 #if ZEND_DEBUG
88 static ZEND_FUNCTION(zend_test_func);
89 #ifdef ZTS
90 static ZEND_FUNCTION(zend_thread_id);
91 #endif
92 #endif
93 static ZEND_FUNCTION(gc_collect_cycles);
94 static ZEND_FUNCTION(gc_enabled);
95 static ZEND_FUNCTION(gc_enable);
96 static ZEND_FUNCTION(gc_disable);
97 
98 /* {{{ arginfo */
99 ZEND_BEGIN_ARG_INFO(arginfo_zend__void, 0)
100 ZEND_END_ARG_INFO()
101 
102 ZEND_BEGIN_ARG_INFO_EX(arginfo_func_get_arg, 0, 0, 1)
103 	ZEND_ARG_INFO(0, arg_num)
104 ZEND_END_ARG_INFO()
105 
106 ZEND_BEGIN_ARG_INFO_EX(arginfo_strlen, 0, 0, 1)
107 	ZEND_ARG_INFO(0, str)
108 ZEND_END_ARG_INFO()
109 
110 ZEND_BEGIN_ARG_INFO_EX(arginfo_strcmp, 0, 0, 2)
111 	ZEND_ARG_INFO(0, str1)
112 	ZEND_ARG_INFO(0, str2)
113 ZEND_END_ARG_INFO()
114 
115 ZEND_BEGIN_ARG_INFO_EX(arginfo_strncmp, 0, 0, 3)
116 	ZEND_ARG_INFO(0, str1)
117 	ZEND_ARG_INFO(0, str2)
118 	ZEND_ARG_INFO(0, len)
119 ZEND_END_ARG_INFO()
120 
121 ZEND_BEGIN_ARG_INFO_EX(arginfo_each, 0, 0, 1)
122 	ZEND_ARG_INFO(1, arr)
123 ZEND_END_ARG_INFO()
124 
125 ZEND_BEGIN_ARG_INFO_EX(arginfo_error_reporting, 0, 0, 0)
126 	ZEND_ARG_INFO(0, new_error_level)
127 ZEND_END_ARG_INFO()
128 
129 ZEND_BEGIN_ARG_INFO_EX(arginfo_define, 0, 0, 3)
130 	ZEND_ARG_INFO(0, constant_name)
131 	ZEND_ARG_INFO(0, value)
132 	ZEND_ARG_INFO(0, case_insensitive)
133 ZEND_END_ARG_INFO()
134 
135 ZEND_BEGIN_ARG_INFO_EX(arginfo_defined, 0, 0, 1)
136 	ZEND_ARG_INFO(0, constant_name)
137 ZEND_END_ARG_INFO()
138 
139 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_class, 0, 0, 0)
140 	ZEND_ARG_INFO(0, object)
141 ZEND_END_ARG_INFO()
142 
143 ZEND_BEGIN_ARG_INFO_EX(arginfo_is_subclass_of, 0, 0, 2)
144 	ZEND_ARG_INFO(0, object)
145 	ZEND_ARG_INFO(0, class_name)
146 	ZEND_ARG_INFO(0, allow_string)
147 ZEND_END_ARG_INFO()
148 
149 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_class_vars, 0, 0, 1)
150 	ZEND_ARG_INFO(0, class_name)
151 ZEND_END_ARG_INFO()
152 
153 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_object_vars, 0, 0, 1)
154 	ZEND_ARG_INFO(0, obj)
155 ZEND_END_ARG_INFO()
156 
157 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_class_methods, 0, 0, 1)
158 	ZEND_ARG_INFO(0, class)
159 ZEND_END_ARG_INFO()
160 
161 ZEND_BEGIN_ARG_INFO_EX(arginfo_method_exists, 0, 0, 2)
162 	ZEND_ARG_INFO(0, object)
163 	ZEND_ARG_INFO(0, method)
164 ZEND_END_ARG_INFO()
165 
166 ZEND_BEGIN_ARG_INFO_EX(arginfo_property_exists, 0, 0, 2)
167 	ZEND_ARG_INFO(0, object_or_class)
168 	ZEND_ARG_INFO(0, property_name)
169 ZEND_END_ARG_INFO()
170 
171 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_exists, 0, 0, 1)
172 	ZEND_ARG_INFO(0, classname)
173 	ZEND_ARG_INFO(0, autoload)
174 ZEND_END_ARG_INFO()
175 
176 ZEND_BEGIN_ARG_INFO_EX(arginfo_trait_exists, 0, 0, 1)
177 	ZEND_ARG_INFO(0, traitname)
178 	ZEND_ARG_INFO(0, autoload)
179 ZEND_END_ARG_INFO()
180 
181 ZEND_BEGIN_ARG_INFO_EX(arginfo_function_exists, 0, 0, 1)
182 	ZEND_ARG_INFO(0, function_name)
183 ZEND_END_ARG_INFO()
184 
185 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_alias, 0, 0, 2)
186 	ZEND_ARG_INFO(0, user_class_name)
187 	ZEND_ARG_INFO(0, alias_name)
188 	ZEND_ARG_INFO(0, autoload)
189 ZEND_END_ARG_INFO()
190 
191 #if ZEND_DEBUG
192 ZEND_BEGIN_ARG_INFO_EX(arginfo_leak_variable, 0, 0, 1)
193 	ZEND_ARG_INFO(0, variable)
194 	ZEND_ARG_INFO(0, leak_data)
195 ZEND_END_ARG_INFO()
196 #endif
197 
198 ZEND_BEGIN_ARG_INFO_EX(arginfo_trigger_error, 0, 0, 1)
199 	ZEND_ARG_INFO(0, message)
200 	ZEND_ARG_INFO(0, error_type)
201 ZEND_END_ARG_INFO()
202 
203 ZEND_BEGIN_ARG_INFO_EX(arginfo_set_error_handler, 0, 0, 1)
204 	ZEND_ARG_INFO(0, error_handler)
205 	ZEND_ARG_INFO(0, error_types)
206 ZEND_END_ARG_INFO()
207 
208 ZEND_BEGIN_ARG_INFO_EX(arginfo_set_exception_handler, 0, 0, 1)
209 	ZEND_ARG_INFO(0, exception_handler)
210 ZEND_END_ARG_INFO()
211 
212 ZEND_BEGIN_ARG_INFO_EX(arginfo_create_function, 0, 0, 2)
213 	ZEND_ARG_INFO(0, args)
214 	ZEND_ARG_INFO(0, code)
215 ZEND_END_ARG_INFO()
216 
217 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_resource_type, 0, 0, 1)
218 	ZEND_ARG_INFO(0, res)
219 ZEND_END_ARG_INFO()
220 
221 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_loaded_extensions, 0, 0, 0)
222 	ZEND_ARG_INFO(0, zend_extensions)
223 ZEND_END_ARG_INFO()
224 
225 ZEND_BEGIN_ARG_INFO_EX(arginfo_get_defined_constants, 0, 0, 0)
226 	ZEND_ARG_INFO(0, categorize)
227 ZEND_END_ARG_INFO()
228 
229 ZEND_BEGIN_ARG_INFO_EX(arginfo_debug_backtrace, 0, 0, 0)
230 	ZEND_ARG_INFO(0, options)
231 	ZEND_ARG_INFO(0, limit)
232 ZEND_END_ARG_INFO()
233 
234 ZEND_BEGIN_ARG_INFO_EX(arginfo_debug_print_backtrace, 0, 0, 0)
235 	ZEND_ARG_INFO(0, options)
236 ZEND_END_ARG_INFO()
237 
238 ZEND_BEGIN_ARG_INFO_EX(arginfo_extension_loaded, 0, 0, 1)
239 	ZEND_ARG_INFO(0, extension_name)
240 ZEND_END_ARG_INFO()
241 /* }}} */
242 
243 static const zend_function_entry builtin_functions[] = { /* {{{ */
244 	ZEND_FE(zend_version,		arginfo_zend__void)
245 	ZEND_FE(func_num_args,		arginfo_zend__void)
246 	ZEND_FE(func_get_arg,		arginfo_func_get_arg)
247 	ZEND_FE(func_get_args,		arginfo_zend__void)
248 	ZEND_FE(strlen,			arginfo_strlen)
249 	ZEND_FE(strcmp,			arginfo_strcmp)
250 	ZEND_FE(strncmp,		arginfo_strncmp)
251 	ZEND_FE(strcasecmp,		arginfo_strcmp)
252 	ZEND_FE(strncasecmp,		arginfo_strncmp)
253 	ZEND_FE(each,			arginfo_each)
254 	ZEND_FE(error_reporting,	arginfo_error_reporting)
255 	ZEND_FE(define,			arginfo_define)
256 	ZEND_FE(defined,		arginfo_defined)
257 	ZEND_FE(get_class,		arginfo_get_class)
258 	ZEND_FE(get_called_class,	arginfo_zend__void)
259 	ZEND_FE(get_parent_class,	arginfo_get_class)
260 	ZEND_FE(method_exists,		arginfo_method_exists)
261 	ZEND_FE(property_exists,	arginfo_property_exists)
262 	ZEND_FE(class_exists,		arginfo_class_exists)
263 	ZEND_FE(interface_exists,	arginfo_class_exists)
264 	ZEND_FE(trait_exists,		arginfo_trait_exists)
265 	ZEND_FE(function_exists,	arginfo_function_exists)
266 	ZEND_FE(class_alias,		arginfo_class_alias)
267 #if ZEND_DEBUG
268 	ZEND_FE(leak,				NULL)
269 	ZEND_FE(leak_variable,		arginfo_leak_variable)
270 #ifdef ZEND_TEST_EXCEPTIONS
271 	ZEND_FE(crash,				NULL)
272 #endif
273 #endif
274 	ZEND_FE(get_included_files,	arginfo_zend__void)
275 	ZEND_FALIAS(get_required_files,	get_included_files,		arginfo_zend__void)
276 	ZEND_FE(is_subclass_of,		arginfo_is_subclass_of)
277 	ZEND_FE(is_a,			arginfo_is_subclass_of)
278 	ZEND_FE(get_class_vars,		arginfo_get_class_vars)
279 	ZEND_FE(get_object_vars,	arginfo_get_object_vars)
280 	ZEND_FE(get_class_methods,	arginfo_get_class_methods)
281 	ZEND_FE(trigger_error,		arginfo_trigger_error)
282 	ZEND_FALIAS(user_error,		trigger_error,		arginfo_trigger_error)
283 	ZEND_FE(set_error_handler,		arginfo_set_error_handler)
284 	ZEND_FE(restore_error_handler,		arginfo_zend__void)
285 	ZEND_FE(set_exception_handler,		arginfo_set_exception_handler)
286 	ZEND_FE(restore_exception_handler,	arginfo_zend__void)
287 	ZEND_FE(get_declared_classes, 		arginfo_zend__void)
288 	ZEND_FE(get_declared_traits, 		arginfo_zend__void)
289 	ZEND_FE(get_declared_interfaces, 	arginfo_zend__void)
290 	ZEND_FE(get_defined_functions, 		arginfo_zend__void)
291 	ZEND_FE(get_defined_vars,		arginfo_zend__void)
292 	ZEND_FE(create_function,		arginfo_create_function)
293 	ZEND_FE(get_resource_type,		arginfo_get_resource_type)
294 	ZEND_FE(get_loaded_extensions,		arginfo_get_loaded_extensions)
295 	ZEND_FE(extension_loaded,		arginfo_extension_loaded)
296 	ZEND_FE(get_extension_funcs,		arginfo_extension_loaded)
297 	ZEND_FE(get_defined_constants,		arginfo_get_defined_constants)
298 	ZEND_FE(debug_backtrace, 		arginfo_debug_backtrace)
299 	ZEND_FE(debug_print_backtrace, 		arginfo_debug_print_backtrace)
300 #if ZEND_DEBUG
301 	ZEND_FE(zend_test_func,		NULL)
302 #ifdef ZTS
303 	ZEND_FE(zend_thread_id,		NULL)
304 #endif
305 #endif
306 	ZEND_FE(gc_collect_cycles, 	arginfo_zend__void)
307 	ZEND_FE(gc_enabled, 		arginfo_zend__void)
308 	ZEND_FE(gc_enable, 		arginfo_zend__void)
309 	ZEND_FE(gc_disable, 		arginfo_zend__void)
310 	ZEND_FE_END
311 };
312 /* }}} */
313 
ZEND_MINIT_FUNCTION(core)314 ZEND_MINIT_FUNCTION(core) { /* {{{ */
315 	zend_class_entry class_entry;
316 
317 	INIT_CLASS_ENTRY(class_entry, "stdClass", NULL);
318 	zend_standard_class_def = zend_register_internal_class(&class_entry TSRMLS_CC);
319 
320 	zend_register_default_classes(TSRMLS_C);
321 
322 	return SUCCESS;
323 }
324 /* }}} */
325 
326 zend_module_entry zend_builtin_module = { /* {{{ */
327     STANDARD_MODULE_HEADER,
328 	"Core",
329 	builtin_functions,
330 	ZEND_MINIT(core),
331 	NULL,
332 	NULL,
333 	NULL,
334 	NULL,
335 	ZEND_VERSION,
336 	STANDARD_MODULE_PROPERTIES
337 };
338 /* }}} */
339 
zend_startup_builtin_functions(TSRMLS_D)340 int zend_startup_builtin_functions(TSRMLS_D) /* {{{ */
341 {
342 	zend_builtin_module.module_number = 0;
343 	zend_builtin_module.type = MODULE_PERSISTENT;
344 	return (EG(current_module) = zend_register_module_ex(&zend_builtin_module TSRMLS_CC)) == NULL ? FAILURE : SUCCESS;
345 }
346 /* }}} */
347 
348 /* {{{ proto string zend_version(void)
349    Get the version of the Zend Engine */
ZEND_FUNCTION(zend_version)350 ZEND_FUNCTION(zend_version)
351 {
352 	RETURN_STRINGL(ZEND_VERSION, sizeof(ZEND_VERSION)-1, 1);
353 }
354 /* }}} */
355 
356 /* {{{ proto int gc_collect_cycles(void)
357    Forces collection of any existing garbage cycles.
358    Returns number of freed zvals */
ZEND_FUNCTION(gc_collect_cycles)359 ZEND_FUNCTION(gc_collect_cycles)
360 {
361 	RETURN_LONG(gc_collect_cycles(TSRMLS_C));
362 }
363 /* }}} */
364 
365 /* {{{ proto void gc_enabled(void)
366    Returns status of the circular reference collector */
ZEND_FUNCTION(gc_enabled)367 ZEND_FUNCTION(gc_enabled)
368 {
369 	RETURN_BOOL(GC_G(gc_enabled));
370 }
371 /* }}} */
372 
373 /* {{{ proto void gc_enable(void)
374    Activates the circular reference collector */
ZEND_FUNCTION(gc_enable)375 ZEND_FUNCTION(gc_enable)
376 {
377 	zend_alter_ini_entry("zend.enable_gc", sizeof("zend.enable_gc"), "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
378 }
379 /* }}} */
380 
381 /* {{{ proto void gc_disable(void)
382    Deactivates the circular reference collector */
ZEND_FUNCTION(gc_disable)383 ZEND_FUNCTION(gc_disable)
384 {
385 	zend_alter_ini_entry("zend.enable_gc", sizeof("zend.enable_gc"), "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
386 }
387 /* }}} */
388 
389 /* {{{ proto int func_num_args(void)
390    Get the number of arguments that were passed to the function */
ZEND_FUNCTION(func_num_args)391 ZEND_FUNCTION(func_num_args)
392 {
393 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
394 
395 	if (ex && ex->function_state.arguments) {
396 		RETURN_LONG((long)(zend_uintptr_t)*(ex->function_state.arguments));
397 	} else {
398 		zend_error(E_WARNING, "func_num_args():  Called from the global scope - no function context");
399 		RETURN_LONG(-1);
400 	}
401 }
402 /* }}} */
403 
404 
405 /* {{{ proto mixed func_get_arg(int arg_num)
406    Get the $arg_num'th argument that was passed to the function */
ZEND_FUNCTION(func_get_arg)407 ZEND_FUNCTION(func_get_arg)
408 {
409 	void **p;
410 	int arg_count;
411 	zval *arg;
412 	long requested_offset;
413 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
414 
415 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &requested_offset) == FAILURE) {
416 		return;
417 	}
418 
419 	if (requested_offset < 0) {
420 		zend_error(E_WARNING, "func_get_arg():  The argument number should be >= 0");
421 		RETURN_FALSE;
422 	}
423 
424 	if (!ex || !ex->function_state.arguments) {
425 		zend_error(E_WARNING, "func_get_arg():  Called from the global scope - no function context");
426 		RETURN_FALSE;
427 	}
428 
429 	p = ex->function_state.arguments;
430 	arg_count = (int)(zend_uintptr_t) *p;		/* this is the amount of arguments passed to func_get_arg(); */
431 
432 	if (requested_offset >= arg_count) {
433 		zend_error(E_WARNING, "func_get_arg():  Argument %ld not passed to function", requested_offset);
434 		RETURN_FALSE;
435 	}
436 
437 	arg = *(p-(arg_count-requested_offset));
438 	*return_value = *arg;
439 	zval_copy_ctor(return_value);
440 	INIT_PZVAL(return_value);
441 }
442 /* }}} */
443 
444 
445 /* {{{ proto array func_get_args()
446    Get an array of the arguments that were passed to the function */
ZEND_FUNCTION(func_get_args)447 ZEND_FUNCTION(func_get_args)
448 {
449 	void **p;
450 	int arg_count;
451 	int i;
452 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
453 
454 	if (!ex || !ex->function_state.arguments) {
455 		zend_error(E_WARNING, "func_get_args():  Called from the global scope - no function context");
456 		RETURN_FALSE;
457 	}
458 
459 	p = ex->function_state.arguments;
460 	arg_count = (int)(zend_uintptr_t) *p;		/* this is the amount of arguments passed to func_get_args(); */
461 
462 	array_init_size(return_value, arg_count);
463 	for (i=0; i<arg_count; i++) {
464 		zval *element;
465 
466 		ALLOC_ZVAL(element);
467 		*element = **((zval **) (p-(arg_count-i)));
468 		zval_copy_ctor(element);
469 		INIT_PZVAL(element);
470 		zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL);
471 	}
472 }
473 /* }}} */
474 
475 
476 /* {{{ proto int strlen(string str)
477    Get string length */
ZEND_FUNCTION(strlen)478 ZEND_FUNCTION(strlen)
479 {
480 	char *s1;
481 	int s1_len;
482 
483 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &s1, &s1_len) == FAILURE) {
484 		return;
485 	}
486 
487 	RETVAL_LONG(s1_len);
488 }
489 /* }}} */
490 
491 
492 /* {{{ proto int strcmp(string str1, string str2)
493    Binary safe string comparison */
ZEND_FUNCTION(strcmp)494 ZEND_FUNCTION(strcmp)
495 {
496 	char *s1, *s2;
497 	int s1_len, s2_len;
498 
499 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
500 		return;
501 	}
502 
503 	RETURN_LONG(zend_binary_strcmp(s1, s1_len, s2, s2_len));
504 }
505 /* }}} */
506 
507 
508 /* {{{ proto int strncmp(string str1, string str2, int len)
509    Binary safe string comparison */
ZEND_FUNCTION(strncmp)510 ZEND_FUNCTION(strncmp)
511 {
512 	char *s1, *s2;
513 	int s1_len, s2_len;
514 	long len;
515 
516 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
517 		return;
518 	}
519 
520 	if (len < 0) {
521 		zend_error(E_WARNING, "Length must be greater than or equal to 0");
522 		RETURN_FALSE;
523 	}
524 
525 	RETURN_LONG(zend_binary_strncmp(s1, s1_len, s2, s2_len, len));
526 }
527 /* }}} */
528 
529 
530 /* {{{ proto int strcasecmp(string str1, string str2)
531    Binary safe case-insensitive string comparison */
ZEND_FUNCTION(strcasecmp)532 ZEND_FUNCTION(strcasecmp)
533 {
534 	char *s1, *s2;
535 	int s1_len, s2_len;
536 
537 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
538 		return;
539 	}
540 
541 	RETURN_LONG(zend_binary_strcasecmp(s1, s1_len, s2, s2_len));
542 }
543 /* }}} */
544 
545 
546 /* {{{ proto int strncasecmp(string str1, string str2, int len)
547    Binary safe string comparison */
ZEND_FUNCTION(strncasecmp)548 ZEND_FUNCTION(strncasecmp)
549 {
550 	char *s1, *s2;
551 	int s1_len, s2_len;
552 	long len;
553 
554 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
555 		return;
556 	}
557 
558 	if (len < 0) {
559 		zend_error(E_WARNING, "Length must be greater than or equal to 0");
560 		RETURN_FALSE;
561 	}
562 
563 	RETURN_LONG(zend_binary_strncasecmp(s1, s1_len, s2, s2_len, len));
564 }
565 /* }}} */
566 
567 
568 /* {{{ proto array each(array arr)
569    Return the currently pointed key..value pair in the passed array, and advance the pointer to the next element */
ZEND_FUNCTION(each)570 ZEND_FUNCTION(each)
571 {
572 	zval *array, *entry, **entry_ptr, *tmp;
573 	char *string_key;
574 	uint string_key_len;
575 	ulong num_key;
576 	zval **inserted_pointer;
577 	HashTable *target_hash;
578 
579 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
580 		return;
581 	}
582 
583 	target_hash = HASH_OF(array);
584 	if (!target_hash) {
585 		zend_error(E_WARNING,"Variable passed to each() is not an array or object");
586 		return;
587 	}
588 	if (zend_hash_get_current_data(target_hash, (void **) &entry_ptr)==FAILURE) {
589 		RETURN_FALSE;
590 	}
591 	array_init(return_value);
592 	entry = *entry_ptr;
593 
594 	/* add value elements */
595 	if (Z_ISREF_P(entry)) {
596 		ALLOC_ZVAL(tmp);
597 		*tmp = *entry;
598 		zval_copy_ctor(tmp);
599 		Z_UNSET_ISREF_P(tmp);
600 		Z_SET_REFCOUNT_P(tmp, 0);
601 		entry=tmp;
602 	}
603 	zend_hash_index_update(return_value->value.ht, 1, &entry, sizeof(zval *), NULL);
604 	Z_ADDREF_P(entry);
605 	zend_hash_update(return_value->value.ht, "value", sizeof("value"), &entry, sizeof(zval *), NULL);
606 	Z_ADDREF_P(entry);
607 
608 	/* add the key elements */
609 	switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_key_len, &num_key, 1, NULL)) {
610 		case HASH_KEY_IS_STRING:
611 			add_get_index_stringl(return_value, 0, string_key, string_key_len-1, (void **) &inserted_pointer, 0);
612 			break;
613 		case HASH_KEY_IS_LONG:
614 			add_get_index_long(return_value, 0, num_key, (void **) &inserted_pointer);
615 			break;
616 	}
617 	zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
618 	Z_ADDREF_PP(inserted_pointer);
619 	zend_hash_move_forward(target_hash);
620 }
621 /* }}} */
622 
623 
624 /* {{{ proto int error_reporting([int new_error_level])
625    Return the current error_reporting level, and if an argument was passed - change to the new level */
ZEND_FUNCTION(error_reporting)626 ZEND_FUNCTION(error_reporting)
627 {
628 	char *err;
629 	int err_len;
630 	int old_error_reporting;
631 
632 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &err, &err_len) == FAILURE) {
633 		return;
634 	}
635 
636 	old_error_reporting = EG(error_reporting);
637 	if(ZEND_NUM_ARGS() != 0) {
638 		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
639 	}
640 
641 	RETVAL_LONG(old_error_reporting);
642 }
643 /* }}} */
644 
645 
646 /* {{{ proto bool define(string constant_name, mixed value, boolean case_insensitive=false)
647    Define a new constant */
ZEND_FUNCTION(define)648 ZEND_FUNCTION(define)
649 {
650 	char *name;
651 	int name_len;
652 	zval *val;
653 	zval *val_free = NULL;
654 	zend_bool non_cs = 0;
655 	int case_sensitive = CONST_CS;
656 	zend_constant c;
657 
658 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
659 		return;
660 	}
661 
662 	if(non_cs) {
663 		case_sensitive = 0;
664 	}
665 
666 	/* class constant, check if there is name and make sure class is valid & exists */
667 	if (zend_memnstr(name, "::", sizeof("::") - 1, name + name_len)) {
668 		zend_error(E_WARNING, "Class constants cannot be defined or redefined");
669 		RETURN_FALSE;
670 	}
671 
672 repeat:
673 	switch (Z_TYPE_P(val)) {
674 		case IS_LONG:
675 		case IS_DOUBLE:
676 		case IS_STRING:
677 		case IS_BOOL:
678 		case IS_RESOURCE:
679 		case IS_NULL:
680 			break;
681 		case IS_OBJECT:
682 			if (!val_free) {
683 				if (Z_OBJ_HT_P(val)->get) {
684 					val_free = val = Z_OBJ_HT_P(val)->get(val TSRMLS_CC);
685 					goto repeat;
686 				} else if (Z_OBJ_HT_P(val)->cast_object) {
687 					ALLOC_INIT_ZVAL(val_free);
688 					if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
689 						val = val_free;
690 						break;
691 					}
692 				}
693 			}
694 			/* no break */
695 		default:
696 			zend_error(E_WARNING,"Constants may only evaluate to scalar values");
697 			if (val_free) {
698 				zval_ptr_dtor(&val_free);
699 			}
700 			RETURN_FALSE;
701 	}
702 
703 	c.value = *val;
704 	zval_copy_ctor(&c.value);
705 	if (val_free) {
706 		zval_ptr_dtor(&val_free);
707 	}
708 	c.flags = case_sensitive; /* non persistent */
709 	c.name = IS_INTERNED(name) ? name : zend_strndup(name, name_len);
710 	if(c.name == NULL) {
711 		RETURN_FALSE;
712 	}
713 	c.name_len = name_len+1;
714 	c.module_number = PHP_USER_CONSTANT;
715 	if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) {
716 		RETURN_TRUE;
717 	} else {
718 		RETURN_FALSE;
719 	}
720 }
721 /* }}} */
722 
723 
724 /* {{{ proto bool defined(string constant_name)
725    Check whether a constant exists */
ZEND_FUNCTION(defined)726 ZEND_FUNCTION(defined)
727 {
728 	char *name;
729 	int name_len;
730 	zval c;
731 
732 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
733 		return;
734 	}
735 
736 	if (zend_get_constant_ex(name, name_len, &c, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
737 		zval_dtor(&c);
738 		RETURN_TRUE;
739 	} else {
740 		RETURN_FALSE;
741 	}
742 }
743 /* }}} */
744 
745 
746 /* {{{ proto string get_class([object object])
747    Retrieves the class name */
ZEND_FUNCTION(get_class)748 ZEND_FUNCTION(get_class)
749 {
750 	zval *obj = NULL;
751 	const char *name = "";
752 	zend_uint name_len = 0;
753 	int dup;
754 
755 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|o!", &obj) == FAILURE) {
756 		RETURN_FALSE;
757 	}
758 
759 	if (!obj) {
760 		if (EG(scope)) {
761 			RETURN_STRINGL(EG(scope)->name, EG(scope)->name_length, 1);
762 		} else {
763 			zend_error(E_WARNING, "get_class() called without object from outside a class");
764 			RETURN_FALSE;
765 		}
766 	}
767 
768 	dup = zend_get_object_classname(obj, &name, &name_len TSRMLS_CC);
769 
770 	RETURN_STRINGL(name, name_len, dup);
771 }
772 /* }}} */
773 
774 
775 /* {{{ proto string get_called_class()
776    Retrieves the "Late Static Binding" class name */
ZEND_FUNCTION(get_called_class)777 ZEND_FUNCTION(get_called_class)
778 {
779 	if (zend_parse_parameters_none() == FAILURE) {
780 		return;
781 	}
782 
783 	if (EG(called_scope)) {
784 		RETURN_STRINGL(EG(called_scope)->name, EG(called_scope)->name_length, 1);
785 	} else if (!EG(scope))  {
786 		zend_error(E_WARNING, "get_called_class() called from outside a class");
787 	}
788 	RETURN_FALSE;
789 }
790 /* }}} */
791 
792 
793 /* {{{ proto string get_parent_class([mixed object])
794    Retrieves the parent class name for object or class or current scope. */
ZEND_FUNCTION(get_parent_class)795 ZEND_FUNCTION(get_parent_class)
796 {
797 	zval *arg;
798 	zend_class_entry *ce = NULL;
799 	const char *name;
800 	zend_uint name_length;
801 
802 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
803 		return;
804 	}
805 
806 	if (!ZEND_NUM_ARGS()) {
807 		ce = EG(scope);
808 		if (ce && ce->parent) {
809 			RETURN_STRINGL(ce->parent->name, ce->parent->name_length, 1);
810 		} else {
811 			RETURN_FALSE;
812 		}
813 	}
814 
815 	if (Z_TYPE_P(arg) == IS_OBJECT) {
816 		if (Z_OBJ_HT_P(arg)->get_class_name
817 			&& Z_OBJ_HT_P(arg)->get_class_name(arg, &name, &name_length, 1 TSRMLS_CC) == SUCCESS) {
818 			RETURN_STRINGL(name, name_length, 0);
819 		} else {
820 			ce = zend_get_class_entry(arg TSRMLS_CC);
821 		}
822 	} else if (Z_TYPE_P(arg) == IS_STRING) {
823 		zend_class_entry **pce;
824 
825 		if (zend_lookup_class(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &pce TSRMLS_CC) == SUCCESS) {
826 			ce = *pce;
827 		}
828 	}
829 
830 	if (ce && ce->parent) {
831 		RETURN_STRINGL(ce->parent->name, ce->parent->name_length, 1);
832 	} else {
833 		RETURN_FALSE;
834 	}
835 }
836 /* }}} */
837 
838 
is_a_impl(INTERNAL_FUNCTION_PARAMETERS,zend_bool only_subclass)839 static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
840 {
841 	zval *obj;
842 	char *class_name;
843 	int class_name_len;
844 	zend_class_entry *instance_ce;
845 	zend_class_entry **ce;
846 	zend_bool allow_string = only_subclass;
847 	zend_bool retval;
848 
849 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|b", &obj, &class_name, &class_name_len, &allow_string) == FAILURE) {
850 		return;
851 	}
852 	/*
853 	 * allow_string - is_a default is no, is_subclass_of is yes.
854 	 *   if it's allowed, then the autoloader will be called if the class does not exist.
855 	 *   default behaviour is different, as 'is_a' used to be used to test mixed return values
856 	 *   and there is no easy way to deprecate this.
857 	 */
858 
859 	if (allow_string && Z_TYPE_P(obj) == IS_STRING) {
860 		zend_class_entry **the_ce;
861 		if (zend_lookup_class(Z_STRVAL_P(obj), Z_STRLEN_P(obj), &the_ce TSRMLS_CC) == FAILURE) {
862 			RETURN_FALSE;
863 		}
864 		instance_ce = *the_ce;
865 	} else if (Z_TYPE_P(obj) == IS_OBJECT && HAS_CLASS_ENTRY(*obj)) {
866 		instance_ce = Z_OBJCE_P(obj);
867 	} else {
868 		RETURN_FALSE;
869 	}
870 
871 	if (zend_lookup_class_ex(class_name, class_name_len, NULL, 0, &ce TSRMLS_CC) == FAILURE) {
872 		retval = 0;
873 	} else {
874 		if (only_subclass && instance_ce == *ce) {
875 			retval = 0;
876  		} else {
877 			retval = instanceof_function(instance_ce, *ce TSRMLS_CC);
878 		}
879 	}
880 
881 	RETURN_BOOL(retval);
882 }
883 
884 
885 /* {{{ proto bool is_subclass_of(mixed object_or_string, string class_name [, bool allow_string=true])
886    Returns true if the object has this class as one of its parents */
ZEND_FUNCTION(is_subclass_of)887 ZEND_FUNCTION(is_subclass_of)
888 {
889 	is_a_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
890 }
891 /* }}} */
892 
893 
894 /* {{{ proto bool is_a(mixed object_or_string, string class_name [, bool allow_string=false])
895    Returns true if the first argument is an object and is this class or has this class as one of its parents, */
ZEND_FUNCTION(is_a)896 ZEND_FUNCTION(is_a)
897 {
898 	is_a_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
899 }
900 /* }}} */
901 
902 
903 /* {{{ add_class_vars */
add_class_vars(zend_class_entry * ce,int statics,zval * return_value TSRMLS_DC)904 static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value TSRMLS_DC)
905 {
906 	HashPosition pos;
907 	zend_property_info *prop_info;
908 	zval *prop, *prop_copy;
909 	char *key;
910 	uint key_len;
911 	ulong num_index;
912 
913 	zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
914 	while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop_info, &pos) == SUCCESS) {
915 		zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
916 		zend_hash_move_forward_ex(&ce->properties_info, &pos);
917 		if (((prop_info->flags & ZEND_ACC_SHADOW) &&
918 		     prop_info->ce != EG(scope)) ||
919 		    ((prop_info->flags & ZEND_ACC_PROTECTED) &&
920 		     !zend_check_protected(prop_info->ce, EG(scope))) ||
921 		    ((prop_info->flags & ZEND_ACC_PRIVATE) &&
922 		      ce != EG(scope) &&
923 			  prop_info->ce != EG(scope))) {
924 			continue;
925 		}
926 		prop = NULL;
927 		if (prop_info->offset >= 0) {
928 			if (statics && (prop_info->flags & ZEND_ACC_STATIC) != 0) {
929 				prop = ce->default_static_members_table[prop_info->offset];
930 			} else if (!statics && (prop_info->flags & ZEND_ACC_STATIC) == 0) {
931 				prop = ce->default_properties_table[prop_info->offset];
932  			}
933 		}
934 		if (!prop) {
935 			continue;
936 		}
937 
938 		/* copy: enforce read only access */
939 		ALLOC_ZVAL(prop_copy);
940 		*prop_copy = *prop;
941 		zval_copy_ctor(prop_copy);
942 		INIT_PZVAL(prop_copy);
943 
944 		/* this is necessary to make it able to work with default array
945 		 * properties, returned to user */
946 		if (Z_TYPE_P(prop_copy) == IS_CONSTANT_ARRAY || (Z_TYPE_P(prop_copy) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
947 			zval_update_constant(&prop_copy, 0 TSRMLS_CC);
948 		}
949 
950 		add_assoc_zval(return_value, key, prop_copy);
951 	}
952 }
953 /* }}} */
954 
955 
956 /* {{{ proto array get_class_vars(string class_name)
957    Returns an array of default properties of the class. */
ZEND_FUNCTION(get_class_vars)958 ZEND_FUNCTION(get_class_vars)
959 {
960 	char *class_name;
961 	int class_name_len;
962 	zend_class_entry **pce;
963 
964 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &class_name, &class_name_len) == FAILURE) {
965 		return;
966 	}
967 
968 	if (zend_lookup_class(class_name, class_name_len, &pce TSRMLS_CC) == FAILURE) {
969 		RETURN_FALSE;
970 	} else {
971 		array_init(return_value);
972 		zend_update_class_constants(*pce TSRMLS_CC);
973 		add_class_vars(*pce, 0, return_value TSRMLS_CC);
974 		add_class_vars(*pce, 1, return_value TSRMLS_CC);
975 	}
976 }
977 /* }}} */
978 
979 
980 /* {{{ proto array get_object_vars(object obj)
981    Returns an array of object properties */
ZEND_FUNCTION(get_object_vars)982 ZEND_FUNCTION(get_object_vars)
983 {
984 	zval *obj;
985 	zval **value;
986 	HashTable *properties;
987 	HashPosition pos;
988 	char *key;
989 	const char *prop_name, *class_name;
990 	uint key_len;
991 	ulong num_index;
992 	zend_object *zobj;
993 
994 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
995 		return;
996 	}
997 
998 	if (Z_OBJ_HT_P(obj)->get_properties == NULL) {
999 		RETURN_FALSE;
1000 	}
1001 
1002 	properties = Z_OBJ_HT_P(obj)->get_properties(obj TSRMLS_CC);
1003 
1004 	if (properties == NULL) {
1005 		RETURN_FALSE;
1006 	}
1007 
1008 	zobj = zend_objects_get_address(obj TSRMLS_CC);
1009 
1010 	array_init(return_value);
1011 
1012 	zend_hash_internal_pointer_reset_ex(properties, &pos);
1013 
1014 	while (zend_hash_get_current_data_ex(properties, (void **) &value, &pos) == SUCCESS) {
1015 		if (zend_hash_get_current_key_ex(properties, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
1016 			if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
1017 				zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
1018 				/* Not separating references */
1019 				Z_ADDREF_PP(value);
1020 				add_assoc_zval_ex(return_value, prop_name, strlen(prop_name)+1, *value);
1021 			}
1022 		}
1023 		zend_hash_move_forward_ex(properties, &pos);
1024 	}
1025 }
1026 /* }}} */
1027 
same_name(const char * key,const char * name,zend_uint name_len)1028 static int same_name(const char *key, const char *name, zend_uint name_len)
1029 {
1030 	char *lcname = zend_str_tolower_dup(name, name_len);
1031 	int ret = memcmp(lcname, key, name_len) == 0;
1032 	efree(lcname);
1033 	return ret;
1034 }
1035 
1036 /* {{{ proto array get_class_methods(mixed class)
1037    Returns an array of method names for class or class instance. */
ZEND_FUNCTION(get_class_methods)1038 ZEND_FUNCTION(get_class_methods)
1039 {
1040 	zval *klass;
1041 	zval *method_name;
1042 	zend_class_entry *ce = NULL, **pce;
1043 	HashPosition pos;
1044 	zend_function *mptr;
1045 
1046 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &klass) == FAILURE) {
1047 		return;
1048 	}
1049 
1050 	if (Z_TYPE_P(klass) == IS_OBJECT) {
1051 		/* TBI!! new object handlers */
1052 		if (!HAS_CLASS_ENTRY(*klass)) {
1053 			RETURN_FALSE;
1054 		}
1055 		ce = Z_OBJCE_P(klass);
1056 	} else if (Z_TYPE_P(klass) == IS_STRING) {
1057 		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == SUCCESS) {
1058 			ce = *pce;
1059 		}
1060 	}
1061 
1062 	if (!ce) {
1063 		RETURN_NULL();
1064 	}
1065 
1066 	array_init(return_value);
1067 	zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
1068 
1069 	while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
1070 		if ((mptr->common.fn_flags & ZEND_ACC_PUBLIC)
1071 		 || (EG(scope) &&
1072 		     (((mptr->common.fn_flags & ZEND_ACC_PROTECTED) &&
1073 		       zend_check_protected(mptr->common.scope, EG(scope)))
1074 		   || ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) &&
1075 		       EG(scope) == mptr->common.scope)))) {
1076 			char *key;
1077 			uint key_len;
1078 			ulong num_index;
1079 			uint len = strlen(mptr->common.function_name);
1080 
1081 			/* Do not display old-style inherited constructors */
1082 			if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING) {
1083 				MAKE_STD_ZVAL(method_name);
1084 				ZVAL_STRINGL(method_name, mptr->common.function_name, len, 1);
1085 				zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
1086 			} else if ((mptr->common.fn_flags & ZEND_ACC_CTOR) == 0 ||
1087 			    mptr->common.scope == ce ||
1088 			    zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0) {
1089 
1090 				if (mptr->type == ZEND_USER_FUNCTION &&
1091 				    *mptr->op_array.refcount > 1 &&
1092 			    	(len != key_len - 1 ||
1093 			    	 !same_name(key, mptr->common.function_name, len))) {
1094 					MAKE_STD_ZVAL(method_name);
1095 					ZVAL_STRINGL(method_name, zend_find_alias_name(mptr->common.scope, key, key_len - 1), key_len - 1, 1);
1096 					zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
1097 				} else {
1098 					MAKE_STD_ZVAL(method_name);
1099 					ZVAL_STRINGL(method_name, mptr->common.function_name, len, 1);
1100 					zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
1101 				}
1102 			}
1103 		}
1104 		zend_hash_move_forward_ex(&ce->function_table, &pos);
1105 	}
1106 }
1107 /* }}} */
1108 
1109 
1110 /* {{{ proto bool method_exists(object object, string method)
1111    Checks if the class method exists */
ZEND_FUNCTION(method_exists)1112 ZEND_FUNCTION(method_exists)
1113 {
1114 	zval *klass;
1115 	char *method_name;
1116 	int method_len;
1117 	char *lcname;
1118 	zend_class_entry * ce, **pce;
1119 
1120 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &klass, &method_name, &method_len) == FAILURE) {
1121 		return;
1122 	}
1123 	if (Z_TYPE_P(klass) == IS_OBJECT) {
1124 		ce = Z_OBJCE_P(klass);
1125 	} else if (Z_TYPE_P(klass) == IS_STRING) {
1126 		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == FAILURE) {
1127 			RETURN_FALSE;
1128 		}
1129 		ce = *pce;
1130 	} else {
1131 		RETURN_FALSE;
1132 	}
1133 
1134 	lcname = zend_str_tolower_dup(method_name, method_len);
1135 	if (zend_hash_exists(&ce->function_table, lcname, method_len+1)) {
1136 		efree(lcname);
1137 		RETURN_TRUE;
1138 	} else {
1139 		union _zend_function *func = NULL;
1140 
1141 		if (Z_TYPE_P(klass) == IS_OBJECT
1142 		&& Z_OBJ_HT_P(klass)->get_method != NULL
1143 		&& (func = Z_OBJ_HT_P(klass)->get_method(&klass, method_name, method_len, NULL TSRMLS_CC)) != NULL
1144 		) {
1145 			if (func->type == ZEND_INTERNAL_FUNCTION
1146 			&& (func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0
1147 			) {
1148 				/* Returns true to the fake Closure's __invoke */
1149 				RETVAL_BOOL((func->common.scope == zend_ce_closure
1150 					&& (method_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
1151 					&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0) ? 1 : 0);
1152 
1153 				efree(lcname);
1154 				efree((char*)((zend_internal_function*)func)->function_name);
1155 				efree(func);
1156 				return;
1157 			}
1158 			efree(lcname);
1159 			RETURN_TRUE;
1160 		}
1161 	}
1162 	efree(lcname);
1163 	RETURN_FALSE;
1164 }
1165 /* }}} */
1166 
1167 /* {{{ proto bool property_exists(mixed object_or_class, string property_name)
1168    Checks if the object or class has a property */
ZEND_FUNCTION(property_exists)1169 ZEND_FUNCTION(property_exists)
1170 {
1171 	zval *object;
1172 	char *property;
1173 	int property_len;
1174 	zend_class_entry *ce, **pce;
1175 	zend_property_info *property_info;
1176 	zval property_z;
1177 	ulong h;
1178 
1179 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &object, &property, &property_len) == FAILURE) {
1180 		return;
1181 	}
1182 
1183 	if (property_len == 0) {
1184 		RETURN_FALSE;
1185 	}
1186 
1187 	if (Z_TYPE_P(object) == IS_STRING) {
1188 		if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == FAILURE) {
1189 			RETURN_FALSE;
1190 		}
1191 		ce = *pce;
1192 	} else if (Z_TYPE_P(object) == IS_OBJECT) {
1193 		ce = Z_OBJCE_P(object);
1194 	} else {
1195 		zend_error(E_WARNING, "First parameter must either be an object or the name of an existing class");
1196 		RETURN_NULL();
1197 	}
1198 
1199 	h = zend_get_hash_value(property, property_len+1);
1200 	if (zend_hash_quick_find(&ce->properties_info, property, property_len+1, h, (void **) &property_info) == SUCCESS
1201 		&& (property_info->flags & ZEND_ACC_SHADOW) == 0) {
1202 		RETURN_TRUE;
1203 	}
1204 
1205 	ZVAL_STRINGL(&property_z, property, property_len, 0);
1206 
1207 	if (Z_TYPE_P(object) ==  IS_OBJECT &&
1208 		Z_OBJ_HANDLER_P(object, has_property) &&
1209 		Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2, 0 TSRMLS_CC)) {
1210 		RETURN_TRUE;
1211 	}
1212 	RETURN_FALSE;
1213 }
1214 /* }}} */
1215 
1216 
1217 /* {{{ proto bool class_exists(string classname [, bool autoload])
1218    Checks if the class exists */
ZEND_FUNCTION(class_exists)1219 ZEND_FUNCTION(class_exists)
1220 {
1221 	char *class_name, *lc_name;
1222 	zend_class_entry **ce;
1223 	int class_name_len;
1224 	int found;
1225 	zend_bool autoload = 1;
1226 	ALLOCA_FLAG(use_heap)
1227 
1228 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &class_name, &class_name_len, &autoload) == FAILURE) {
1229 		return;
1230 	}
1231 
1232 	if (!autoload) {
1233 		char *name;
1234 		int len;
1235 
1236 		lc_name = do_alloca(class_name_len + 1, use_heap);
1237 		zend_str_tolower_copy(lc_name, class_name, class_name_len);
1238 
1239 		/* Ignore leading "\" */
1240 		name = lc_name;
1241 		len = class_name_len;
1242 		if (lc_name[0] == '\\') {
1243 			name = &lc_name[1];
1244 			len--;
1245 		}
1246 
1247 		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
1248 		free_alloca(lc_name, use_heap);
1249 		RETURN_BOOL(found == SUCCESS && !(((*ce)->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT)) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
1250 	}
1251 
1252  	if (zend_lookup_class(class_name, class_name_len, &ce TSRMLS_CC) == SUCCESS) {
1253  		RETURN_BOOL(((*ce)->ce_flags & (ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT - ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) == 0);
1254 	} else {
1255 		RETURN_FALSE;
1256 	}
1257 }
1258 /* }}} */
1259 
1260 /* {{{ proto bool interface_exists(string classname [, bool autoload])
1261    Checks if the class exists */
ZEND_FUNCTION(interface_exists)1262 ZEND_FUNCTION(interface_exists)
1263 {
1264 	char *iface_name, *lc_name;
1265 	zend_class_entry **ce;
1266 	int iface_name_len;
1267 	int found;
1268 	zend_bool autoload = 1;
1269 	ALLOCA_FLAG(use_heap)
1270 
1271 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &iface_name, &iface_name_len, &autoload) == FAILURE) {
1272 		return;
1273 	}
1274 
1275 	if (!autoload) {
1276 		char *name;
1277 		int len;
1278 
1279 		lc_name = do_alloca(iface_name_len + 1, use_heap);
1280 		zend_str_tolower_copy(lc_name, iface_name, iface_name_len);
1281 
1282 		/* Ignore leading "\" */
1283 		name = lc_name;
1284 		len = iface_name_len;
1285 		if (lc_name[0] == '\\') {
1286 			name = &lc_name[1];
1287 			len--;
1288 		}
1289 
1290 		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
1291 		free_alloca(lc_name, use_heap);
1292 		RETURN_BOOL(found == SUCCESS && (*ce)->ce_flags & ZEND_ACC_INTERFACE);
1293 	}
1294 
1295  	if (zend_lookup_class(iface_name, iface_name_len, &ce TSRMLS_CC) == SUCCESS) {
1296  		RETURN_BOOL(((*ce)->ce_flags & ZEND_ACC_INTERFACE) > 0);
1297 	} else {
1298 		RETURN_FALSE;
1299 	}
1300 }
1301 /* }}} */
1302 
1303 /* {{{ proto bool trait_exists(string traitname [, bool autoload])
1304  Checks if the trait exists */
ZEND_FUNCTION(trait_exists)1305 ZEND_FUNCTION(trait_exists)
1306 {
1307 	char *trait_name, *lc_name;
1308 	zend_class_entry **ce;
1309 	int trait_name_len;
1310 	int found;
1311 	zend_bool autoload = 1;
1312 	ALLOCA_FLAG(use_heap)
1313 
1314 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &trait_name, &trait_name_len, &autoload) == FAILURE) {
1315 		return;
1316 	}
1317 
1318 	if (!autoload) {
1319 		char *name;
1320 		int len;
1321 
1322 		lc_name = do_alloca(trait_name_len + 1, use_heap);
1323 		zend_str_tolower_copy(lc_name, trait_name, trait_name_len);
1324 
1325 		/* Ignore leading "\" */
1326 		name = lc_name;
1327 		len = trait_name_len;
1328 		if (lc_name[0] == '\\') {
1329 			name = &lc_name[1];
1330 			len--;
1331 		}
1332 
1333 		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
1334 		free_alloca(lc_name, use_heap);
1335 		RETURN_BOOL(found == SUCCESS && (((*ce)->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
1336 	}
1337 
1338  	if (zend_lookup_class(trait_name, trait_name_len, &ce TSRMLS_CC) == SUCCESS) {
1339  		RETURN_BOOL(((*ce)->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
1340 	} else {
1341 		RETURN_FALSE;
1342 	}
1343 }
1344 /* }}} */
1345 
1346 
1347 /* {{{ proto bool function_exists(string function_name)
1348    Checks if the function exists */
ZEND_FUNCTION(function_exists)1349 ZEND_FUNCTION(function_exists)
1350 {
1351 	char *name;
1352 	int name_len;
1353 	zend_function *func;
1354 	char *lcname;
1355 	zend_bool retval;
1356 
1357 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
1358 		return;
1359 	}
1360 
1361 	lcname = zend_str_tolower_dup(name, name_len);
1362 
1363 	/* Ignore leading "\" */
1364 	name = lcname;
1365 	if (lcname[0] == '\\') {
1366 		name = &lcname[1];
1367 		name_len--;
1368 	}
1369 
1370 	retval = (zend_hash_find(EG(function_table), name, name_len+1, (void **)&func) == SUCCESS);
1371 
1372 	efree(lcname);
1373 
1374 	/*
1375 	 * A bit of a hack, but not a bad one: we see if the handler of the function
1376 	 * is actually one that displays "function is disabled" message.
1377 	 */
1378 	if (retval && func->type == ZEND_INTERNAL_FUNCTION &&
1379 		func->internal_function.handler == zif_display_disabled_function) {
1380 		retval = 0;
1381 	}
1382 
1383 	RETURN_BOOL(retval);
1384 }
1385 /* }}} */
1386 
1387 /* {{{ proto bool class_alias(string user_class_name , string alias_name [, bool autoload])
1388    Creates an alias for user defined class */
ZEND_FUNCTION(class_alias)1389 ZEND_FUNCTION(class_alias)
1390 {
1391 	char *class_name, *lc_name, *alias_name;
1392 	zend_class_entry **ce;
1393 	int class_name_len, alias_name_len;
1394 	int found;
1395 	zend_bool autoload = 1;
1396 	ALLOCA_FLAG(use_heap)
1397 
1398 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &class_name, &class_name_len, &alias_name, &alias_name_len, &autoload) == FAILURE) {
1399 		return;
1400 	}
1401 
1402 	found = zend_lookup_class_ex(class_name, class_name_len, NULL, autoload, &ce TSRMLS_CC);
1403 
1404 	if (found == SUCCESS) {
1405 		if ((*ce)->type == ZEND_USER_CLASS) {
1406 			if (zend_register_class_alias_ex(alias_name, alias_name_len, *ce TSRMLS_CC) == SUCCESS) {
1407 				RETURN_TRUE;
1408 			} else {
1409 				zend_error(E_WARNING, "Cannot redeclare class %s", alias_name);
1410 				RETURN_FALSE;
1411 			}
1412 		} else {
1413 			zend_error(E_WARNING, "First argument of class_alias() must be a name of user defined class");
1414 			RETURN_FALSE;
1415 		}
1416 	} else {
1417 		zend_error(E_WARNING, "Class '%s' not found", class_name);
1418 		RETURN_FALSE;
1419 	}
1420 }
1421 /* }}} */
1422 
1423 #if ZEND_DEBUG
1424 /* {{{ proto void leak(int num_bytes=3)
1425    Cause an intentional memory leak, for testing/debugging purposes */
ZEND_FUNCTION(leak)1426 ZEND_FUNCTION(leak)
1427 {
1428 	long leakbytes=3;
1429 
1430 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) {
1431 		return;
1432 	}
1433 
1434 	emalloc(leakbytes);
1435 }
1436 /* }}} */
1437 
1438 /* {{{ proto leak_variable(mixed variable [, bool leak_data]) */
ZEND_FUNCTION(leak_variable)1439 ZEND_FUNCTION(leak_variable)
1440 {
1441 	zval *zv;
1442 	zend_bool leak_data = 0;
1443 
1444 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &zv, &leak_data) == FAILURE) {
1445 		return;
1446 	}
1447 
1448 	if (!leak_data) {
1449 		zval_add_ref(&zv);
1450 	} else if (Z_TYPE_P(zv) == IS_RESOURCE) {
1451 		zend_list_addref(Z_RESVAL_P(zv));
1452 	} else if (Z_TYPE_P(zv) == IS_OBJECT) {
1453 		Z_OBJ_HANDLER_P(zv, add_ref)(zv TSRMLS_CC);
1454 	} else {
1455 		zend_error(E_WARNING, "Leaking non-zval data is only applicable to resources and objects");
1456 	}
1457 }
1458 /* }}} */
1459 
1460 
1461 #ifdef ZEND_TEST_EXCEPTIONS
ZEND_FUNCTION(crash)1462 ZEND_FUNCTION(crash)
1463 {
1464 	char *nowhere=NULL;
1465 
1466 	memcpy(nowhere, "something", sizeof("something"));
1467 }
1468 #endif
1469 
1470 #endif /* ZEND_DEBUG */
1471 
1472 /* {{{ proto array get_included_files(void)
1473    Returns an array with the file names that were include_once()'d */
ZEND_FUNCTION(get_included_files)1474 ZEND_FUNCTION(get_included_files)
1475 {
1476 	char *entry;
1477 
1478 	if (zend_parse_parameters_none() == FAILURE) {
1479 		return;
1480 	}
1481 
1482 	array_init(return_value);
1483 	zend_hash_internal_pointer_reset(&EG(included_files));
1484 	while (zend_hash_get_current_key(&EG(included_files), &entry, NULL, 1) == HASH_KEY_IS_STRING) {
1485 		add_next_index_string(return_value, entry, 0);
1486 		zend_hash_move_forward(&EG(included_files));
1487 	}
1488 }
1489 /* }}} */
1490 
1491 
1492 /* {{{ proto void trigger_error(string message [, int error_type])
1493    Generates a user-level error/warning/notice message */
ZEND_FUNCTION(trigger_error)1494 ZEND_FUNCTION(trigger_error)
1495 {
1496 	long error_type = E_USER_NOTICE;
1497 	char *message;
1498 	int message_len;
1499 
1500 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) {
1501 		return;
1502 	}
1503 
1504 	switch (error_type) {
1505 		case E_USER_ERROR:
1506 		case E_USER_WARNING:
1507 		case E_USER_NOTICE:
1508 		case E_USER_DEPRECATED:
1509 			break;
1510 		default:
1511 			zend_error(E_WARNING, "Invalid error type specified");
1512 			RETURN_FALSE;
1513 			break;
1514 	}
1515 
1516 	zend_error((int)error_type, "%s", message);
1517 	RETURN_TRUE;
1518 }
1519 /* }}} */
1520 
1521 
1522 /* {{{ proto string set_error_handler(string error_handler [, int error_types])
1523    Sets a user-defined error handler function.  Returns the previously defined error handler, or false on error */
ZEND_FUNCTION(set_error_handler)1524 ZEND_FUNCTION(set_error_handler)
1525 {
1526 	zval *error_handler;
1527 	zend_bool had_orig_error_handler=0;
1528 	char *error_handler_name = NULL;
1529 	long error_type = E_ALL;
1530 
1531 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
1532 		return;
1533 	}
1534 
1535 	if (!zend_is_callable(error_handler, 0, &error_handler_name TSRMLS_CC)) {
1536 		zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
1537 				   get_active_function_name(TSRMLS_C), error_handler_name?error_handler_name:"unknown");
1538 		efree(error_handler_name);
1539 		return;
1540 	}
1541 	efree(error_handler_name);
1542 
1543 	if (EG(user_error_handler)) {
1544 		had_orig_error_handler = 1;
1545 		*return_value = *EG(user_error_handler);
1546 		zval_copy_ctor(return_value);
1547 		INIT_PZVAL(return_value);
1548 		zend_stack_push(&EG(user_error_handlers_error_reporting), &EG(user_error_handler_error_reporting), sizeof(EG(user_error_handler_error_reporting)));
1549 		zend_ptr_stack_push(&EG(user_error_handlers), EG(user_error_handler));
1550 	}
1551 	ALLOC_ZVAL(EG(user_error_handler));
1552 
1553 	if (!zend_is_true(error_handler)) { /* unset user-defined handler */
1554 		FREE_ZVAL(EG(user_error_handler));
1555 		EG(user_error_handler) = NULL;
1556 		RETURN_TRUE;
1557 	}
1558 
1559 	EG(user_error_handler_error_reporting) = (int)error_type;
1560 	*EG(user_error_handler) = *error_handler;
1561 	zval_copy_ctor(EG(user_error_handler));
1562 	INIT_PZVAL(EG(user_error_handler));
1563 
1564 	if (!had_orig_error_handler) {
1565 		RETURN_NULL();
1566 	}
1567 }
1568 /* }}} */
1569 
1570 
1571 /* {{{ proto void restore_error_handler(void)
1572    Restores the previously defined error handler function */
ZEND_FUNCTION(restore_error_handler)1573 ZEND_FUNCTION(restore_error_handler)
1574 {
1575 	if (EG(user_error_handler)) {
1576 		zval *zeh = EG(user_error_handler);
1577 
1578 		EG(user_error_handler) = NULL;
1579 		zval_ptr_dtor(&zeh);
1580 	}
1581 
1582 	if (zend_ptr_stack_num_elements(&EG(user_error_handlers))==0) {
1583 		EG(user_error_handler) = NULL;
1584 	} else {
1585 		EG(user_error_handler_error_reporting) = zend_stack_int_top(&EG(user_error_handlers_error_reporting));
1586 		zend_stack_del_top(&EG(user_error_handlers_error_reporting));
1587 		EG(user_error_handler) = zend_ptr_stack_pop(&EG(user_error_handlers));
1588 	}
1589 	RETURN_TRUE;
1590 }
1591 /* }}} */
1592 
1593 
1594 /* {{{ proto string set_exception_handler(callable exception_handler)
1595    Sets a user-defined exception handler function.  Returns the previously defined exception handler, or false on error */
ZEND_FUNCTION(set_exception_handler)1596 ZEND_FUNCTION(set_exception_handler)
1597 {
1598 	zval *exception_handler;
1599 	char *exception_handler_name = NULL;
1600 	zend_bool had_orig_exception_handler=0;
1601 
1602 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception_handler) == FAILURE) {
1603 		return;
1604 	}
1605 
1606 	if (Z_TYPE_P(exception_handler) != IS_NULL) { /* NULL == unset */
1607 		if (!zend_is_callable(exception_handler, 0, &exception_handler_name TSRMLS_CC)) {
1608 			zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
1609 					   get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name:"unknown");
1610 			efree(exception_handler_name);
1611 			return;
1612 		}
1613 		efree(exception_handler_name);
1614 	}
1615 
1616 	if (EG(user_exception_handler)) {
1617 		had_orig_exception_handler = 1;
1618 		*return_value = *EG(user_exception_handler);
1619 		zval_copy_ctor(return_value);
1620 		zend_ptr_stack_push(&EG(user_exception_handlers), EG(user_exception_handler));
1621 	}
1622 	ALLOC_ZVAL(EG(user_exception_handler));
1623 
1624 	if (Z_TYPE_P(exception_handler) == IS_NULL) { /* unset user-defined handler */
1625 		FREE_ZVAL(EG(user_exception_handler));
1626 		EG(user_exception_handler) = NULL;
1627 		RETURN_TRUE;
1628 	}
1629 
1630 	MAKE_COPY_ZVAL(&exception_handler, EG(user_exception_handler))
1631 
1632 	if (!had_orig_exception_handler) {
1633 		RETURN_NULL();
1634 	}
1635 }
1636 /* }}} */
1637 
1638 
1639 /* {{{ proto void restore_exception_handler(void)
1640    Restores the previously defined exception handler function */
ZEND_FUNCTION(restore_exception_handler)1641 ZEND_FUNCTION(restore_exception_handler)
1642 {
1643 	if (EG(user_exception_handler)) {
1644 		zval_ptr_dtor(&EG(user_exception_handler));
1645 	}
1646 	if (zend_ptr_stack_num_elements(&EG(user_exception_handlers))==0) {
1647 		EG(user_exception_handler) = NULL;
1648 	} else {
1649 		EG(user_exception_handler) = zend_ptr_stack_pop(&EG(user_exception_handlers));
1650 	}
1651 	RETURN_TRUE;
1652 }
1653 /* }}} */
1654 
copy_class_or_interface_name(zend_class_entry ** pce TSRMLS_DC,int num_args,va_list args,zend_hash_key * hash_key)1655 static int copy_class_or_interface_name(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
1656 {
1657 	zval *array = va_arg(args, zval *);
1658 	zend_uint mask = va_arg(args, zend_uint);
1659 	zend_uint comply = va_arg(args, zend_uint);
1660 	zend_uint comply_mask = (comply)? mask:0;
1661 	zend_class_entry *ce  = *pce;
1662 
1663 	if ((hash_key->nKeyLength==0 || hash_key->arKey[0]!=0)
1664 		&& (comply_mask == (ce->ce_flags & mask))) {
1665 		if (ce->refcount > 1 &&
1666 		    (ce->name_length != hash_key->nKeyLength - 1 ||
1667 		     !same_name(hash_key->arKey, ce->name, ce->name_length))) {
1668 			add_next_index_stringl(array, hash_key->arKey, hash_key->nKeyLength - 1, 1);
1669 		} else {
1670 			add_next_index_stringl(array, ce->name, ce->name_length, 1);
1671 		}
1672 	}
1673 	return ZEND_HASH_APPLY_KEEP;
1674 }
1675 
1676 /* {{{ proto array get_declared_traits()
1677    Returns an array of all declared traits. */
ZEND_FUNCTION(get_declared_traits)1678 ZEND_FUNCTION(get_declared_traits)
1679 {
1680 	zend_uint mask = ZEND_ACC_TRAIT;
1681 	zend_uint comply = 1;
1682 
1683 	if (zend_parse_parameters_none() == FAILURE) {
1684 		return;
1685 	}
1686 
1687 	array_init(return_value);
1688 	zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1689 }
1690 /* }}} */
1691 
1692 
1693 /* {{{ proto array get_declared_classes()
1694    Returns an array of all declared classes. */
ZEND_FUNCTION(get_declared_classes)1695 ZEND_FUNCTION(get_declared_classes)
1696 {
1697 	zend_uint mask = ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT & ~ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
1698 	zend_uint comply = 0;
1699 
1700 	if (zend_parse_parameters_none() == FAILURE) {
1701 		return;
1702 	}
1703 
1704 	array_init(return_value);
1705 	zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1706 }
1707 /* }}} */
1708 
1709 /* {{{ proto array get_declared_interfaces()
1710    Returns an array of all declared interfaces. */
ZEND_FUNCTION(get_declared_interfaces)1711 ZEND_FUNCTION(get_declared_interfaces)
1712 {
1713 	zend_uint mask = ZEND_ACC_INTERFACE;
1714 	zend_uint comply = 1;
1715 
1716 	if (zend_parse_parameters_none() == FAILURE) {
1717 		return;
1718 	}
1719 
1720 	array_init(return_value);
1721 	zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1722 }
1723 /* }}} */
1724 
1725 
copy_function_name(zend_function * func TSRMLS_DC,int num_args,va_list args,zend_hash_key * hash_key)1726 static int copy_function_name(zend_function *func TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
1727 {
1728 	zval *internal_ar = va_arg(args, zval *),
1729 	     *user_ar     = va_arg(args, zval *);
1730 
1731 	if (hash_key->nKeyLength == 0 || hash_key->arKey[0] == 0) {
1732 		return 0;
1733 	}
1734 
1735 	if (func->type == ZEND_INTERNAL_FUNCTION) {
1736 		add_next_index_stringl(internal_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
1737 	} else if (func->type == ZEND_USER_FUNCTION) {
1738 		add_next_index_stringl(user_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
1739 	}
1740 
1741 	return 0;
1742 }
1743 
1744 
1745 /* {{{ proto array get_defined_functions(void)
1746    Returns an array of all defined functions */
ZEND_FUNCTION(get_defined_functions)1747 ZEND_FUNCTION(get_defined_functions)
1748 {
1749 	zval *internal;
1750 	zval *user;
1751 
1752 	if (zend_parse_parameters_none() == FAILURE) {
1753 		return;
1754 	}
1755 
1756 	MAKE_STD_ZVAL(internal);
1757 	MAKE_STD_ZVAL(user);
1758 
1759 	array_init(internal);
1760 	array_init(user);
1761 	array_init(return_value);
1762 
1763 	zend_hash_apply_with_arguments(EG(function_table) TSRMLS_CC, (apply_func_args_t) copy_function_name, 2, internal, user);
1764 
1765 	if (zend_hash_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) {
1766 		zval_ptr_dtor(&internal);
1767 		zval_ptr_dtor(&user);
1768 		zval_dtor(return_value);
1769 		zend_error(E_WARNING, "Cannot add internal functions to return value from get_defined_functions()");
1770 		RETURN_FALSE;
1771 	}
1772 
1773 	if (zend_hash_add(Z_ARRVAL_P(return_value), "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) {
1774 		zval_ptr_dtor(&user);
1775 		zval_dtor(return_value);
1776 		zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()");
1777 		RETURN_FALSE;
1778 	}
1779 }
1780 /* }}} */
1781 
1782 
1783 /* {{{ proto array get_defined_vars(void)
1784    Returns an associative array of names and values of all currently defined variable names (variables in the current scope) */
ZEND_FUNCTION(get_defined_vars)1785 ZEND_FUNCTION(get_defined_vars)
1786 {
1787 	if (!EG(active_symbol_table)) {
1788 		zend_rebuild_symbol_table(TSRMLS_C);
1789 	}
1790 
1791 	array_init_size(return_value, zend_hash_num_elements(EG(active_symbol_table)));
1792 
1793 	zend_hash_copy(Z_ARRVAL_P(return_value), EG(active_symbol_table),
1794 					(copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval *));
1795 }
1796 /* }}} */
1797 
1798 
1799 #define LAMBDA_TEMP_FUNCNAME	"__lambda_func"
1800 /* {{{ proto string create_function(string args, string code)
1801    Creates an anonymous function, and returns its name (funny, eh?) */
ZEND_FUNCTION(create_function)1802 ZEND_FUNCTION(create_function)
1803 {
1804 	char *eval_code, *function_name, *function_args, *function_code;
1805 	int eval_code_length, function_name_length, function_args_len, function_code_len;
1806 	int retval;
1807 	char *eval_name;
1808 
1809 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &function_args, &function_args_len, &function_code, &function_code_len) == FAILURE) {
1810 		return;
1811 	}
1812 
1813 	eval_code = (char *) emalloc(sizeof("function " LAMBDA_TEMP_FUNCNAME)
1814 			+function_args_len
1815 			+2	/* for the args parentheses */
1816 			+2	/* for the curly braces */
1817 			+function_code_len);
1818 
1819 	eval_code_length = sizeof("function " LAMBDA_TEMP_FUNCNAME "(") - 1;
1820 	memcpy(eval_code, "function " LAMBDA_TEMP_FUNCNAME "(", eval_code_length);
1821 
1822 	memcpy(eval_code + eval_code_length, function_args, function_args_len);
1823 	eval_code_length += function_args_len;
1824 
1825 	eval_code[eval_code_length++] = ')';
1826 	eval_code[eval_code_length++] = '{';
1827 
1828 	memcpy(eval_code + eval_code_length, function_code, function_code_len);
1829 	eval_code_length += function_code_len;
1830 
1831 	eval_code[eval_code_length++] = '}';
1832 	eval_code[eval_code_length] = '\0';
1833 
1834 	eval_name = zend_make_compiled_string_description("runtime-created function" TSRMLS_CC);
1835 	retval = zend_eval_stringl(eval_code, eval_code_length, NULL, eval_name TSRMLS_CC);
1836 	efree(eval_code);
1837 	efree(eval_name);
1838 
1839 	if (retval==SUCCESS) {
1840 		zend_function new_function, *func;
1841 
1842 		if (zend_hash_find(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME), (void **) &func)==FAILURE) {
1843 			zend_error(E_ERROR, "Unexpected inconsistency in create_function()");
1844 			RETURN_FALSE;
1845 		}
1846 		new_function = *func;
1847 		function_add_ref(&new_function);
1848 
1849 		function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
1850 		function_name[0] = '\0';
1851 
1852 		do {
1853 			function_name_length = 1 + snprintf(function_name + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count));
1854 		} while (zend_hash_add(EG(function_table), function_name, function_name_length+1, &new_function, sizeof(zend_function), NULL)==FAILURE);
1855 		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
1856 		RETURN_STRINGL(function_name, function_name_length, 0);
1857 	} else {
1858 		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
1859 		RETURN_FALSE;
1860 	}
1861 }
1862 /* }}} */
1863 
1864 
1865 #if ZEND_DEBUG
ZEND_FUNCTION(zend_test_func)1866 ZEND_FUNCTION(zend_test_func)
1867 {
1868 	zval *arg1, *arg2;
1869 
1870 	zend_get_parameters(ht, 2, &arg1, &arg2);
1871 }
1872 
1873 
1874 #ifdef ZTS
ZEND_FUNCTION(zend_thread_id)1875 ZEND_FUNCTION(zend_thread_id)
1876 {
1877 	RETURN_LONG((long)tsrm_thread_id());
1878 }
1879 #endif
1880 #endif
1881 
1882 /* {{{ proto string get_resource_type(resource res)
1883    Get the resource type name for a given resource */
ZEND_FUNCTION(get_resource_type)1884 ZEND_FUNCTION(get_resource_type)
1885 {
1886 	const char *resource_type;
1887 	zval *z_resource_type;
1888 
1889 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_resource_type) == FAILURE) {
1890 		return;
1891 	}
1892 
1893 	resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_P(z_resource_type) TSRMLS_CC);
1894 	if (resource_type) {
1895 		RETURN_STRING(resource_type, 1);
1896 	} else {
1897 		RETURN_STRING("Unknown", 1);
1898 	}
1899 }
1900 /* }}} */
1901 
1902 
add_extension_info(zend_module_entry * module,void * arg TSRMLS_DC)1903 static int add_extension_info(zend_module_entry *module, void *arg TSRMLS_DC)
1904 {
1905 	zval *name_array = (zval *)arg;
1906 	add_next_index_string(name_array, module->name, 1);
1907 	return 0;
1908 }
1909 
add_zendext_info(zend_extension * ext,void * arg TSRMLS_DC)1910 static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC)
1911 {
1912 	zval *name_array = (zval *)arg;
1913 	add_next_index_string(name_array, ext->name, 1);
1914 	return 0;
1915 }
1916 
add_constant_info(zend_constant * constant,void * arg TSRMLS_DC)1917 static int add_constant_info(zend_constant *constant, void *arg TSRMLS_DC)
1918 {
1919 	zval *name_array = (zval *)arg;
1920 	zval *const_val;
1921 
1922 	if (!constant->name) {
1923 		/* skip special constants */
1924 		return 0;
1925 	}
1926 
1927 	MAKE_STD_ZVAL(const_val);
1928 	*const_val = constant->value;
1929 	zval_copy_ctor(const_val);
1930 	INIT_PZVAL(const_val);
1931 	add_assoc_zval_ex(name_array, constant->name, constant->name_len, const_val);
1932 	return 0;
1933 }
1934 
1935 
1936 /* {{{ proto array get_loaded_extensions([bool zend_extensions]) U
1937    Return an array containing names of loaded extensions */
ZEND_FUNCTION(get_loaded_extensions)1938 ZEND_FUNCTION(get_loaded_extensions)
1939 {
1940 	zend_bool zendext = 0;
1941 
1942 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &zendext) == FAILURE) {
1943 		return;
1944 	}
1945 
1946 	array_init(return_value);
1947 
1948 	if (zendext) {
1949 		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) add_zendext_info, return_value TSRMLS_CC);
1950 	} else {
1951 		zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) add_extension_info, return_value TSRMLS_CC);
1952 	}
1953 }
1954 /* }}} */
1955 
1956 
1957 /* {{{ proto array get_defined_constants([bool categorize])
1958    Return an array containing the names and values of all defined constants */
ZEND_FUNCTION(get_defined_constants)1959 ZEND_FUNCTION(get_defined_constants)
1960 {
1961 	zend_bool categorize = 0;
1962 
1963 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &categorize) == FAILURE) {
1964 		return;
1965 	}
1966 
1967 	array_init(return_value);
1968 
1969 	if (categorize) {
1970 		HashPosition pos;
1971 		zend_constant *val;
1972 		int module_number;
1973 		zval **modules;
1974 		char **module_names;
1975 		zend_module_entry *module;
1976 		int i = 1;
1977 
1978 		modules = ecalloc(zend_hash_num_elements(&module_registry) + 2, sizeof(zval *));
1979 		module_names = emalloc((zend_hash_num_elements(&module_registry) + 2) * sizeof(char *));
1980 
1981 		module_names[0] = "internal";
1982 		zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
1983 		while (zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) != FAILURE) {
1984 			module_names[module->module_number] = (char *)module->name;
1985 			i++;
1986 			zend_hash_move_forward_ex(&module_registry, &pos);
1987 		}
1988 		module_names[i] = "user";
1989 
1990 		zend_hash_internal_pointer_reset_ex(EG(zend_constants), &pos);
1991 		while (zend_hash_get_current_data_ex(EG(zend_constants), (void **) &val, &pos) != FAILURE) {
1992 			zval *const_val;
1993 
1994 			if (!val->name) {
1995 				/* skip special constants */
1996 				goto next_constant;
1997 			}
1998 
1999 			if (val->module_number == PHP_USER_CONSTANT) {
2000 				module_number = i;
2001 			} else if (val->module_number > i || val->module_number < 0) {
2002 				/* should not happen */
2003 				goto next_constant;
2004 			} else {
2005 				module_number = val->module_number;
2006 			}
2007 
2008 			if (!modules[module_number]) {
2009 				MAKE_STD_ZVAL(modules[module_number]);
2010 				array_init(modules[module_number]);
2011 				add_assoc_zval(return_value, module_names[module_number], modules[module_number]);
2012 			}
2013 
2014 			MAKE_STD_ZVAL(const_val);
2015 			*const_val = val->value;
2016 			zval_copy_ctor(const_val);
2017 			INIT_PZVAL(const_val);
2018 
2019 			add_assoc_zval_ex(modules[module_number], val->name, val->name_len, const_val);
2020 next_constant:
2021 			zend_hash_move_forward_ex(EG(zend_constants), &pos);
2022 		}
2023 		efree(module_names);
2024 		efree(modules);
2025 	} else {
2026 		zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) add_constant_info, return_value TSRMLS_CC);
2027 	}
2028 }
2029 /* }}} */
2030 
2031 
debug_backtrace_get_args(void ** curpos TSRMLS_DC)2032 static zval *debug_backtrace_get_args(void **curpos TSRMLS_DC)
2033 {
2034 	void **p = curpos;
2035 	zval *arg_array, **arg;
2036 	int arg_count = (int)(zend_uintptr_t) *p;
2037 
2038 	MAKE_STD_ZVAL(arg_array);
2039 	array_init_size(arg_array, arg_count);
2040 	p -= arg_count;
2041 
2042 	while (--arg_count >= 0) {
2043 		arg = (zval **) p++;
2044 		if (*arg) {
2045 			if (Z_TYPE_PP(arg) != IS_OBJECT) {
2046 				SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
2047 			}
2048 			Z_ADDREF_PP(arg);
2049 			add_next_index_zval(arg_array, *arg);
2050 		} else {
2051 			add_next_index_null(arg_array);
2052 		}
2053 	}
2054 
2055 	return arg_array;
2056 }
2057 
debug_print_backtrace_args(zval * arg_array TSRMLS_DC)2058 void debug_print_backtrace_args(zval *arg_array TSRMLS_DC)
2059 {
2060 	zval **tmp;
2061 	HashPosition iterator;
2062 	int i = 0;
2063 
2064 	zend_hash_internal_pointer_reset_ex(arg_array->value.ht, &iterator);
2065 	while (zend_hash_get_current_data_ex(arg_array->value.ht, (void **) &tmp, &iterator) == SUCCESS) {
2066 		if (i++) {
2067 			ZEND_PUTS(", ");
2068 		}
2069 		zend_print_flat_zval_r(*tmp TSRMLS_CC);
2070 		zend_hash_move_forward_ex(arg_array->value.ht, &iterator);
2071 	}
2072 }
2073 
2074 /* {{{ proto void debug_print_backtrace([int options[, int limit]]) */
ZEND_FUNCTION(debug_print_backtrace)2075 ZEND_FUNCTION(debug_print_backtrace)
2076 {
2077 	zend_execute_data *ptr, *skip;
2078 	int lineno, frameno = 0;
2079 	const char *function_name;
2080 	const char *filename;
2081 	const char *class_name = NULL;
2082 	char *call_type;
2083 	const char *include_filename = NULL;
2084 	zval *arg_array = NULL;
2085 	int indent = 0;
2086 	long options = 0;
2087 	long limit = 0;
2088 
2089 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
2090 		return;
2091 	}
2092 
2093 	ptr = EG(current_execute_data);
2094 
2095 	/* skip debug_backtrace() */
2096 	ptr = ptr->prev_execute_data;
2097 
2098 	while (ptr && (limit == 0 || frameno < limit)) {
2099 		const char *free_class_name = NULL;
2100 
2101 		frameno++;
2102 		class_name = call_type = NULL;
2103 		arg_array = NULL;
2104 
2105 		skip = ptr;
2106 		/* skip internal handler */
2107 		if (!skip->op_array &&
2108 		    skip->prev_execute_data &&
2109 		    skip->prev_execute_data->opline &&
2110 		    skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL &&
2111 		    skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL_BY_NAME &&
2112 		    skip->prev_execute_data->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2113 			skip = skip->prev_execute_data;
2114 		}
2115 
2116 		if (skip->op_array) {
2117 			filename = skip->op_array->filename;
2118 			lineno = skip->opline->lineno;
2119 		} else {
2120 			filename = NULL;
2121 			lineno = 0;
2122 		}
2123 
2124 		function_name = (ptr->function_state.function->common.scope &&
2125 			ptr->function_state.function->common.scope->trait_aliases) ?
2126 				zend_resolve_method_name(
2127 					ptr->object ?
2128 						Z_OBJCE_P(ptr->object) :
2129 						ptr->function_state.function->common.scope,
2130 					ptr->function_state.function) :
2131 				ptr->function_state.function->common.function_name;
2132 
2133 		if (function_name) {
2134 			if (ptr->object) {
2135 				if (ptr->function_state.function->common.scope) {
2136 					class_name = ptr->function_state.function->common.scope->name;
2137 				} else {
2138 					zend_uint class_name_len;
2139 					int dup;
2140 
2141 					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
2142 					if(!dup) {
2143 						free_class_name = class_name;
2144 					}
2145 				}
2146 
2147 				call_type = "->";
2148 			} else if (ptr->function_state.function->common.scope) {
2149 				class_name = ptr->function_state.function->common.scope->name;
2150 				call_type = "::";
2151 			} else {
2152 				class_name = NULL;
2153 				call_type = NULL;
2154 			}
2155 			if ((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL))) {
2156 				if (ptr->function_state.arguments && (options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0) {
2157 					arg_array = debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC);
2158 				}
2159 			}
2160 		} else {
2161 			/* i know this is kinda ugly, but i'm trying to avoid extra cycles in the main execution loop */
2162 			zend_bool build_filename_arg = 1;
2163 
2164 			if (!ptr->opline || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2165 				/* can happen when calling eval from a custom sapi */
2166 				function_name = "unknown";
2167 				build_filename_arg = 0;
2168 			} else
2169 			switch (ptr->opline->extended_value) {
2170 				case ZEND_EVAL:
2171 					function_name = "eval";
2172 					build_filename_arg = 0;
2173 					break;
2174 				case ZEND_INCLUDE:
2175 					function_name = "include";
2176 					break;
2177 				case ZEND_REQUIRE:
2178 					function_name = "require";
2179 					break;
2180 				case ZEND_INCLUDE_ONCE:
2181 					function_name = "include_once";
2182 					break;
2183 				case ZEND_REQUIRE_ONCE:
2184 					function_name = "require_once";
2185 					break;
2186 				default:
2187 					/* this can actually happen if you use debug_backtrace() in your error_handler and
2188 					 * you're in the top-scope */
2189 					function_name = "unknown";
2190 					build_filename_arg = 0;
2191 					break;
2192 			}
2193 
2194 			if (build_filename_arg && include_filename) {
2195 				MAKE_STD_ZVAL(arg_array);
2196 				array_init(arg_array);
2197 				add_next_index_string(arg_array, (char*)include_filename, 1);
2198 			}
2199 			call_type = NULL;
2200 		}
2201 		zend_printf("#%-2d ", indent);
2202 		if (class_name) {
2203 			ZEND_PUTS(class_name);
2204 			ZEND_PUTS(call_type);
2205 		}
2206 		zend_printf("%s(", function_name);
2207 		if (arg_array) {
2208 			debug_print_backtrace_args(arg_array TSRMLS_CC);
2209 			zval_ptr_dtor(&arg_array);
2210 		}
2211 		if (filename) {
2212 			zend_printf(") called at [%s:%d]\n", filename, lineno);
2213 		} else {
2214 			zend_execute_data *prev = skip->prev_execute_data;
2215 
2216 			while (prev) {
2217 				if (prev->function_state.function &&
2218 					prev->function_state.function->common.type != ZEND_USER_FUNCTION) {
2219 					prev = NULL;
2220 					break;
2221 				}
2222 				if (prev->op_array) {
2223 					zend_printf(") called at [%s:%d]\n", prev->op_array->filename, prev->opline->lineno);
2224 					break;
2225 				}
2226 				prev = prev->prev_execute_data;
2227 			}
2228 			if (!prev) {
2229 				ZEND_PUTS(")\n");
2230 			}
2231 		}
2232 		include_filename = filename;
2233 		ptr = skip->prev_execute_data;
2234 		++indent;
2235 		if (free_class_name) {
2236 			efree((char*)free_class_name);
2237 		}
2238 	}
2239 }
2240 
2241 /* }}} */
2242 
zend_fetch_debug_backtrace(zval * return_value,int skip_last,int options,int limit TSRMLS_DC)2243 ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC)
2244 {
2245 	zend_execute_data *ptr, *skip;
2246 	int lineno, frameno = 0;
2247 	const char *function_name;
2248 	const char *filename;
2249 	const char *class_name;
2250 	const char *include_filename = NULL;
2251 	zval *stack_frame;
2252 
2253 	ptr = EG(current_execute_data);
2254 
2255 	/* skip "new Exception()" */
2256 	if (ptr && (skip_last == 0) && ptr->opline && (ptr->opline->opcode == ZEND_NEW)) {
2257 		ptr = ptr->prev_execute_data;
2258 	}
2259 
2260 	/* skip debug_backtrace() */
2261 	if (skip_last-- && ptr) {
2262 		ptr = ptr->prev_execute_data;
2263 	}
2264 
2265 	array_init(return_value);
2266 
2267 	while (ptr && (limit == 0 || frameno < limit)) {
2268 		frameno++;
2269 		MAKE_STD_ZVAL(stack_frame);
2270 		array_init(stack_frame);
2271 
2272 		skip = ptr;
2273 		/* skip internal handler */
2274 		if (!skip->op_array &&
2275 		    skip->prev_execute_data &&
2276 		    skip->prev_execute_data->opline &&
2277 		    skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL &&
2278 		    skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL_BY_NAME &&
2279 		    skip->prev_execute_data->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2280 			skip = skip->prev_execute_data;
2281 		}
2282 
2283 		if (skip->op_array) {
2284 			filename = skip->op_array->filename;
2285 			lineno = skip->opline->lineno;
2286 			add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)filename, 1);
2287 			add_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno);
2288 
2289 			/* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
2290 			 * and debug_baktrace() might have been called by the error_handler. in this case we don't
2291 			 * want to pop anything of the argument-stack */
2292 		} else {
2293 			zend_execute_data *prev = skip->prev_execute_data;
2294 
2295 			while (prev) {
2296 				if (prev->function_state.function &&
2297 					prev->function_state.function->common.type != ZEND_USER_FUNCTION &&
2298 					!(prev->function_state.function->common.type == ZEND_INTERNAL_FUNCTION &&
2299 						(prev->function_state.function->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER))) {
2300 					break;
2301 				}
2302 				if (prev->op_array) {
2303 					add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)prev->op_array->filename, 1);
2304 					add_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno);
2305 					break;
2306 				}
2307 				prev = prev->prev_execute_data;
2308 			}
2309 			filename = NULL;
2310 		}
2311 
2312 		function_name = (ptr->function_state.function->common.scope &&
2313 			ptr->function_state.function->common.scope->trait_aliases) ?
2314 				zend_resolve_method_name(
2315 					ptr->object ?
2316 						Z_OBJCE_P(ptr->object) :
2317 						ptr->function_state.function->common.scope,
2318 					ptr->function_state.function) :
2319 				ptr->function_state.function->common.function_name;
2320 
2321 		if (function_name) {
2322 			add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
2323 
2324 			if (ptr->object && Z_TYPE_P(ptr->object) == IS_OBJECT) {
2325 				if (ptr->function_state.function->common.scope) {
2326 					add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
2327 				} else {
2328 					zend_uint class_name_len;
2329 					int dup;
2330 
2331 					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
2332 					add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)class_name, dup);
2333 
2334 				}
2335 				if ((options & DEBUG_BACKTRACE_PROVIDE_OBJECT) != 0) {
2336 					add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object);
2337 					Z_ADDREF_P(ptr->object);
2338 				}
2339 
2340 				add_assoc_string_ex(stack_frame, "type", sizeof("type"), "->", 1);
2341 			} else if (ptr->function_state.function->common.scope) {
2342 				add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
2343 				add_assoc_string_ex(stack_frame, "type", sizeof("type"), "::", 1);
2344 			}
2345 
2346 			if ((options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0 &&
2347 				((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL)))) {
2348 				if (ptr->function_state.arguments) {
2349 					add_assoc_zval_ex(stack_frame, "args", sizeof("args"), debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC));
2350 				}
2351 			}
2352 		} else {
2353 			/* i know this is kinda ugly, but i'm trying to avoid extra cycles in the main execution loop */
2354 			zend_bool build_filename_arg = 1;
2355 
2356 			if (!ptr->opline || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2357 				/* can happen when calling eval from a custom sapi */
2358 				function_name = "unknown";
2359 				build_filename_arg = 0;
2360 			} else
2361 			switch (ptr->opline->extended_value) {
2362 				case ZEND_EVAL:
2363 					function_name = "eval";
2364 					build_filename_arg = 0;
2365 					break;
2366 				case ZEND_INCLUDE:
2367 					function_name = "include";
2368 					break;
2369 				case ZEND_REQUIRE:
2370 					function_name = "require";
2371 					break;
2372 				case ZEND_INCLUDE_ONCE:
2373 					function_name = "include_once";
2374 					break;
2375 				case ZEND_REQUIRE_ONCE:
2376 					function_name = "require_once";
2377 					break;
2378 				default:
2379 					/* this can actually happen if you use debug_backtrace() in your error_handler and
2380 					 * you're in the top-scope */
2381 					function_name = "unknown";
2382 					build_filename_arg = 0;
2383 					break;
2384 			}
2385 
2386 			if (build_filename_arg && include_filename) {
2387 				zval *arg_array;
2388 
2389 				MAKE_STD_ZVAL(arg_array);
2390 				array_init(arg_array);
2391 
2392 				/* include_filename always points to the last filename of the last last called-function.
2393 				   if we have called include in the frame above - this is the file we have included.
2394 				 */
2395 
2396 				add_next_index_string(arg_array, (char*)include_filename, 1);
2397 				add_assoc_zval_ex(stack_frame, "args", sizeof("args"), arg_array);
2398 			}
2399 
2400 			add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
2401 		}
2402 
2403 		add_next_index_zval(return_value, stack_frame);
2404 
2405 		include_filename = filename;
2406 
2407 		ptr = skip->prev_execute_data;
2408 	}
2409 }
2410 /* }}} */
2411 
2412 
2413 /* {{{ proto array debug_backtrace([int options[, int limit]])
2414    Return backtrace as array */
ZEND_FUNCTION(debug_backtrace)2415 ZEND_FUNCTION(debug_backtrace)
2416 {
2417 	long options = DEBUG_BACKTRACE_PROVIDE_OBJECT;
2418 	long limit = 0;
2419 
2420 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
2421 		return;
2422 	}
2423 
2424 	zend_fetch_debug_backtrace(return_value, 1, options, limit TSRMLS_CC);
2425 }
2426 /* }}} */
2427 
2428 /* {{{ proto bool extension_loaded(string extension_name)
2429    Returns true if the named extension is loaded */
ZEND_FUNCTION(extension_loaded)2430 ZEND_FUNCTION(extension_loaded)
2431 {
2432 	char *extension_name;
2433 	int extension_name_len;
2434 	char *lcname;
2435 
2436 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
2437 		return;
2438 	}
2439 
2440 	lcname = zend_str_tolower_dup(extension_name, extension_name_len);
2441 	if (zend_hash_exists(&module_registry, lcname, extension_name_len+1)) {
2442 		RETVAL_TRUE;
2443 	} else {
2444 		RETVAL_FALSE;
2445 	}
2446 	efree(lcname);
2447 }
2448 /* }}} */
2449 
2450 
2451 /* {{{ proto array get_extension_funcs(string extension_name)
2452    Returns an array with the names of functions belonging to the named extension */
ZEND_FUNCTION(get_extension_funcs)2453 ZEND_FUNCTION(get_extension_funcs)
2454 {
2455 	char *extension_name, *lcname;
2456 	int extension_name_len, array;
2457 	zend_module_entry *module;
2458 	HashPosition iterator;
2459 	zend_function *zif;
2460 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
2461 		return;
2462 	}
2463 	if (strncasecmp(extension_name, "zend", sizeof("zend"))) {
2464 		lcname = zend_str_tolower_dup(extension_name, extension_name_len);
2465 	} else {
2466 		lcname = estrdup("core");
2467 	}
2468 	if (zend_hash_find(&module_registry, lcname,
2469 		extension_name_len+1, (void**)&module) == FAILURE) {
2470 		efree(lcname);
2471 		RETURN_FALSE;
2472 	}
2473 
2474 	zend_hash_internal_pointer_reset_ex(CG(function_table), &iterator);
2475 	if (module->functions) {
2476 		/* avoid BC break, if functions list is empty, will return an empty array */
2477 		array_init(return_value);
2478 		array = 1;
2479 	} else {
2480 		array = 0;
2481 	}
2482 	while (zend_hash_get_current_data_ex(CG(function_table), (void **) &zif, &iterator) == SUCCESS) {
2483 		if (zif->common.type==ZEND_INTERNAL_FUNCTION
2484 			&& zif->internal_function.module == module) {
2485 			if (!array) {
2486 				array_init(return_value);
2487 				array = 1;
2488 			}
2489 			add_next_index_string(return_value, zif->common.function_name, 1);
2490 		}
2491 		zend_hash_move_forward_ex(CG(function_table), &iterator);
2492 	}
2493 
2494 	efree(lcname);
2495 
2496 	if (!array) {
2497 		RETURN_FALSE;
2498 	}
2499 }
2500 /* }}} */
2501 
2502 /*
2503  * Local variables:
2504  * tab-width: 4
2505  * c-basic-offset: 4
2506  * indent-tabs-mode: t
2507  * End:
2508  */
2509