1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2015 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, prop_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_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
1018 /* Not separating references */
1019 Z_ADDREF_PP(value);
1020 add_assoc_zval_ex(return_value, prop_name, prop_len + 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 char *error_handler_name = NULL;
1528 long error_type = E_ALL;
1529
1530 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
1531 return;
1532 }
1533
1534 if (Z_TYPE_P(error_handler) != IS_NULL) { /* NULL == unset */
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
1544 if (EG(user_error_handler)) {
1545 RETVAL_ZVAL(EG(user_error_handler), 1, 0);
1546
1547 zend_stack_push(&EG(user_error_handlers_error_reporting), &EG(user_error_handler_error_reporting), sizeof(EG(user_error_handler_error_reporting)));
1548 zend_ptr_stack_push(&EG(user_error_handlers), EG(user_error_handler));
1549 }
1550
1551 if (Z_TYPE_P(error_handler) == IS_NULL) { /* unset user-defined handler */
1552 EG(user_error_handler) = NULL;
1553 return;
1554 }
1555
1556 ALLOC_ZVAL(EG(user_error_handler));
1557 MAKE_COPY_ZVAL(&error_handler, EG(user_error_handler));
1558 EG(user_error_handler_error_reporting) = (int)error_type;
1559 }
1560 /* }}} */
1561
1562
1563 /* {{{ proto void restore_error_handler(void)
1564 Restores the previously defined error handler function */
ZEND_FUNCTION(restore_error_handler)1565 ZEND_FUNCTION(restore_error_handler)
1566 {
1567 if (EG(user_error_handler)) {
1568 zval *zeh = EG(user_error_handler);
1569
1570 EG(user_error_handler) = NULL;
1571 zval_ptr_dtor(&zeh);
1572 }
1573
1574 if (zend_ptr_stack_num_elements(&EG(user_error_handlers))==0) {
1575 EG(user_error_handler) = NULL;
1576 } else {
1577 EG(user_error_handler_error_reporting) = zend_stack_int_top(&EG(user_error_handlers_error_reporting));
1578 zend_stack_del_top(&EG(user_error_handlers_error_reporting));
1579 EG(user_error_handler) = zend_ptr_stack_pop(&EG(user_error_handlers));
1580 }
1581 RETURN_TRUE;
1582 }
1583 /* }}} */
1584
1585
1586 /* {{{ proto string set_exception_handler(callable exception_handler)
1587 Sets a user-defined exception handler function. Returns the previously defined exception handler, or false on error */
ZEND_FUNCTION(set_exception_handler)1588 ZEND_FUNCTION(set_exception_handler)
1589 {
1590 zval *exception_handler;
1591 char *exception_handler_name = NULL;
1592
1593 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception_handler) == FAILURE) {
1594 return;
1595 }
1596
1597 if (Z_TYPE_P(exception_handler) != IS_NULL) { /* NULL == unset */
1598 if (!zend_is_callable(exception_handler, 0, &exception_handler_name TSRMLS_CC)) {
1599 zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
1600 get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name:"unknown");
1601 efree(exception_handler_name);
1602 return;
1603 }
1604 efree(exception_handler_name);
1605 }
1606
1607 if (EG(user_exception_handler)) {
1608 RETVAL_ZVAL(EG(user_exception_handler), 1, 0);
1609
1610 zend_ptr_stack_push(&EG(user_exception_handlers), EG(user_exception_handler));
1611 }
1612
1613 if (Z_TYPE_P(exception_handler) == IS_NULL) { /* unset user-defined handler */
1614 EG(user_exception_handler) = NULL;
1615 return;
1616 }
1617
1618 ALLOC_ZVAL(EG(user_exception_handler));
1619 MAKE_COPY_ZVAL(&exception_handler, EG(user_exception_handler))
1620 }
1621 /* }}} */
1622
1623
1624 /* {{{ proto void restore_exception_handler(void)
1625 Restores the previously defined exception handler function */
ZEND_FUNCTION(restore_exception_handler)1626 ZEND_FUNCTION(restore_exception_handler)
1627 {
1628 if (EG(user_exception_handler)) {
1629 zval_ptr_dtor(&EG(user_exception_handler));
1630 }
1631 if (zend_ptr_stack_num_elements(&EG(user_exception_handlers))==0) {
1632 EG(user_exception_handler) = NULL;
1633 } else {
1634 EG(user_exception_handler) = zend_ptr_stack_pop(&EG(user_exception_handlers));
1635 }
1636 RETURN_TRUE;
1637 }
1638 /* }}} */
1639
copy_class_or_interface_name(zend_class_entry ** pce TSRMLS_DC,int num_args,va_list args,zend_hash_key * hash_key)1640 static int copy_class_or_interface_name(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
1641 {
1642 zval *array = va_arg(args, zval *);
1643 zend_uint mask = va_arg(args, zend_uint);
1644 zend_uint comply = va_arg(args, zend_uint);
1645 zend_uint comply_mask = (comply)? mask:0;
1646 zend_class_entry *ce = *pce;
1647
1648 if ((hash_key->nKeyLength==0 || hash_key->arKey[0]!=0)
1649 && (comply_mask == (ce->ce_flags & mask))) {
1650 if (ce->refcount > 1 &&
1651 (ce->name_length != hash_key->nKeyLength - 1 ||
1652 !same_name(hash_key->arKey, ce->name, ce->name_length))) {
1653 add_next_index_stringl(array, hash_key->arKey, hash_key->nKeyLength - 1, 1);
1654 } else {
1655 add_next_index_stringl(array, ce->name, ce->name_length, 1);
1656 }
1657 }
1658 return ZEND_HASH_APPLY_KEEP;
1659 }
1660
1661 /* {{{ proto array get_declared_traits()
1662 Returns an array of all declared traits. */
ZEND_FUNCTION(get_declared_traits)1663 ZEND_FUNCTION(get_declared_traits)
1664 {
1665 zend_uint mask = ZEND_ACC_TRAIT;
1666 zend_uint comply = 1;
1667
1668 if (zend_parse_parameters_none() == FAILURE) {
1669 return;
1670 }
1671
1672 array_init(return_value);
1673 zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1674 }
1675 /* }}} */
1676
1677
1678 /* {{{ proto array get_declared_classes()
1679 Returns an array of all declared classes. */
ZEND_FUNCTION(get_declared_classes)1680 ZEND_FUNCTION(get_declared_classes)
1681 {
1682 zend_uint mask = ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT & ~ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
1683 zend_uint comply = 0;
1684
1685 if (zend_parse_parameters_none() == FAILURE) {
1686 return;
1687 }
1688
1689 array_init(return_value);
1690 zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1691 }
1692 /* }}} */
1693
1694 /* {{{ proto array get_declared_interfaces()
1695 Returns an array of all declared interfaces. */
ZEND_FUNCTION(get_declared_interfaces)1696 ZEND_FUNCTION(get_declared_interfaces)
1697 {
1698 zend_uint mask = ZEND_ACC_INTERFACE;
1699 zend_uint comply = 1;
1700
1701 if (zend_parse_parameters_none() == FAILURE) {
1702 return;
1703 }
1704
1705 array_init(return_value);
1706 zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) copy_class_or_interface_name, 3, return_value, mask, comply);
1707 }
1708 /* }}} */
1709
1710
copy_function_name(zend_function * func TSRMLS_DC,int num_args,va_list args,zend_hash_key * hash_key)1711 static int copy_function_name(zend_function *func TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
1712 {
1713 zval *internal_ar = va_arg(args, zval *),
1714 *user_ar = va_arg(args, zval *);
1715
1716 if (hash_key->nKeyLength == 0 || hash_key->arKey[0] == 0) {
1717 return 0;
1718 }
1719
1720 if (func->type == ZEND_INTERNAL_FUNCTION) {
1721 add_next_index_stringl(internal_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
1722 } else if (func->type == ZEND_USER_FUNCTION) {
1723 add_next_index_stringl(user_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
1724 }
1725
1726 return 0;
1727 }
1728
1729
1730 /* {{{ proto array get_defined_functions(void)
1731 Returns an array of all defined functions */
ZEND_FUNCTION(get_defined_functions)1732 ZEND_FUNCTION(get_defined_functions)
1733 {
1734 zval *internal;
1735 zval *user;
1736
1737 if (zend_parse_parameters_none() == FAILURE) {
1738 return;
1739 }
1740
1741 MAKE_STD_ZVAL(internal);
1742 MAKE_STD_ZVAL(user);
1743
1744 array_init(internal);
1745 array_init(user);
1746 array_init(return_value);
1747
1748 zend_hash_apply_with_arguments(EG(function_table) TSRMLS_CC, (apply_func_args_t) copy_function_name, 2, internal, user);
1749
1750 if (zend_hash_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) {
1751 zval_ptr_dtor(&internal);
1752 zval_ptr_dtor(&user);
1753 zval_dtor(return_value);
1754 zend_error(E_WARNING, "Cannot add internal functions to return value from get_defined_functions()");
1755 RETURN_FALSE;
1756 }
1757
1758 if (zend_hash_add(Z_ARRVAL_P(return_value), "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) {
1759 zval_ptr_dtor(&user);
1760 zval_dtor(return_value);
1761 zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()");
1762 RETURN_FALSE;
1763 }
1764 }
1765 /* }}} */
1766
1767
1768 /* {{{ proto array get_defined_vars(void)
1769 Returns an associative array of names and values of all currently defined variable names (variables in the current scope) */
ZEND_FUNCTION(get_defined_vars)1770 ZEND_FUNCTION(get_defined_vars)
1771 {
1772 if (!EG(active_symbol_table)) {
1773 zend_rebuild_symbol_table(TSRMLS_C);
1774 }
1775
1776 array_init_size(return_value, zend_hash_num_elements(EG(active_symbol_table)));
1777
1778 zend_hash_copy(Z_ARRVAL_P(return_value), EG(active_symbol_table),
1779 (copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval *));
1780 }
1781 /* }}} */
1782
1783
1784 #define LAMBDA_TEMP_FUNCNAME "__lambda_func"
1785 /* {{{ proto string create_function(string args, string code)
1786 Creates an anonymous function, and returns its name (funny, eh?) */
ZEND_FUNCTION(create_function)1787 ZEND_FUNCTION(create_function)
1788 {
1789 char *eval_code, *function_name, *function_args, *function_code;
1790 int eval_code_length, function_name_length, function_args_len, function_code_len;
1791 int retval;
1792 char *eval_name;
1793
1794 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &function_args, &function_args_len, &function_code, &function_code_len) == FAILURE) {
1795 return;
1796 }
1797
1798 eval_code = (char *) emalloc(sizeof("function " LAMBDA_TEMP_FUNCNAME)
1799 +function_args_len
1800 +2 /* for the args parentheses */
1801 +2 /* for the curly braces */
1802 +function_code_len);
1803
1804 eval_code_length = sizeof("function " LAMBDA_TEMP_FUNCNAME "(") - 1;
1805 memcpy(eval_code, "function " LAMBDA_TEMP_FUNCNAME "(", eval_code_length);
1806
1807 memcpy(eval_code + eval_code_length, function_args, function_args_len);
1808 eval_code_length += function_args_len;
1809
1810 eval_code[eval_code_length++] = ')';
1811 eval_code[eval_code_length++] = '{';
1812
1813 memcpy(eval_code + eval_code_length, function_code, function_code_len);
1814 eval_code_length += function_code_len;
1815
1816 eval_code[eval_code_length++] = '}';
1817 eval_code[eval_code_length] = '\0';
1818
1819 eval_name = zend_make_compiled_string_description("runtime-created function" TSRMLS_CC);
1820 retval = zend_eval_stringl(eval_code, eval_code_length, NULL, eval_name TSRMLS_CC);
1821 efree(eval_code);
1822 efree(eval_name);
1823
1824 if (retval==SUCCESS) {
1825 zend_function new_function, *func;
1826
1827 if (zend_hash_find(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME), (void **) &func)==FAILURE) {
1828 zend_error(E_ERROR, "Unexpected inconsistency in create_function()");
1829 RETURN_FALSE;
1830 }
1831 new_function = *func;
1832 function_add_ref(&new_function);
1833
1834 function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
1835 function_name[0] = '\0';
1836
1837 do {
1838 function_name_length = 1 + snprintf(function_name + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count));
1839 } while (zend_hash_add(EG(function_table), function_name, function_name_length+1, &new_function, sizeof(zend_function), NULL)==FAILURE);
1840 zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
1841 RETURN_STRINGL(function_name, function_name_length, 0);
1842 } else {
1843 zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
1844 RETURN_FALSE;
1845 }
1846 }
1847 /* }}} */
1848
1849
1850 #if ZEND_DEBUG
ZEND_FUNCTION(zend_test_func)1851 ZEND_FUNCTION(zend_test_func)
1852 {
1853 zval *arg1, *arg2;
1854
1855 zend_get_parameters(ht, 2, &arg1, &arg2);
1856 }
1857
1858
1859 #ifdef ZTS
ZEND_FUNCTION(zend_thread_id)1860 ZEND_FUNCTION(zend_thread_id)
1861 {
1862 RETURN_LONG((long)tsrm_thread_id());
1863 }
1864 #endif
1865 #endif
1866
1867 /* {{{ proto string get_resource_type(resource res)
1868 Get the resource type name for a given resource */
ZEND_FUNCTION(get_resource_type)1869 ZEND_FUNCTION(get_resource_type)
1870 {
1871 const char *resource_type;
1872 zval *z_resource_type;
1873
1874 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_resource_type) == FAILURE) {
1875 return;
1876 }
1877
1878 resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_P(z_resource_type) TSRMLS_CC);
1879 if (resource_type) {
1880 RETURN_STRING(resource_type, 1);
1881 } else {
1882 RETURN_STRING("Unknown", 1);
1883 }
1884 }
1885 /* }}} */
1886
1887
add_extension_info(zend_module_entry * module,void * arg TSRMLS_DC)1888 static int add_extension_info(zend_module_entry *module, void *arg TSRMLS_DC)
1889 {
1890 zval *name_array = (zval *)arg;
1891 add_next_index_string(name_array, module->name, 1);
1892 return 0;
1893 }
1894
add_zendext_info(zend_extension * ext,void * arg TSRMLS_DC)1895 static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC)
1896 {
1897 zval *name_array = (zval *)arg;
1898 add_next_index_string(name_array, ext->name, 1);
1899 return 0;
1900 }
1901
add_constant_info(zend_constant * constant,void * arg TSRMLS_DC)1902 static int add_constant_info(zend_constant *constant, void *arg TSRMLS_DC)
1903 {
1904 zval *name_array = (zval *)arg;
1905 zval *const_val;
1906
1907 if (!constant->name) {
1908 /* skip special constants */
1909 return 0;
1910 }
1911
1912 MAKE_STD_ZVAL(const_val);
1913 *const_val = constant->value;
1914 zval_copy_ctor(const_val);
1915 INIT_PZVAL(const_val);
1916 add_assoc_zval_ex(name_array, constant->name, constant->name_len, const_val);
1917 return 0;
1918 }
1919
1920
1921 /* {{{ proto array get_loaded_extensions([bool zend_extensions]) U
1922 Return an array containing names of loaded extensions */
ZEND_FUNCTION(get_loaded_extensions)1923 ZEND_FUNCTION(get_loaded_extensions)
1924 {
1925 zend_bool zendext = 0;
1926
1927 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &zendext) == FAILURE) {
1928 return;
1929 }
1930
1931 array_init(return_value);
1932
1933 if (zendext) {
1934 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) add_zendext_info, return_value TSRMLS_CC);
1935 } else {
1936 zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) add_extension_info, return_value TSRMLS_CC);
1937 }
1938 }
1939 /* }}} */
1940
1941
1942 /* {{{ proto array get_defined_constants([bool categorize])
1943 Return an array containing the names and values of all defined constants */
ZEND_FUNCTION(get_defined_constants)1944 ZEND_FUNCTION(get_defined_constants)
1945 {
1946 zend_bool categorize = 0;
1947
1948 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &categorize) == FAILURE) {
1949 return;
1950 }
1951
1952 array_init(return_value);
1953
1954 if (categorize) {
1955 HashPosition pos;
1956 zend_constant *val;
1957 int module_number;
1958 zval **modules;
1959 char **module_names;
1960 zend_module_entry *module;
1961 int i = 1;
1962
1963 modules = ecalloc(zend_hash_num_elements(&module_registry) + 2, sizeof(zval *));
1964 module_names = emalloc((zend_hash_num_elements(&module_registry) + 2) * sizeof(char *));
1965
1966 module_names[0] = "internal";
1967 zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
1968 while (zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) != FAILURE) {
1969 module_names[module->module_number] = (char *)module->name;
1970 i++;
1971 zend_hash_move_forward_ex(&module_registry, &pos);
1972 }
1973 module_names[i] = "user";
1974
1975 zend_hash_internal_pointer_reset_ex(EG(zend_constants), &pos);
1976 while (zend_hash_get_current_data_ex(EG(zend_constants), (void **) &val, &pos) != FAILURE) {
1977 zval *const_val;
1978
1979 if (!val->name) {
1980 /* skip special constants */
1981 goto next_constant;
1982 }
1983
1984 if (val->module_number == PHP_USER_CONSTANT) {
1985 module_number = i;
1986 } else if (val->module_number > i || val->module_number < 0) {
1987 /* should not happen */
1988 goto next_constant;
1989 } else {
1990 module_number = val->module_number;
1991 }
1992
1993 if (!modules[module_number]) {
1994 MAKE_STD_ZVAL(modules[module_number]);
1995 array_init(modules[module_number]);
1996 add_assoc_zval(return_value, module_names[module_number], modules[module_number]);
1997 }
1998
1999 MAKE_STD_ZVAL(const_val);
2000 *const_val = val->value;
2001 zval_copy_ctor(const_val);
2002 INIT_PZVAL(const_val);
2003
2004 add_assoc_zval_ex(modules[module_number], val->name, val->name_len, const_val);
2005 next_constant:
2006 zend_hash_move_forward_ex(EG(zend_constants), &pos);
2007 }
2008 efree(module_names);
2009 efree(modules);
2010 } else {
2011 zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) add_constant_info, return_value TSRMLS_CC);
2012 }
2013 }
2014 /* }}} */
2015
2016
debug_backtrace_get_args(void ** curpos TSRMLS_DC)2017 static zval *debug_backtrace_get_args(void **curpos TSRMLS_DC)
2018 {
2019 void **p = curpos;
2020 zval *arg_array, **arg;
2021 int arg_count = (int)(zend_uintptr_t) *p;
2022
2023 MAKE_STD_ZVAL(arg_array);
2024 array_init_size(arg_array, arg_count);
2025 p -= arg_count;
2026
2027 while (--arg_count >= 0) {
2028 arg = (zval **) p++;
2029 if (*arg) {
2030 if (Z_TYPE_PP(arg) != IS_OBJECT) {
2031 SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
2032 }
2033 Z_ADDREF_PP(arg);
2034 add_next_index_zval(arg_array, *arg);
2035 } else {
2036 add_next_index_null(arg_array);
2037 }
2038 }
2039
2040 return arg_array;
2041 }
2042
debug_print_backtrace_args(zval * arg_array TSRMLS_DC)2043 void debug_print_backtrace_args(zval *arg_array TSRMLS_DC)
2044 {
2045 zval **tmp;
2046 HashPosition iterator;
2047 int i = 0;
2048
2049 zend_hash_internal_pointer_reset_ex(arg_array->value.ht, &iterator);
2050 while (zend_hash_get_current_data_ex(arg_array->value.ht, (void **) &tmp, &iterator) == SUCCESS) {
2051 if (i++) {
2052 ZEND_PUTS(", ");
2053 }
2054 zend_print_flat_zval_r(*tmp TSRMLS_CC);
2055 zend_hash_move_forward_ex(arg_array->value.ht, &iterator);
2056 }
2057 }
2058
2059 /* {{{ proto void debug_print_backtrace([int options[, int limit]]) */
ZEND_FUNCTION(debug_print_backtrace)2060 ZEND_FUNCTION(debug_print_backtrace)
2061 {
2062 zend_execute_data *ptr, *skip;
2063 int lineno, frameno = 0;
2064 const char *function_name;
2065 const char *filename;
2066 const char *class_name = NULL;
2067 char *call_type;
2068 const char *include_filename = NULL;
2069 zval *arg_array = NULL;
2070 int indent = 0;
2071 long options = 0;
2072 long limit = 0;
2073
2074 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
2075 return;
2076 }
2077
2078 ptr = EG(current_execute_data);
2079
2080 /* skip debug_backtrace() */
2081 ptr = ptr->prev_execute_data;
2082
2083 while (ptr && (limit == 0 || frameno < limit)) {
2084 const char *free_class_name = NULL;
2085
2086 frameno++;
2087 class_name = call_type = NULL;
2088 arg_array = NULL;
2089
2090 skip = ptr;
2091 /* skip internal handler */
2092 if (!skip->op_array &&
2093 skip->prev_execute_data &&
2094 skip->prev_execute_data->opline &&
2095 skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL &&
2096 skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL_BY_NAME &&
2097 skip->prev_execute_data->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2098 skip = skip->prev_execute_data;
2099 }
2100
2101 if (skip->op_array) {
2102 filename = skip->op_array->filename;
2103 lineno = skip->opline->lineno;
2104 } else {
2105 filename = NULL;
2106 lineno = 0;
2107 }
2108
2109 function_name = (ptr->function_state.function->common.scope &&
2110 ptr->function_state.function->common.scope->trait_aliases) ?
2111 zend_resolve_method_name(
2112 ptr->object ?
2113 Z_OBJCE_P(ptr->object) :
2114 ptr->function_state.function->common.scope,
2115 ptr->function_state.function) :
2116 ptr->function_state.function->common.function_name;
2117
2118 if (function_name) {
2119 if (ptr->object) {
2120 if (ptr->function_state.function->common.scope) {
2121 class_name = ptr->function_state.function->common.scope->name;
2122 } else {
2123 zend_uint class_name_len;
2124 int dup;
2125
2126 dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
2127 if(!dup) {
2128 free_class_name = class_name;
2129 }
2130 }
2131
2132 call_type = "->";
2133 } else if (ptr->function_state.function->common.scope) {
2134 class_name = ptr->function_state.function->common.scope->name;
2135 call_type = "::";
2136 } else {
2137 class_name = NULL;
2138 call_type = NULL;
2139 }
2140 if ((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL))) {
2141 if (ptr->function_state.arguments && (options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0) {
2142 arg_array = debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC);
2143 }
2144 }
2145 } else {
2146 /* i know this is kinda ugly, but i'm trying to avoid extra cycles in the main execution loop */
2147 zend_bool build_filename_arg = 1;
2148
2149 if (!ptr->opline || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2150 /* can happen when calling eval from a custom sapi */
2151 function_name = "unknown";
2152 build_filename_arg = 0;
2153 } else
2154 switch (ptr->opline->extended_value) {
2155 case ZEND_EVAL:
2156 function_name = "eval";
2157 build_filename_arg = 0;
2158 break;
2159 case ZEND_INCLUDE:
2160 function_name = "include";
2161 break;
2162 case ZEND_REQUIRE:
2163 function_name = "require";
2164 break;
2165 case ZEND_INCLUDE_ONCE:
2166 function_name = "include_once";
2167 break;
2168 case ZEND_REQUIRE_ONCE:
2169 function_name = "require_once";
2170 break;
2171 default:
2172 /* this can actually happen if you use debug_backtrace() in your error_handler and
2173 * you're in the top-scope */
2174 function_name = "unknown";
2175 build_filename_arg = 0;
2176 break;
2177 }
2178
2179 if (build_filename_arg && include_filename) {
2180 MAKE_STD_ZVAL(arg_array);
2181 array_init(arg_array);
2182 add_next_index_string(arg_array, (char*)include_filename, 1);
2183 }
2184 call_type = NULL;
2185 }
2186 zend_printf("#%-2d ", indent);
2187 if (class_name) {
2188 ZEND_PUTS(class_name);
2189 ZEND_PUTS(call_type);
2190 }
2191 zend_printf("%s(", function_name);
2192 if (arg_array) {
2193 debug_print_backtrace_args(arg_array TSRMLS_CC);
2194 zval_ptr_dtor(&arg_array);
2195 }
2196 if (filename) {
2197 zend_printf(") called at [%s:%d]\n", filename, lineno);
2198 } else {
2199 zend_execute_data *prev = skip->prev_execute_data;
2200
2201 while (prev) {
2202 if (prev->function_state.function &&
2203 prev->function_state.function->common.type != ZEND_USER_FUNCTION) {
2204 prev = NULL;
2205 break;
2206 }
2207 if (prev->op_array) {
2208 zend_printf(") called at [%s:%d]\n", prev->op_array->filename, prev->opline->lineno);
2209 break;
2210 }
2211 prev = prev->prev_execute_data;
2212 }
2213 if (!prev) {
2214 ZEND_PUTS(")\n");
2215 }
2216 }
2217 include_filename = filename;
2218 ptr = skip->prev_execute_data;
2219 ++indent;
2220 if (free_class_name) {
2221 efree((char*)free_class_name);
2222 }
2223 }
2224 }
2225
2226 /* }}} */
2227
zend_fetch_debug_backtrace(zval * return_value,int skip_last,int options,int limit TSRMLS_DC)2228 ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC)
2229 {
2230 zend_execute_data *ptr, *skip;
2231 int lineno, frameno = 0;
2232 const char *function_name;
2233 const char *filename;
2234 const char *class_name;
2235 const char *include_filename = NULL;
2236 zval *stack_frame;
2237
2238 ptr = EG(current_execute_data);
2239
2240 /* skip "new Exception()" */
2241 if (ptr && (skip_last == 0) && ptr->opline && (ptr->opline->opcode == ZEND_NEW)) {
2242 ptr = ptr->prev_execute_data;
2243 }
2244
2245 /* skip debug_backtrace() */
2246 if (skip_last-- && ptr) {
2247 ptr = ptr->prev_execute_data;
2248 }
2249
2250 array_init(return_value);
2251
2252 while (ptr && (limit == 0 || frameno < limit)) {
2253 frameno++;
2254 MAKE_STD_ZVAL(stack_frame);
2255 array_init(stack_frame);
2256
2257 skip = ptr;
2258 /* skip internal handler */
2259 if (!skip->op_array &&
2260 skip->prev_execute_data &&
2261 skip->prev_execute_data->opline &&
2262 skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL &&
2263 skip->prev_execute_data->opline->opcode != ZEND_DO_FCALL_BY_NAME &&
2264 skip->prev_execute_data->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2265 skip = skip->prev_execute_data;
2266 }
2267
2268 if (skip->op_array) {
2269 filename = skip->op_array->filename;
2270 lineno = skip->opline->lineno;
2271 add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)filename, 1);
2272 add_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno);
2273
2274 /* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
2275 * and debug_baktrace() might have been called by the error_handler. in this case we don't
2276 * want to pop anything of the argument-stack */
2277 } else {
2278 zend_execute_data *prev = skip->prev_execute_data;
2279
2280 while (prev) {
2281 if (prev->function_state.function &&
2282 prev->function_state.function->common.type != ZEND_USER_FUNCTION &&
2283 !(prev->function_state.function->common.type == ZEND_INTERNAL_FUNCTION &&
2284 (prev->function_state.function->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER))) {
2285 break;
2286 }
2287 if (prev->op_array) {
2288 add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)prev->op_array->filename, 1);
2289 add_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno);
2290 break;
2291 }
2292 prev = prev->prev_execute_data;
2293 }
2294 filename = NULL;
2295 }
2296
2297 function_name = (ptr->function_state.function->common.scope &&
2298 ptr->function_state.function->common.scope->trait_aliases) ?
2299 zend_resolve_method_name(
2300 ptr->object ?
2301 Z_OBJCE_P(ptr->object) :
2302 ptr->function_state.function->common.scope,
2303 ptr->function_state.function) :
2304 ptr->function_state.function->common.function_name;
2305
2306 if (function_name) {
2307 add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
2308
2309 if (ptr->object && Z_TYPE_P(ptr->object) == IS_OBJECT) {
2310 if (ptr->function_state.function->common.scope) {
2311 add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
2312 } else {
2313 zend_uint class_name_len;
2314 int dup;
2315
2316 dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
2317 add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)class_name, dup);
2318
2319 }
2320 if ((options & DEBUG_BACKTRACE_PROVIDE_OBJECT) != 0) {
2321 add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object);
2322 Z_ADDREF_P(ptr->object);
2323 }
2324
2325 add_assoc_string_ex(stack_frame, "type", sizeof("type"), "->", 1);
2326 } else if (ptr->function_state.function->common.scope) {
2327 add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
2328 add_assoc_string_ex(stack_frame, "type", sizeof("type"), "::", 1);
2329 }
2330
2331 if ((options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0 &&
2332 ((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL)))) {
2333 if (ptr->function_state.arguments) {
2334 add_assoc_zval_ex(stack_frame, "args", sizeof("args"), debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC));
2335 }
2336 }
2337 } else {
2338 /* i know this is kinda ugly, but i'm trying to avoid extra cycles in the main execution loop */
2339 zend_bool build_filename_arg = 1;
2340
2341 if (!ptr->opline || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
2342 /* can happen when calling eval from a custom sapi */
2343 function_name = "unknown";
2344 build_filename_arg = 0;
2345 } else
2346 switch (ptr->opline->extended_value) {
2347 case ZEND_EVAL:
2348 function_name = "eval";
2349 build_filename_arg = 0;
2350 break;
2351 case ZEND_INCLUDE:
2352 function_name = "include";
2353 break;
2354 case ZEND_REQUIRE:
2355 function_name = "require";
2356 break;
2357 case ZEND_INCLUDE_ONCE:
2358 function_name = "include_once";
2359 break;
2360 case ZEND_REQUIRE_ONCE:
2361 function_name = "require_once";
2362 break;
2363 default:
2364 /* this can actually happen if you use debug_backtrace() in your error_handler and
2365 * you're in the top-scope */
2366 function_name = "unknown";
2367 build_filename_arg = 0;
2368 break;
2369 }
2370
2371 if (build_filename_arg && include_filename) {
2372 zval *arg_array;
2373
2374 MAKE_STD_ZVAL(arg_array);
2375 array_init(arg_array);
2376
2377 /* include_filename always points to the last filename of the last last called-function.
2378 if we have called include in the frame above - this is the file we have included.
2379 */
2380
2381 add_next_index_string(arg_array, (char*)include_filename, 1);
2382 add_assoc_zval_ex(stack_frame, "args", sizeof("args"), arg_array);
2383 }
2384
2385 add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
2386 }
2387
2388 add_next_index_zval(return_value, stack_frame);
2389
2390 include_filename = filename;
2391
2392 ptr = skip->prev_execute_data;
2393 }
2394 }
2395 /* }}} */
2396
2397
2398 /* {{{ proto array debug_backtrace([int options[, int limit]])
2399 Return backtrace as array */
ZEND_FUNCTION(debug_backtrace)2400 ZEND_FUNCTION(debug_backtrace)
2401 {
2402 long options = DEBUG_BACKTRACE_PROVIDE_OBJECT;
2403 long limit = 0;
2404
2405 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
2406 return;
2407 }
2408
2409 zend_fetch_debug_backtrace(return_value, 1, options, limit TSRMLS_CC);
2410 }
2411 /* }}} */
2412
2413 /* {{{ proto bool extension_loaded(string extension_name)
2414 Returns true if the named extension is loaded */
ZEND_FUNCTION(extension_loaded)2415 ZEND_FUNCTION(extension_loaded)
2416 {
2417 char *extension_name;
2418 int extension_name_len;
2419 char *lcname;
2420
2421 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
2422 return;
2423 }
2424
2425 lcname = zend_str_tolower_dup(extension_name, extension_name_len);
2426 if (zend_hash_exists(&module_registry, lcname, extension_name_len+1)) {
2427 RETVAL_TRUE;
2428 } else {
2429 RETVAL_FALSE;
2430 }
2431 efree(lcname);
2432 }
2433 /* }}} */
2434
2435
2436 /* {{{ proto array get_extension_funcs(string extension_name)
2437 Returns an array with the names of functions belonging to the named extension */
ZEND_FUNCTION(get_extension_funcs)2438 ZEND_FUNCTION(get_extension_funcs)
2439 {
2440 char *extension_name, *lcname;
2441 int extension_name_len, array;
2442 zend_module_entry *module;
2443 HashPosition iterator;
2444 zend_function *zif;
2445 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
2446 return;
2447 }
2448 if (strncasecmp(extension_name, "zend", sizeof("zend"))) {
2449 lcname = zend_str_tolower_dup(extension_name, extension_name_len);
2450 } else {
2451 lcname = estrdup("core");
2452 }
2453 if (zend_hash_find(&module_registry, lcname,
2454 extension_name_len+1, (void**)&module) == FAILURE) {
2455 efree(lcname);
2456 RETURN_FALSE;
2457 }
2458
2459 zend_hash_internal_pointer_reset_ex(CG(function_table), &iterator);
2460 if (module->functions) {
2461 /* avoid BC break, if functions list is empty, will return an empty array */
2462 array_init(return_value);
2463 array = 1;
2464 } else {
2465 array = 0;
2466 }
2467 while (zend_hash_get_current_data_ex(CG(function_table), (void **) &zif, &iterator) == SUCCESS) {
2468 if (zif->common.type==ZEND_INTERNAL_FUNCTION
2469 && zif->internal_function.module == module) {
2470 if (!array) {
2471 array_init(return_value);
2472 array = 1;
2473 }
2474 add_next_index_string(return_value, zif->common.function_name, 1);
2475 }
2476 zend_hash_move_forward_ex(CG(function_table), &iterator);
2477 }
2478
2479 efree(lcname);
2480
2481 if (!array) {
2482 RETURN_FALSE;
2483 }
2484 }
2485 /* }}} */
2486
2487 /*
2488 * Local variables:
2489 * tab-width: 4
2490 * c-basic-offset: 4
2491 * indent-tabs-mode: t
2492 * End:
2493 */
2494
